Geant4 11.3.0
Toolkit for the simulation of the passage of particles through matter
Loading...
Searching...
No Matches
G4VisCommandsViewerSet.cc
Go to the documentation of this file.
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27
28// /vis/viewer/set commands - John Allison 16th May 2000
29
30#include "G4VisCommandsViewerSet.hh"
31
32#include "G4UIcommand.hh"
33#include "G4UIcmdWithoutParameter.hh"
34#include "G4UIcmdWithAString.hh"
35#include "G4UIcmdWithABool.hh"
36#include "G4UIcmdWithAnInteger.hh"
37#include "G4UIcmdWithADouble.hh"
38#include "G4UIcmdWith3VectorAndUnit.hh"
39#include "G4UnitsTable.hh"
40#include "G4VisManager.hh"
41#include "G4Polyhedron.hh"
42#include "G4SystemOfUnits.hh"
43
44#include <sstream>
45#include <iomanip>
46#include <utility>
47
48#define G4warn G4cout
49
50G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
51fLightsVector (G4ThreeVector(1.,1.,1.)),
52fUpVector (G4ThreeVector(0.,1.,0.)),
53fViewpointVector (G4ThreeVector(0.,0.,1.))
54{
55 G4bool omitable;
56 G4UIparameter* parameter;
57
58 fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
59 fpCommandAll->SetGuidance
60 ("Copies view parameters.");
61 fpCommandAll->SetGuidance
62 ("Copies ALL view parameters (except the autoRefresh status) from"
63 "\nfrom-viewer to current viewer. You may need \"/vis/viewer/rebuild\".");
64 fpCommandAll->SetGuidance
65 ("Note: to copy only the camera-specific parameters use"
66 "\n\"/vis/viewer/copyfrom\".");
67 fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
68
69 fpCommandAutoRefresh = new G4UIcmdWithABool
70 ("/vis/viewer/set/autoRefresh",this);
71 fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
72 fpCommandAutoRefresh->SetGuidance
73 ("If true, view is automatically refreshed after a change of"
74 "\nview parameters.");
75 fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
76 fpCommandAutoRefresh->SetDefaultValue(true);
77
78 fpCommandAuxEdge = new G4UIcmdWithABool
79 ("/vis/viewer/set/auxiliaryEdge",this);
80 fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
81 fpCommandAuxEdge->SetGuidance
82 ("Auxiliary edges, i.e., those that are part of a curved surface,"
83 "\nsometimes called soft edges, become visible/invisible.");
84 fpCommandAuxEdge->SetParameterName("edge",omitable = true);
85 fpCommandAuxEdge->SetDefaultValue(true);
86
87 fpCommandBackground = new G4UIcommand
88 ("/vis/viewer/set/background",this);
89 fpCommandBackground->SetGuidance
90 ("Set background colour and transparency (default black and opaque).");
91 fpCommandBackground->SetGuidance(ConvertToColourGuidance());
92 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
93 parameter -> SetDefaultValue ("0.");
94 fpCommandBackground -> SetParameter (parameter);
95 parameter = new G4UIparameter("green", 'd', omitable = true);
96 parameter -> SetDefaultValue (0.);
97 fpCommandBackground -> SetParameter (parameter);
98 parameter = new G4UIparameter ("blue", 'd', omitable = true);
99 parameter -> SetDefaultValue (0.);
100 fpCommandBackground -> SetParameter (parameter);
101 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
102 parameter -> SetDefaultValue (1.);
103 fpCommandBackground -> SetParameter (parameter);
104
105 fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106 fpCommandCulling->SetGuidance ("Set culling options.");
107 fpCommandCulling->SetGuidance
108 ("\"global\": enables/disables all other culling options.");
109 fpCommandCulling->SetGuidance
110 ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
111 "\nbe seen because covered by ancestor volumes in surface drawing mode,"
112 "\nand then only if the ancestors are visible and opaque, and then only"
113 "\nif no sections or cutaways are in operation. Intended solely to"
114 "\nimprove the speed of rendering visible volumes.");
115 fpCommandCulling->SetGuidance
116 ("\"invisible\": culls objects with the invisible attribute set.");
117 fpCommandCulling->SetGuidance
118 ("\"density\": culls volumes with density lower than threshold. Useful"
119 "\nfor eliminating \"container volumes\" with no physical correspondence,"
120 "\nwhose material is usually air. If this is selected, provide threshold"
121 "\ndensity and unit (e.g., g/cm3, mg/cm3 or kg/m3)."
122 );
123 parameter = new G4UIparameter("culling-option",'s',omitable = false);
124 parameter->SetParameterCandidates
125 ("global coveredDaughters invisible density");
126 fpCommandCulling->SetParameter(parameter);
127 parameter = new G4UIparameter("action",'b',omitable = true);
128 parameter->SetDefaultValue(1);
129 fpCommandCulling->SetParameter(parameter);
130 parameter = new G4UIparameter("density-threshold",'d',omitable = true);
131 parameter->SetDefaultValue("0.01");
132 fpCommandCulling->SetParameter(parameter);
133 parameter = new G4UIparameter("unit",'s',omitable = true);
134 // parameter->SetParameterCandidates ("g/cm3 mg/cm3 kg/m3");
135 // Instead of the above, SetNewValue accepts *any* density unit.
136 parameter->SetDefaultValue("g/cm3");
137 fpCommandCulling->SetParameter(parameter);
138
139 fpCommandCutawayMode =
140 new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
141 fpCommandCutawayMode->SetGuidance
142 ("Sets cutaway mode - add (union) or multiply (intersection).");
143 fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
144 fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
145 fpCommandCutawayMode->SetDefaultValue("union");
146
147 fpCommandDefaultColour = new G4UIcommand
148 ("/vis/viewer/set/defaultColour",this);
149 fpCommandDefaultColour->SetGuidance
150 ("Set defaultColour colour and transparency (default white and opaque).");
151 fpCommandDefaultColour->SetGuidance(ConvertToColourGuidance());
152 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
153 parameter -> SetDefaultValue ("1.");
154 fpCommandDefaultColour -> SetParameter (parameter);
155 parameter = new G4UIparameter("green", 'd', omitable = true);
156 parameter -> SetDefaultValue (1.);
157 fpCommandDefaultColour -> SetParameter (parameter);
158 parameter = new G4UIparameter ("blue", 'd', omitable = true);
159 parameter -> SetDefaultValue (1.);
160 fpCommandDefaultColour -> SetParameter (parameter);
161 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
162 parameter -> SetDefaultValue (1.);
163 fpCommandDefaultColour -> SetParameter (parameter);
164
165 fpCommandDefaultTextColour = new G4UIcommand
166 ("/vis/viewer/set/defaultTextColour",this);
167 fpCommandDefaultTextColour->SetGuidance
168 ("Set defaultTextColour colour and transparency (default blue and opaque).");
169 fpCommandDefaultTextColour->SetGuidance(ConvertToColourGuidance());
170 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
171 parameter -> SetDefaultValue ("0.");
172 fpCommandDefaultTextColour -> SetParameter (parameter);
173 parameter = new G4UIparameter("green", 'd', omitable = true);
174 parameter -> SetDefaultValue (0.);
175 fpCommandDefaultTextColour -> SetParameter (parameter);
176 parameter = new G4UIparameter ("blue", 'd', omitable = true);
177 parameter -> SetDefaultValue (1.);
178 fpCommandDefaultTextColour -> SetParameter (parameter);
179 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
180 parameter -> SetDefaultValue (1.);
181 fpCommandDefaultTextColour -> SetParameter (parameter);
182
183 fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
184 fpCommandEdge->SetGuidance
185 ("Edges become visible/invisible in surface mode.");
186 fpCommandEdge->SetParameterName("edge",omitable = true);
187 fpCommandEdge->SetDefaultValue(true);
188
189 fpCommandExplodeFactor = new G4UIcommand
190 ("/vis/viewer/set/explodeFactor", this);
191 fpCommandExplodeFactor->SetGuidance
192 ("Moves top-level drawn volumes by this factor from this centre.");
193 parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
194 parameter->SetParameterRange("explodeFactor>=1.");
195 parameter->SetDefaultValue(1.);
196 fpCommandExplodeFactor->SetParameter(parameter);
197 parameter = new G4UIparameter("x",'d',omitable = true);
198 parameter->SetDefaultValue (0);
199 parameter->SetGuidance ("Coordinate of explode centre.");
200 fpCommandExplodeFactor->SetParameter(parameter);
201 parameter = new G4UIparameter("y",'d',omitable = true);
202 parameter->SetDefaultValue (0);
203 parameter->SetGuidance ("Coordinate of explode centre.");
204 fpCommandExplodeFactor->SetParameter(parameter);
205 parameter = new G4UIparameter("z",'d',omitable = true);
206 parameter->SetDefaultValue (0);
207 parameter->SetGuidance ("Coordinate of explode centre.");
208 fpCommandExplodeFactor->SetParameter(parameter);
209 parameter = new G4UIparameter("unit",'s',omitable = true);
210 parameter->SetDefaultValue ("m");
211 parameter->SetGuidance ("Unit of explode centre.");
212 fpCommandExplodeFactor->SetParameter(parameter);
213
214 fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
215 ("/vis/viewer/set/globalLineWidthScale", this);
216 fpCommandGlobalLineWidthScale->SetGuidance
217 ("Multiplies line widths by this factor.");
218 fpCommandGlobalLineWidthScale->
219 SetParameterName("scale-factor", omitable=true);
220 fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
221
222 fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
223 ("/vis/viewer/set/globalMarkerScale", this);
224 fpCommandGlobalMarkerScale->SetGuidance
225 ("Multiplies marker sizes by this factor.");
226 fpCommandGlobalMarkerScale->
227 SetParameterName("scale-factor", omitable=true);
228 fpCommandGlobalMarkerScale->SetDefaultValue(1.);
229
230 fpCommandHiddenEdge =
231 new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
232 fpCommandHiddenEdge->SetGuidance
233 ("Edges become hidden/seen in wireframe or surface mode.");
234 fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
235 fpCommandHiddenEdge->SetDefaultValue(true);
236
237 fpCommandHiddenMarker =
238 new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
239 fpCommandHiddenMarker->SetGuidance
240 ("If true, closer objects hide markers. Otherwise, markers always show.");
241 fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
242 fpCommandHiddenMarker->SetDefaultValue(true);
243
244 fpCommandLightsMove = new G4UIcmdWithAString
245 ("/vis/viewer/set/lightsMove",this);
246 fpCommandLightsMove->SetGuidance
247 ("Lights move with camera or with object");
248 fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
249 fpCommandLightsMove->SetCandidates
250 ("cam camera with-camera obj object with-object");
251
252 fpCommandLightsThetaPhi = new G4UIcommand
253 ("/vis/viewer/set/lightsThetaPhi", this);
254 fpCommandLightsThetaPhi->SetGuidance
255 ("Set direction from target to lights.");
256 parameter = new G4UIparameter("theta", 'd', omitable = true);
257 parameter -> SetDefaultValue(60.);
258 fpCommandLightsThetaPhi -> SetParameter (parameter);
259 parameter = new G4UIparameter("phi", 'd', omitable = true);
260 parameter -> SetDefaultValue(45.);
261 fpCommandLightsThetaPhi -> SetParameter (parameter);
262 parameter = new G4UIparameter ("unit", 's', omitable = true);
263 parameter -> SetDefaultValue ("deg");
264 fpCommandLightsThetaPhi -> SetParameter (parameter);
265
266 fpCommandLightsVector = new G4UIcommand
267 ("/vis/viewer/set/lightsVector", this);
268 fpCommandLightsVector->SetGuidance
269 ("Set direction from target to lights.");
270 parameter = new G4UIparameter("x", 'd', omitable = true);
271 parameter -> SetDefaultValue (1);
272 fpCommandLightsVector -> SetParameter (parameter);
273 parameter = new G4UIparameter("y", 'd', omitable = true);
274 parameter -> SetDefaultValue (1);
275 fpCommandLightsVector -> SetParameter (parameter);
276 parameter = new G4UIparameter ("z", 'd', omitable = true);
277 parameter -> SetDefaultValue (1);
278 fpCommandLightsVector -> SetParameter (parameter);
279
280 fpCommandLineSegments = new G4UIcmdWithAnInteger
281 ("/vis/viewer/set/lineSegmentsPerCircle",this);
282 fpCommandLineSegments->SetGuidance
283 ("Set number of sides per circle for polygon/polyhedron drawing.");
284 fpCommandLineSegments->SetGuidance
285 ("Refers to graphical representation of objects with curved lines/surfaces.");
286 fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
287 fpCommandLineSegments->SetDefaultValue(24);
288
289 fpCommandLineWidth = new G4UIcmdWithoutParameter
290 ("/vis/viewer/set/lineWidth",this);
291 fpCommandLineWidth->SetGuidance
292 ("Use \"/vis/viewer/set/globalLineWidthScale\" instead."
293 "\nFor trajectories use \"/vis/modeling/trajectories/*/default/setLineWidth\"."
294 "\nFor volumes use \"/vis/geometry/set/lineWidth\".");
295
296 fpCommandNumberOfCloudPoints = new G4UIcmdWithAnInteger
297 ("/vis/viewer/set/numberOfCloudPoints",this);
298 fpCommandNumberOfCloudPoints->SetGuidance
299 ("Set number of points to be used for cloud representation of volumes.");
300 fpCommandNumberOfCloudPoints->SetParameterName("points",omitable = true);
301 fpCommandNumberOfCloudPoints->SetDefaultValue(10000);
302
303 fpCommandPicking = new G4UIcmdWithABool
304 ("/vis/viewer/set/picking",this);
305 fpCommandPicking->SetGuidance("Sets picking, if available.");
306 fpCommandPicking->SetGuidance
307 ("If true, view is set up for picking, if available.");
308 fpCommandPicking->SetGuidance
309 ("You may need to issue \"/vis/viewer/update\".");
310 fpCommandPicking->SetGuidance
311 ("For required actions, watch for instructions for viewer.");
312 fpCommandPicking->SetParameterName("picking",omitable = true);
313 fpCommandPicking->SetDefaultValue(true);
314
315 fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
316 fpCommandProjection->SetGuidance
317 ("Set projection style - o[rthogonal] or p[erspective]."
318 "\nIf p[erspective], also set field half angle.");
319 parameter = new G4UIparameter("projection",'s',omitable = true);
320 parameter->SetParameterCandidates("o orthogonal p perspective");
321 parameter->SetDefaultValue("orthogonal");
322 fpCommandProjection->SetParameter(parameter);
323 parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
324 parameter->SetDefaultValue(30.);
325 //parameter->SetCurrentAsDefault(true);
326 fpCommandProjection->SetParameter(parameter);
327 parameter = new G4UIparameter("unit",'s',omitable = true);
328 parameter->SetDefaultValue("deg");
329 //parameter->SetCurrentAsDefault(true);
330 fpCommandProjection->SetParameter(parameter);
331
332 fpCommandRotationStyle = new G4UIcmdWithAString
333 ("/vis/viewer/set/rotationStyle",this);
334 fpCommandRotationStyle->SetGuidance
335 ("Set style of rotation - constrainUpDirection or freeRotation.");
336 fpCommandRotationStyle->SetGuidance
337 ("constrainUpDirection: conventional HEP view.");
338 fpCommandRotationStyle->SetGuidance
339 ("freeRotation: Google-like rotation, using mouse-grab.");
340 fpCommandRotationStyle->SetParameterName ("style",omitable = false);
341 fpCommandRotationStyle->SetCandidates("constrainUpDirection freeRotation");
342
343 fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
344 fpCommandSectionPlane -> SetGuidance
345 ("Set plane for drawing section (DCUT).");
346 fpCommandSectionPlane -> SetGuidance
347 ("E.g., for a y-z plane at x = 1 cm:"
348 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
349 "\nTo turn off: /vis/viewer/set/sectionPlane off");
350 parameter = new G4UIparameter("Selector",'c',true);
351 parameter -> SetDefaultValue ("on");
352 fpCommandSectionPlane->SetParameter(parameter);
353 parameter = new G4UIparameter("x",'d',omitable = true);
354 parameter -> SetDefaultValue (0);
355 parameter -> SetGuidance ("Coordinate of point on the plane.");
356 fpCommandSectionPlane->SetParameter(parameter);
357 parameter = new G4UIparameter("y",'d',omitable = true);
358 parameter -> SetDefaultValue (0);
359 parameter -> SetGuidance ("Coordinate of point on the plane.");
360 fpCommandSectionPlane->SetParameter(parameter);
361 parameter = new G4UIparameter("z",'d',omitable = true);
362 parameter -> SetDefaultValue (0);
363 parameter -> SetGuidance ("Coordinate of point on the plane.");
364 fpCommandSectionPlane->SetParameter(parameter);
365 parameter = new G4UIparameter("unit",'s',omitable = true);
366 parameter -> SetDefaultValue ("m");
367 parameter -> SetGuidance ("Unit of point on the plane.");
368 fpCommandSectionPlane->SetParameter(parameter);
369 parameter = new G4UIparameter("nx",'d',omitable = true);
370 parameter -> SetDefaultValue (1);
371 parameter -> SetGuidance ("Component of plane normal.");
372 fpCommandSectionPlane->SetParameter(parameter);
373 parameter = new G4UIparameter("ny",'d',omitable = true);
374 parameter -> SetDefaultValue (0);
375 parameter -> SetGuidance ("Component of plane normal.");
376 fpCommandSectionPlane->SetParameter(parameter);
377 parameter = new G4UIparameter("nz",'d',omitable = true);
378 parameter -> SetDefaultValue (0);
379 parameter -> SetGuidance ("Component of plane normal.");
380 fpCommandSectionPlane->SetParameter(parameter);
381
382 fpCommandSpecialMeshRendering = new G4UIcmdWithABool
383 ("/vis/viewer/set/specialMeshRendering",this);
384 fpCommandSpecialMeshRendering -> SetGuidance
385 ("Request special rendering of volumes (meshes) that use G4VParameterisation.");
386 fpCommandSpecialMeshRendering->SetParameterName("render",omitable = true);
387 fpCommandSpecialMeshRendering->SetDefaultValue(true);
388
389 fpCommandSpecialMeshRenderingOption = new G4UIcmdWithAString
390 ("/vis/viewer/set/specialMeshRenderingOption",this);
391 fpCommandSpecialMeshRenderingOption->SetGuidance
392 ("Set special mesh rendering option - \"default\", \"dots\" or \"surfaces\".");
393 fpCommandSpecialMeshRenderingOption->SetParameterName ("option",omitable = true);
394 fpCommandSpecialMeshRenderingOption->SetCandidates("default dots surfaces");
395 fpCommandSpecialMeshRenderingOption->SetDefaultValue("default");
396
397 fpCommandSpecialMeshVolumes = new G4UIcommand
398 ("/vis/viewer/set/specialMeshVolumes",this);
399 fpCommandSpecialMeshVolumes -> SetGuidance
400 ("Specify the volumes for special rendering. No arguments resets the list"
401 "\nand is interpreted to mean \"all found meshes\".");
402 fpCommandSpecialMeshVolumes->SetGuidance
403 ("Please provide a list of space-separated physical volume names and copy"
404 "\nnumber pairs. Negative copy number means \"all volumes of that name\".");
405 parameter = new G4UIparameter("volumes",'s',omitable = true);
406 parameter->SetGuidance
407 ("List of physical volume names and copy number pairs");
408 fpCommandSpecialMeshVolumes->SetParameter(parameter);
409
410 fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
411 fpCommandStyle->SetGuidance
412 ("Set style of drawing - w[ireframe] or s[urface] or c[loud].");
413 fpCommandStyle->SetGuidance
414 ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
415 fpCommandStyle->SetParameterName ("style",omitable = false);
416 fpCommandStyle->SetCandidates("w wireframe s surface c cloud");
417
418 fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
419 ("/vis/viewer/set/targetPoint", this);
420 fpCommandTargetPoint->SetGuidance
421 ("Set target point.");
422 fpCommandTargetPoint->SetGuidance
423 ("This sets the \"Current Target Point\" relative to the \"Standard");
424 fpCommandTargetPoint->SetGuidance
425 ("Target Point\" so that the actual target point is as requested.");
426 fpCommandTargetPoint->SetGuidance
427 ("(See G4ViewParameters.hh for an explanation of target points.)");
428 fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
429 fpCommandTargetPoint->SetUnitCategory("Length");
430
431 fpCommandUpThetaPhi = new G4UIcommand
432 ("/vis/viewer/set/upThetaPhi", this);
433 fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
434 fpCommandUpThetaPhi -> SetGuidance
435 ("Viewer will attempt always to show this direction upwards.");
436 parameter = new G4UIparameter("theta", 'd', omitable = true);
437 parameter -> SetDefaultValue (90.);
438 fpCommandUpThetaPhi -> SetParameter (parameter);
439 parameter = new G4UIparameter("phi", 'd', omitable = true);
440 parameter -> SetDefaultValue (90.);
441 fpCommandUpThetaPhi -> SetParameter (parameter);
442 parameter = new G4UIparameter ("unit", 's', omitable = true);
443 parameter -> SetDefaultValue ("deg");
444 fpCommandUpThetaPhi -> SetParameter (parameter);
445
446 fpCommandUpVector = new G4UIcommand
447 ("/vis/viewer/set/upVector", this);
448 fpCommandUpVector -> SetGuidance ("Set up vector.");
449 fpCommandUpVector -> SetGuidance
450 ("Viewer will attempt always to show this direction upwards.");
451 parameter = new G4UIparameter("x", 'd', omitable = true);
452 parameter -> SetDefaultValue (0.);
453 fpCommandUpVector -> SetParameter (parameter);
454 parameter = new G4UIparameter("y", 'd', omitable = true);
455 parameter -> SetDefaultValue (1.);
456 fpCommandUpVector -> SetParameter (parameter);
457 parameter = new G4UIparameter ("z", 'd', omitable = true);
458 parameter -> SetDefaultValue (0.);
459 fpCommandUpVector -> SetParameter (parameter);
460
461 fpCommandViewpointThetaPhi = new G4UIcommand
462 ("/vis/viewer/set/viewpointThetaPhi", this);
463 fpCommandViewpointThetaPhi -> SetGuidance
464 ("Set direction from target to camera.");
465 fpCommandViewpointThetaPhi -> SetGuidance
466 ("Also changes lightpoint direction if lights are set to move with camera.");
467 parameter = new G4UIparameter("theta", 'd', omitable = true);
468 parameter -> SetDefaultValue (60.);
469 fpCommandViewpointThetaPhi -> SetParameter (parameter);
470 parameter = new G4UIparameter("phi", 'd', omitable = true);
471 parameter -> SetDefaultValue (45.);
472 fpCommandViewpointThetaPhi -> SetParameter (parameter);
473 parameter = new G4UIparameter ("unit", 's', omitable = true);
474 parameter -> SetDefaultValue ("deg");
475 fpCommandViewpointThetaPhi -> SetParameter (parameter);
476
477 fpCommandViewpointVector = new G4UIcommand
478 ("/vis/viewer/set/viewpointVector", this);
479 fpCommandViewpointVector -> SetGuidance
480 ("Set direction from target to camera.");
481 fpCommandViewpointVector -> SetGuidance
482 ("Also changes lightpoint direction if lights are set to move with camera.");
483 parameter = new G4UIparameter("x", 'd', omitable = true);
484 parameter -> SetDefaultValue (1.);
485 fpCommandViewpointVector -> SetParameter (parameter);
486 parameter = new G4UIparameter("y", 'd', omitable = true);
487 parameter -> SetDefaultValue (1.);
488 fpCommandViewpointVector -> SetParameter (parameter);
489 parameter = new G4UIparameter ("z", 'd', omitable = true);
490 parameter -> SetDefaultValue (1.);
491 fpCommandViewpointVector -> SetParameter (parameter);
492
493 fpTimeWindowDirectory = new G4UIdirectory ("/vis/viewer/set/timeWindow/");
494 fpTimeWindowDirectory -> SetGuidance ("Set time window parameters of current viewer.");
495 G4String timeWindowGuidance =
496 "For these commands use"
497 "\n /vis/scene/add/trajectories rich"
498 "\n /vis/modeling/trajectories/drawByCharge-0/default/setTimeSliceInterval 0.01 ns"
499 "\nthen typically"
500 "\n /vis/viewer/set/timeWindow/displayLightFront true 0 0 -50 cm -0.5 ns"
501 "\n /vis/viewer/set/timeWindow/displayHeadTime true"
502 "\n /vis/viewer/set/timeWindow/fadeFactor 1"
503 "\n /run/beamOn # or several until you get a good event or events"
504 "\n /vis/viewer/set/timeWindow/startTime 0 ns 1 ns"
505 "\n /vis/viewer/save"
506 "\n /vis/viewer/set/timeWindow/startTime 1 ns 1 ns"
507 "\nthen zoom, pan etc to a view of interest and"
508 "\n /vis/viewer/save"
509 "\nthen repeat with next start time, another view and a save, then try"
510 "\n /vis/viewer/interpolate";
511
512 fpCommandTimeWindowDisplayHeadTime =
513 new G4UIcommand("/vis/viewer/set/timeWindow/displayHeadTime", this);
514 fpCommandTimeWindowDisplayHeadTime->SetGuidance
515 ("Display head time of range in 2D text.");
516 fpCommandTimeWindowDisplayHeadTime->SetGuidance(timeWindowGuidance);
517 parameter = new G4UIparameter ("displayHeadTime", 'b', omitable = false);
518 parameter->SetDefaultValue(false);
519 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
520 parameter = new G4UIparameter ("screenX", 'd', omitable = true);
521 parameter->SetGuidance("-1 < screenX < 1");
522 parameter->SetParameterRange("screenX >= -1. && screenX <= 1.");
523 parameter->SetDefaultValue(-0.9);
524 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
525 parameter = new G4UIparameter ("screenY", 'd', omitable = true);
526 parameter->SetGuidance("-1 < screenY < 1");
527 parameter->SetParameterRange("screenY >= -1. && screenY <= 1.");
528 parameter->SetDefaultValue(-0.9);
529 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
530 parameter = new G4UIparameter ("screenSize", 'd', omitable = true);
531 parameter->SetDefaultValue(24.);
532 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
533 parameter = new G4UIparameter ("red", 'd', omitable = true);
534 parameter->SetParameterRange("red >= 0. && red <= 1.");
535 parameter->SetDefaultValue(0.);
536 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
537 parameter = new G4UIparameter ("green", 'd', omitable = true);
538 parameter->SetParameterRange("green >= 0. && green <= 1.");
539 parameter->SetDefaultValue(1.);
540 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
541 parameter = new G4UIparameter ("blue", 'd', omitable = true);
542 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
543 parameter->SetDefaultValue(1.);
544 fpCommandTimeWindowDisplayHeadTime->SetParameter(parameter);
545
546 fpCommandTimeWindowDisplayLightFront =
547 new G4UIcommand("/vis/viewer/set/timeWindow/displayLightFront", this);
548 fpCommandTimeWindowDisplayLightFront->SetGuidance
549 ("Display the light front at head time.");
550 fpCommandTimeWindowDisplayLightFront->SetGuidance
551 ("Tip: The trajectories can appear of jump ahead of the light front"
552 "\nbecause their time range overlaps the viewer's time range. To"
553 "\naverage out this discrete time effect, advance the light front by"
554 "\nhalf the trajectories interval. E.g., if the trajectory time slice"
555 "\ninterval is 0.01 ns:"
556 "\n /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.005 ns"
557 "\nTo prevent them beating the light front at all:"
558 "\n /vis/viewer/set/timeWindow/displayLightFront true -90 0 0 mm -0.01 ns");
559 fpCommandTimeWindowDisplayLightFront->SetGuidance(timeWindowGuidance);
560 parameter = new G4UIparameter ("displayLightFront", 'b', omitable = true);
561 parameter->SetDefaultValue(true);
562 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
563 parameter = new G4UIparameter ("originX", 'd', omitable = true);
564 parameter->SetDefaultValue(0.);
565 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
566 parameter = new G4UIparameter ("originY", 'd', omitable = true);
567 parameter->SetDefaultValue(0.);
568 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
569 parameter = new G4UIparameter ("originZ", 'd', omitable = true);
570 parameter->SetDefaultValue(0.);
571 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
572 parameter = new G4UIparameter ("space_unit", 's', omitable = true);
573 parameter->SetDefaultValue("m");
574 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
575 parameter = new G4UIparameter ("originT", 'd', omitable = true);
576 parameter->SetDefaultValue(0.);
577 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
578 parameter = new G4UIparameter ("time_unit", 's', omitable = true);
579 parameter->SetDefaultValue("s");
580 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
581 parameter = new G4UIparameter ("red", 'd', omitable = true);
582 parameter->SetParameterRange("red >= 0. && red <= 1.");
583 parameter->SetDefaultValue(0.);
584 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
585 parameter = new G4UIparameter ("green", 'd', omitable = true);
586 parameter->SetParameterRange("green >= 0. && green <= 1.");
587 parameter->SetDefaultValue(1.);
588 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
589 parameter = new G4UIparameter ("blue", 'd', omitable = true);
590 parameter->SetParameterRange("blue >= 0. && blue <= 1.");
591 parameter->SetDefaultValue(0.);
592 fpCommandTimeWindowDisplayLightFront->SetParameter(parameter);
593
594 fpCommandTimeWindowEndTime =
595 new G4UIcommand("/vis/viewer/set/timeWindow/endTime", this);
596 fpCommandTimeWindowEndTime->SetGuidance("Set end and range of track time.");
597 fpCommandTimeWindowEndTime->SetGuidance(timeWindowGuidance);
598 parameter = new G4UIparameter ("end-time", 'd', omitable = false);
599 parameter->SetDefaultValue(G4VisAttributes::fVeryLongTime);
600 fpCommandTimeWindowEndTime->SetParameter(parameter);
601 parameter = new G4UIparameter ("end-time-unit", 's', omitable = false);
602 parameter->SetDefaultValue("ns");
603 fpCommandTimeWindowEndTime->SetParameter(parameter);
604 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
605 parameter->SetDefaultValue(-1.);
606 fpCommandTimeWindowEndTime->SetParameter(parameter);
607 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
608 parameter->SetDefaultValue("ns");
609 fpCommandTimeWindowEndTime->SetParameter(parameter);
610
611 fpCommandTimeWindowFadeFactor =
612 new G4UIcmdWithADouble("/vis/viewer/set/timeWindow/fadeFactor", this);
613 fpCommandTimeWindowFadeFactor->SetGuidance
614 ("0: no fade; 1: maximum fade with time window.");
615 fpCommandTimeWindowFadeFactor->SetGuidance(timeWindowGuidance);
616 fpCommandTimeWindowFadeFactor->SetParameterName("fade_factor", omitable = false);
617 fpCommandTimeWindowFadeFactor->SetRange("fade_factor>=0.&&fade_factor<=1.");
618 fpCommandTimeWindowFadeFactor->SetDefaultValue(0.);
619
620 fpCommandTimeWindowStartTime =
621 new G4UIcommand("/vis/viewer/set/timeWindow/startTime", this);
622 fpCommandTimeWindowStartTime->SetGuidance("Set start and range of track time.");
623 fpCommandTimeWindowStartTime->SetGuidance(timeWindowGuidance);
624 parameter = new G4UIparameter ("start-time", 'd', omitable = false);
625 parameter->SetDefaultValue(-G4VisAttributes::fVeryLongTime);
626 fpCommandTimeWindowStartTime->SetParameter(parameter);
627 parameter = new G4UIparameter ("start-time-unit", 's', omitable = false);
628 parameter->SetDefaultValue("ns");
629 fpCommandTimeWindowStartTime->SetParameter(parameter);
630 parameter = new G4UIparameter ("time-range", 'd', omitable = true);
631 parameter->SetDefaultValue(-1.);
632 fpCommandTimeWindowStartTime->SetParameter(parameter);
633 parameter = new G4UIparameter ("time-range-unit", 's', omitable = true);
634 parameter->SetDefaultValue("ns");
635 fpCommandTimeWindowStartTime->SetParameter(parameter);
636}
637
638G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639 delete fpCommandTimeWindowStartTime;
640 delete fpCommandTimeWindowFadeFactor;
641 delete fpCommandTimeWindowEndTime;
642 delete fpCommandTimeWindowDisplayLightFront;
643 delete fpCommandTimeWindowDisplayHeadTime;
644 delete fpTimeWindowDirectory;
645 delete fpCommandViewpointVector;
646 delete fpCommandViewpointThetaPhi;
647 delete fpCommandUpVector;
648 delete fpCommandUpThetaPhi;
649 delete fpCommandTargetPoint;
650 delete fpCommandStyle;
651 delete fpCommandSpecialMeshVolumes;
652 delete fpCommandSpecialMeshRenderingOption;
653 delete fpCommandSpecialMeshRendering;
654 delete fpCommandSectionPlane;
655 delete fpCommandRotationStyle;
656 delete fpCommandProjection;
657 delete fpCommandPicking;
658 delete fpCommandNumberOfCloudPoints;
659 delete fpCommandLineWidth;
660 delete fpCommandLineSegments;
661 delete fpCommandLightsVector;
662 delete fpCommandLightsThetaPhi;
663 delete fpCommandLightsMove;
664 delete fpCommandHiddenMarker;
665 delete fpCommandHiddenEdge;
666 delete fpCommandGlobalMarkerScale;
667 delete fpCommandGlobalLineWidthScale;
668 delete fpCommandExplodeFactor;
669 delete fpCommandEdge;
670 delete fpCommandDefaultTextColour;
671 delete fpCommandDefaultColour;
672 delete fpCommandCutawayMode;
673 delete fpCommandCulling;
674 delete fpCommandBackground;
675 delete fpCommandAuxEdge;
676 delete fpCommandAutoRefresh;
677 delete fpCommandAll;
678}
679
683
684void G4VisCommandsViewerSet::SetNewValue
685(G4UIcommand* command,G4String newValue) {
686
687 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
688
689 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690 if (!currentViewer) {
691 if (verbosity >= G4VisManager::errors) {
692 G4warn <<
693 "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
694 << G4endl;
695 }
696 return;
697 }
698
699 G4ViewParameters vp = currentViewer->GetViewParameters();
700
701 if (command == fpCommandAll) {
702 G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703 if (!fromViewer) {
704 if (verbosity >= G4VisManager::errors) {
705 G4warn <<
706 "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
707 "\n unrecognised from-viewer."
708 << G4endl;
709 }
710 return;
711 }
712 if (fromViewer == currentViewer) {
713 if (verbosity >= G4VisManager::warnings) {
714 G4warn <<
715 "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
716 "\n from-viewer and current viewer are identical."
717 << G4endl;
718 }
719 return;
720 }
721 // Copy view parameters except for autoRefresh and background...
722 auto keepAutoRefresh = vp.IsAutoRefresh();
723 auto keepBackground = vp.GetBackgroundColour();
724 vp = fromViewer->GetViewParameters();
725 vp.SetAutoRefresh(keepAutoRefresh);
726 vp.SetBackgroundColour(keepBackground);
727 // Concatenate any private vis attributes modifiers...
728 const std::vector<G4ModelingParameters::VisAttributesModifier>*
729 privateVAMs = fromViewer->GetPrivateVisAttributesModifiers();
730 if (privateVAMs) {
731 std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator i;
732 for (i = privateVAMs->begin(); i != privateVAMs->end(); ++i) {
733 vp.AddVisAttributesModifier(*i);
734 }
735 }
736 if (verbosity >= G4VisManager::confirmations) {
737 G4cout << "View parameters of viewer \"" << currentViewer->GetName()
738 << "\"\n set to those of viewer \"" << fromViewer->GetName()
739 << "\"."
740 << G4endl;
741 }
742 if (verbosity >= G4VisManager::warnings) {
743 G4warn << "You may need \"/vis/viewer/rebuild\"."
744 << G4endl;
745 }
746 }
747
748 else if (command == fpCommandAutoRefresh) {
749 G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
750 const G4ViewParameters& defaultVP =
751 currentViewer->GetDefaultViewParameters();
752 if (autoRefresh && !defaultVP.IsAutoRefresh()) {
753 if (verbosity >= G4VisManager::warnings) {
754 G4warn
755 << "WARNING: "
756 << currentViewer->GetName() << " is NOT auto-refesh by default"
757 << "\n so cannot be set to auto-refresh."
758 << G4endl;
759 }
760 return;
761 }
762 vp.SetAutoRefresh(autoRefresh);
763 if (verbosity >= G4VisManager::confirmations) {
764 G4cout << "Views will ";
765 if (!vp.IsAutoRefresh()) G4cout << "not ";
766 G4cout << "be automatically refreshed after a change of view parameters."
767 << G4endl;
768 }
769 if (!vp.IsAutoRefresh()) {
770 currentViewer->SetViewParameters(vp);
771 return; // Avoid a refresh if auto-refresh has been set to off...
772 } // ...otherwise take normal action.
773 }
774
775 else if (command == fpCommandAuxEdge) {
776 vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
777 if (verbosity >= G4VisManager::confirmations) {
778 G4cout << "Auxiliary edges will ";
779 if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
780 G4cout << "be visible." << G4endl;
781 }
782 }
783
784 else if (command == fpCommandBackground) {
785 G4String redOrString;
786 G4double green, blue, opacity;
787 std::istringstream iss(newValue);
788 iss >> redOrString >> green >> blue >> opacity;
789 G4Colour colour(0.,0.,0.); // Default black and opaque.
790 ConvertToColour(colour, redOrString, green, blue, opacity);
791 vp.SetBackgroundColour(colour);
792 if (verbosity >= G4VisManager::confirmations) {
793 G4cout << "Background colour "
794 << vp.GetBackgroundColour()
795 << " requested."
796 << G4endl;
797 }
798 }
799
800 else if (command == fpCommandCulling) {
801 G4String cullingOption, stringFlag, unit;
802 G4double density;
803 std::istringstream is (newValue);
804 is >> cullingOption >> stringFlag >> density >> unit;
805 G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
806 if (cullingOption == "global") {
807 vp.SetCulling(boolFlag);
808 if (verbosity >= G4VisManager::confirmations) {
809 G4cout <<
810 "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
811 " set to " << G4UIcommand::ConvertToString(boolFlag) <<
812 ".\n Does not change specific culling flags."
813 << G4endl;
814 }
815 }
816 else if (cullingOption == "coveredDaughters") {
817 vp.SetCullingCovered(boolFlag);
818 if (verbosity >= G4VisManager::confirmations) {
819 G4cout <<
820 "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
821 "\n daughters flag set to "
822 << G4UIcommand::ConvertToString(boolFlag) <<
823 ". Daughters covered by opaque mothers"
824 "\n will be culled, i.e., not drawn, if this flag is true."
825 "\n Note: this is only effective in surface drawing style,"
826 "\n and then only if the volumes are visible and opaque, and then"
827 "\n only if no sections or cutaways are in operation."
828 << G4endl;
829 }
830 }
831 else if (cullingOption == "invisible") {
832 vp.SetCullingInvisible(boolFlag);
833 if (verbosity >= G4VisManager::confirmations) {
834 G4cout <<
835 "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
836 "\n flag set to "
837 << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
838 ". Volumes marked invisible will be culled,"
839 "\n i.e., not drawn, if this flag is true."
840 << G4endl;
841 }
842 }
843 else if (cullingOption == "density") {
844 const G4String where =
845 "G4VisCommandsViewerSet::SetNewValue: culling: culling by density";
846 if (boolFlag) {
847 G4double valueOfUnit;
848 // "Volumic Mass" is Michel's phrase for "Density"
849 if (ProvideValueOfUnit(where,unit,"Volumic Mass",valueOfUnit)) {
850 // Successful outcome of unit search
851 vp.SetDensityCulling(boolFlag);
852 density *= valueOfUnit;
853 vp.SetVisibleDensity(density);
854 } else {
855 // Unsuccessful outcome of unit search. Flag and density unchanged.
856 density = vp.GetVisibleDensity();
857 }
858 } else { // Reset flag but density unchanged.
859 vp.SetDensityCulling(boolFlag);
860 }
861 if (verbosity >= G4VisManager::confirmations) {
862 G4cout
863 << where
864 << "\n flag set to "
865 << std::boolalpha << vp.IsDensityCulling()
866 << ". Volumes with density less than "
867 << G4BestUnit(density,"Volumic Mass")
868 << "\n will be culled, i.e., not drawn, if this flag is true."
869 << G4endl;
870 }
871 }
872 else {
873 if (verbosity >= G4VisManager::errors) {
874 G4warn <<
875 "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
876 "\n option not recognised."
877 << G4endl;
878 }
879 }
880 }
881
882 else if (command == fpCommandCutawayMode) {
883 if (newValue == "add" || newValue == "union")
884 vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
885 if (newValue == "multiply" || newValue == "intersection")
886 vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
887
888 if (verbosity >= G4VisManager::confirmations) {
889 G4cout << "Cutaway mode set to ";
890 if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
891 G4cout << "cutawayUnion";
892 if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
893 G4cout << "cutawayIntersection";
894 G4cout << G4endl;
895 }
896 }
897
898 else if (command == fpCommandDefaultColour) {
899 G4String redOrString;
900 G4double green, blue, opacity;
901 std::istringstream iss(newValue);
902 iss >> redOrString >> green >> blue >> opacity;
903 G4Colour colour(1.,1.,1.); // Default white and opaque.
904 ConvertToColour(colour, redOrString, green, blue, opacity);
905 G4VisAttributes va = vp.GetDefaultVisAttributes();
906 va.SetColour(colour);
907 vp.SetDefaultVisAttributes(va);
908 if (verbosity >= G4VisManager::confirmations) {
909 G4cout << "Default colour "
910 << vp.GetDefaultVisAttributes()->GetColour()
911 << " requested."
912 << G4endl;
913 }
914 }
915
916 else if (command == fpCommandDefaultTextColour) {
917 G4String redOrString;
918 G4double green, blue, opacity;
919 std::istringstream iss(newValue);
920 iss >> redOrString >> green >> blue >> opacity;
921 G4Colour colour(1.,1.,1.); // Default white and opaque.
922 ConvertToColour(colour, redOrString, green, blue, opacity);
923 G4VisAttributes va = vp.GetDefaultTextVisAttributes();
924 va.SetColour(colour);
925 vp.SetDefaultTextVisAttributes(va);
926 if (verbosity >= G4VisManager::confirmations) {
927 G4cout << "Default colour "
928 << vp.GetDefaultTextVisAttributes()->GetColour()
929 << " requested."
930 << G4endl;
931 }
932 }
933
934 else if (command == fpCommandEdge) {
935 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936 if (G4UIcommand::ConvertToBool(newValue)) { // true
937 switch (existingStyle) {
938 case G4ViewParameters::wireframe:
939 break;
940 case G4ViewParameters::hlr:
941 break;
942 case G4ViewParameters::hsr:
943 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944 break;
945 case G4ViewParameters::hlhsr:
946 break;
947 case G4ViewParameters::cloud:
948 break;
949 }
950 }
951 else { // false
952 switch (existingStyle) {
953 case G4ViewParameters::wireframe:
954 break;
955 case G4ViewParameters::hlr:
956 break;
957 case G4ViewParameters::hsr:
958 break;
959 case G4ViewParameters::hlhsr:
960 vp.SetDrawingStyle(G4ViewParameters::hsr);
961 break;
962 case G4ViewParameters::cloud:
963 break;
964 }
965 }
966 if (verbosity >= G4VisManager::confirmations) {
967 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
968 << "\" set to " << vp.GetDrawingStyle()
969 << G4endl;
970 }
971 }
972
973 else if (command == fpCommandExplodeFactor) {
974 G4double explodeFactor, x, y, z;
975 G4String unitString;
976 std::istringstream is (newValue);
977 is >> explodeFactor >> x >> y >> z >> unitString;
978 G4double unit = G4UIcommand::ValueOf(unitString);
979 vp.SetExplodeFactor(explodeFactor);
980 vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
981 if (verbosity >= G4VisManager::confirmations) {
982 G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
983 << " from centre " << vp.GetExplodeCentre()
984 << G4endl;
985 }
986 }
987
988 else if (command == fpCommandGlobalLineWidthScale) {
989 G4double globalLineWidthScale
990 = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
991 vp.SetGlobalLineWidthScale(globalLineWidthScale);
992 if (verbosity >= G4VisManager::confirmations) {
993 G4cout << "Global Line Width Scale changed to "
994 << vp.GetGlobalLineWidthScale() << G4endl;
995 }
996 }
997
998 else if (command == fpCommandGlobalMarkerScale) {
999 G4double globalMarkerScale
1000 = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
1001 vp.SetGlobalMarkerScale(globalMarkerScale);
1002 if (verbosity >= G4VisManager::confirmations) {
1003 G4cout << "Global Marker Scale changed to "
1004 << vp.GetGlobalMarkerScale() << G4endl;
1005 }
1006 }
1007
1008 else if (command == fpCommandHiddenEdge) {
1009 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010 if (G4UIcommand::ConvertToBool(newValue)) {
1011 switch (existingStyle) {
1012 case G4ViewParameters::wireframe:
1013 vp.SetDrawingStyle(G4ViewParameters::hlr);
1014 break;
1015 case G4ViewParameters::hlr:
1016 break;
1017 case G4ViewParameters::hsr:
1018 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019 break;
1020 case G4ViewParameters::hlhsr:
1021 break;
1022 case G4ViewParameters::cloud:
1023 break;
1024 }
1025 }
1026 else {
1027 switch (existingStyle) {
1028 case G4ViewParameters::wireframe:
1029 break;
1030 case G4ViewParameters::hlr:
1031 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032 break;
1033 case G4ViewParameters::hsr:
1034 break;
1035 case G4ViewParameters::hlhsr:
1036 vp.SetDrawingStyle(G4ViewParameters::hsr);
1037 break;
1038 case G4ViewParameters::cloud:
1039 break;
1040 }
1041 }
1042 if (verbosity >= G4VisManager::confirmations) {
1043 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1044 << "\" set to " << vp.GetDrawingStyle()
1045 << G4endl;
1046 }
1047 }
1048
1049 else if (command == fpCommandHiddenMarker) {
1050 G4bool hidden = G4UIcommand::ConvertToBool(newValue);
1051 if (hidden) vp.SetMarkerHidden();
1052 else vp.SetMarkerNotHidden();
1053 if (verbosity >= G4VisManager::confirmations) {
1054 G4cout << "Markers will ";
1055 if (vp.IsMarkerNotHidden()) G4cout << "not ";
1056 G4cout << "be hidden under solid objects." << G4endl;
1057 }
1058 }
1059
1060 else if (command == fpCommandLightsMove) {
1061 if (newValue.find("cam") != G4String::npos)
1062 vp.SetLightsMoveWithCamera(true);
1063 else if(newValue.find("obj") != G4String::npos)
1064 vp.SetLightsMoveWithCamera(false);
1065 else {
1066 if (verbosity >= G4VisManager::errors) {
1067 G4warn << "ERROR: \"" << newValue << "\" not recognised."
1068 " Looking for \"cam\" or \"obj\" in string." << G4endl;
1069 }
1070 }
1071 if (verbosity >= G4VisManager::confirmations) {
1072 G4cout << "Lights move with ";
1073 if (vp.GetLightsMoveWithCamera())
1074 G4cout << "camera (object appears to rotate).";
1075 else G4cout << "object (the viewer appears to be moving).";
1076 G4cout << G4endl;
1077 }
1078 }
1079
1080 else if (command == fpCommandLightsThetaPhi) {
1081 G4double theta, phi;
1082 if (ConvertToDoublePair(newValue, theta, phi)) {
1083 G4double x = std::sin (theta) * std::cos (phi);
1084 G4double y = std::sin (theta) * std::sin (phi);
1085 G4double z = std::cos (theta);
1086 fLightsVector = G4ThreeVector (x, y, z);
1087 vp.SetLightpointDirection(fLightsVector);
1088 if (verbosity >= G4VisManager::confirmations) {
1089 G4cout << "Lights direction set to "
1090 << vp.GetLightpointDirection() << G4endl;
1091 }
1092 }
1093 }
1094
1095 else if (command == fpCommandLightsVector) {
1096 fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
1097 vp.SetLightpointDirection(fLightsVector);
1098 if (verbosity >= G4VisManager::confirmations) {
1099 G4cout << "Lights direction set to "
1100 << vp.GetLightpointDirection() << G4endl;
1101 }
1102 }
1103
1104 else if (command == fpCommandLineWidth) {
1105 if (verbosity >= G4VisManager::errors) {
1106 // A do-nothing command
1107 G4warn << command->GetGuidanceLine(0) << G4endl;
1108 }
1109 }
1110
1111 else if (command == fpCommandLineSegments) {
1112 G4int nSides = G4UIcommand::ConvertToInt(newValue);
1113 nSides = vp.SetNoOfSides(nSides);
1114 if (verbosity >= G4VisManager::confirmations) {
1115 G4cout <<
1116 "Number of line segments per circle in polygon approximation is "
1117 << nSides << G4endl;
1118 }
1119 }
1120
1121 else if (command == fpCommandNumberOfCloudPoints) {
1122 G4int nPoints = G4UIcommand::ConvertToInt(newValue);
1123 nPoints = vp.SetNumberOfCloudPoints(nPoints);
1124 if (verbosity >= G4VisManager::confirmations) {
1125 G4cout <<
1126 "Number of points to be used in cloud representation of volumes is "
1127 << nPoints << G4endl;
1128 }
1129 }
1130
1131 else if (command == fpCommandPicking) {
1132 vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
1133 if (verbosity >= G4VisManager::confirmations) {
1134 G4cout << "Picking ";
1135 if (vp.IsPicking()) G4cout << "requested.";
1136 else G4cout << "inhibited.";
1137 G4cout << G4endl;
1138 }
1139 if (verbosity >= G4VisManager::warnings) {
1140 G4warn << "You may need to issue \"/vis/viewer/update\"."
1141 << G4endl;
1142 }
1143 }
1144
1145 else if (command == fpCommandProjection) {
1146 G4double fieldHalfAngle;
1147 const size_t iPos0 = 0;
1148 if (newValue[iPos0] == 'o') { // "orthogonal"
1149 fieldHalfAngle = 0.;
1150 }
1151 else if (newValue[iPos0] == 'p') { // "perspective"
1152 G4String dummy;
1153 G4String unit;
1154 std::istringstream is (newValue);
1155 is >> dummy >> fieldHalfAngle >> unit;
1156 fieldHalfAngle *= G4UIcommand::ValueOf(unit);
1157 if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
1158 if (verbosity >= G4VisManager::errors) {
1159 G4warn <<
1160 "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
1161 G4warn << G4endl;
1162 }
1163 return;
1164 }
1165 }
1166 else {
1167 if (verbosity >= G4VisManager::errors) {
1168 G4warn << "ERROR: \"" << newValue << "\" not recognised."
1169 " Looking for 'o' or 'p' first character." << G4endl;
1170 }
1171 return;
1172 }
1173 vp.SetFieldHalfAngle(fieldHalfAngle);
1174 if (verbosity >= G4VisManager::confirmations) {
1175 G4cout << "Projection style of viewer \"" << currentViewer->GetName()
1176 << "\" set to ";
1177 if (fieldHalfAngle == 0.) {
1178 G4cout << "orthogonal.";
1179 }
1180 else {
1181 G4cout << "perspective\n with half angle " << fieldHalfAngle / deg
1182 << " degrees.";
1183 }
1184 G4cout << G4endl;
1185 }
1186 }
1187
1188 else if (command == fpCommandRotationStyle) {
1189 G4ViewParameters::RotationStyle style;
1190 if (newValue == "constrainUpDirection")
1191 style = G4ViewParameters::constrainUpDirection;
1192 else if (newValue == "freeRotation")
1193 style = G4ViewParameters::freeRotation;
1194 else {
1195 if (verbosity >= G4VisManager::errors) {
1196 G4warn << "ERROR: \"" << newValue << "\" not recognised." << G4endl;
1197 }
1198 return;
1199 }
1200 vp.SetRotationStyle(style);
1201 if (verbosity >= G4VisManager::confirmations) {
1202 G4cout << "Rotation style of viewer \"" << currentViewer->GetName()
1203 << "\" set to " << vp.GetRotationStyle()
1204 << G4endl;
1205 }
1206 }
1207
1208 else if (command == fpCommandSectionPlane) {
1209 G4String choice, unit;
1210 G4double x, y, z, nx, ny, nz, F = 1.;
1211 std::istringstream is (newValue);
1212 is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
1213 G4int iSelector = -1;
1214 if (G4StrUtil::icompare(choice, "off") == 0 ||
1215 !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
1216 if (G4StrUtil::icompare(choice, "on") == 0 ||
1217 G4UIcommand::ConvertToBool(choice)) iSelector = 1;
1218 if (iSelector < 0) {
1219 if (verbosity >= G4VisManager::errors) {
1220 G4warn << "Choice not recognised (on/true or off/false)." << G4endl;
1221 }
1222 goto write_result;
1223 }
1224 // iSelector can only be 0 or 1
1225 switch (iSelector) {
1226 case 0:
1227 vp.UnsetSectionPlane();
1228 break;
1229 case 1:
1230 F = G4UIcommand::ValueOf(unit);
1231 x *= F; y *= F; z *= F;
1232 if (nx == 0. && ny == 0. && nz == 0.) {
1233 if (verbosity >= G4VisManager::errors) {
1234 G4warn << "Null normal." << G4endl;
1235 }
1236 break;;
1237 }
1238 // Make sure normal is normalised
1239 const G4Normal3D& normal = G4Normal3D(nx,ny,nz).unit();
1240 vp.SetSectionPlane(G4Plane3D(normal, G4Point3D(x,y,z)));
1241 vp.SetViewpointDirection(normal);
1242 break;
1243 }
1244 write_result:
1245 if (verbosity >= G4VisManager::confirmations) {
1246 G4cout << "Section drawing is: ";
1247 if (vp.IsSection ()) G4cout << "on";
1248 else G4cout << "off";
1249 G4cout << ".\nSection plane is now: "
1250 << vp.GetSectionPlane ();
1251 G4cout << G4endl;
1252 }
1253 }
1254
1255 else if (command == fpCommandSpecialMeshRendering) {
1256 vp.SetSpecialMeshRendering(G4UIcommand::ConvertToBool(newValue));
1257 if (verbosity >= G4VisManager::confirmations) {
1258 G4cout << "Special mesh rendering";
1259 if (vp.IsSpecialMeshRendering()) {
1260 G4cout << " requested. Current option is \""
1261 << vp.GetSpecialMeshRenderingOption() << "\" for ";
1262 if (vp.GetSpecialMeshVolumes().empty()) {
1263 G4cout << "any mesh.";
1264 } else{
1265 G4cout << "selected volumes:";
1266 for (const auto& pvNameCopyNo: vp.GetSpecialMeshVolumes()) {
1267 G4cout << "\n " << pvNameCopyNo.GetName();
1268 if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << ':' << pvNameCopyNo.GetCopyNo();
1269 }
1270 }
1271 }
1272 else G4cout << ": off.";
1273 G4cout << G4endl;
1274 }
1275 }
1276
1277 else if (command == fpCommandSpecialMeshRenderingOption) {
1278 G4ViewParameters::SMROption option = G4ViewParameters::meshAsDefault;
1279 if (newValue == "dots") {
1280 option = G4ViewParameters::meshAsDots;
1281 }
1282 else if(newValue == "surfaces") {
1283 option = G4ViewParameters::meshAsSurfaces;
1284 }
1285 vp.SetSpecialMeshRenderingOption(option);
1286 if (verbosity >= G4VisManager::confirmations) {
1287 G4cout << "Special mesh rendering option set to \""
1288 << vp.GetSpecialMeshRenderingOption() << "\"."
1289 << G4endl;
1290 }
1291 }
1292
1293 else if (command == fpCommandSpecialMeshVolumes) {
1294 std::vector<G4ModelingParameters::PVNameCopyNo> requestedMeshes;
1295 if (newValue.empty()) {
1296 vp.SetSpecialMeshVolumes(requestedMeshes); // Empty list
1297 } else {
1298 // Algorithm from Josuttis p.476.
1299 G4String::size_type iBegin, iEnd;
1300 iBegin = newValue.find_first_not_of(' ');
1301 while (iBegin != G4String::npos) {
1302 iEnd = newValue.find_first_of(' ',iBegin);
1303 if (iEnd == G4String::npos) {
1304 iEnd = newValue.length();
1305 }
1306 const G4String& name(newValue.substr(iBegin,iEnd-iBegin));
1307 iBegin = newValue.find_first_not_of(' ',iEnd);
1308 if (iBegin == G4String::npos) {
1309 if (verbosity >= G4VisManager::warnings) {
1310 G4warn <<
1311 "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
1312 "\n A pair not found. (There should be an even number of parameters.)"
1313 "\n Command ignored."
1314 << G4endl;
1315 return;
1316 }
1317 }
1318 iEnd = newValue.find_first_of(' ',iBegin);
1319 if (iEnd == G4String::npos) {
1320 iEnd = newValue.length();
1321 }
1322 G4int copyNo;
1323 std::istringstream iss(newValue.substr(iBegin,iEnd-iBegin));
1324 if (!(iss >> copyNo)) {
1325 if (verbosity >= G4VisManager::warnings) {
1326 G4warn <<
1327 "WARNING: G4VisCommandsViewerSet::SetNewValue: /vis/viewer/set/specialMeshVolumes"
1328 "\n Error reading copy number - it was not numeric?"
1329 "\n Command ignored."
1330 << G4endl;
1331 return;
1332 }
1333 }
1334 requestedMeshes.push_back(G4ModelingParameters::PVNameCopyNo(name,copyNo));
1335 iBegin = newValue.find_first_not_of(' ',iEnd);
1336 }
1337 vp.SetSpecialMeshVolumes(requestedMeshes);
1338 }
1339 if (verbosity >= G4VisManager::confirmations) {
1340 if (vp.GetSpecialMeshVolumes().empty()) {
1341 G4cout <<
1342 "Special mesh list empty, which means \"all meshes\"."
1343 << G4endl;
1344 } else {
1345 G4cout << "Selected special mesh volumes are:";
1346 for (const auto& pvNameCopyNo: vp.GetSpecialMeshVolumes()) {
1347 G4cout << "\n " << pvNameCopyNo.GetName();
1348 if (pvNameCopyNo.GetCopyNo() >= 0) G4cout << ':' << pvNameCopyNo.GetCopyNo();
1349 }
1350 G4cout << G4endl;
1351 }
1352 }
1353 }
1354
1355 else if (command == fpCommandStyle) {
1356 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1357 const size_t iPos0 = 0;
1358 if (newValue[iPos0] == 'w') { // "wireframe"
1359 switch (existingStyle) {
1360 case G4ViewParameters::wireframe:
1361 break;
1362 case G4ViewParameters::hlr:
1363 break;
1364 case G4ViewParameters::hsr:
1365 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1366 break;
1367 case G4ViewParameters::hlhsr:
1368 vp.SetDrawingStyle(G4ViewParameters::hlr);
1369 break;
1370 case G4ViewParameters::cloud:
1371 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1372 break;
1373 }
1374 }
1375 else if (newValue[iPos0] == 's') { // "surface"
1376 switch (existingStyle) {
1377 case G4ViewParameters::wireframe:
1378 vp.SetDrawingStyle(G4ViewParameters::hsr);
1379 break;
1380 case G4ViewParameters::hlr:
1381 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1382 break;
1383 case G4ViewParameters::hsr:
1384 break;
1385 case G4ViewParameters::hlhsr:
1386 break;
1387 case G4ViewParameters::cloud:
1388 vp.SetDrawingStyle(G4ViewParameters::hsr);
1389 break;
1390 }
1391 }
1392 else if (newValue[iPos0] == 'c') { // "cloud"
1393 switch (existingStyle) {
1394 case G4ViewParameters::wireframe:
1395 vp.SetDrawingStyle(G4ViewParameters::cloud);
1396 break;
1397 case G4ViewParameters::hlr:
1398 vp.SetDrawingStyle(G4ViewParameters::cloud);
1399 break;
1400 case G4ViewParameters::hsr:
1401 vp.SetDrawingStyle(G4ViewParameters::cloud);
1402 break;
1403 case G4ViewParameters::hlhsr:
1404 vp.SetDrawingStyle(G4ViewParameters::cloud);
1405 break;
1406 case G4ViewParameters::cloud:
1407 break;
1408 }
1409 }
1410 else {
1411 if (verbosity >= G4VisManager::errors) {
1412 G4warn << "ERROR: \"" << newValue << "\" not recognised."
1413 " Looking for 'w' or 's' or 'c' first character." << G4endl;
1414 }
1415 return;
1416 }
1417 if (verbosity >= G4VisManager::confirmations) {
1418 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1419 << "\" set to " << vp.GetDrawingStyle()
1420 << G4endl;
1421 }
1422 }
1423
1424 else if (command == fpCommandTargetPoint) {
1425 G4ThreeVector targetPoint =
1426 fpCommandTargetPoint->GetNew3VectorValue(newValue);
1427 const G4Point3D& standardTargetPoint =
1428 currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
1429 vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
1430 if (verbosity >= G4VisManager::confirmations) {
1431 G4cout << "Target point set to "
1432 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1433 (targetPoint)
1434 << "\n\"Current Target Point\" set to "
1435 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1436 (vp.GetCurrentTargetPoint())
1437 << "\n\"Standard Target Point\" is "
1438 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1439 (standardTargetPoint)
1440 << G4endl;
1441 }
1442 }
1443
1444 else if (command == fpCommandUpThetaPhi) {
1445 G4double theta, phi;
1446 if (ConvertToDoublePair(newValue, theta, phi)) {
1447 G4double x = std::sin (theta) * std::cos (phi);
1448 G4double y = std::sin (theta) * std::sin (phi);
1449 G4double z = std::cos (theta);
1450 fUpVector = G4ThreeVector (x, y, z);
1451 vp.SetUpVector(fUpVector);
1452 if (verbosity >= G4VisManager::confirmations) {
1453 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1454 }
1455 }
1456 }
1457
1458 else if (command == fpCommandUpVector) {
1459 fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1460 vp.SetUpVector(fUpVector);
1461 if (verbosity >= G4VisManager::confirmations) {
1462 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1463 }
1464 }
1465
1466 else if (command == fpCommandViewpointThetaPhi) {
1467 G4double theta, phi;
1468 if (ConvertToDoublePair(newValue, theta, phi)) {
1469 G4double x = std::sin (theta) * std::cos (phi);
1470 G4double y = std::sin (theta) * std::sin (phi);
1471 G4double z = std::cos (theta);
1472 fViewpointVector = G4ThreeVector (x, y, z);
1473 vp.SetViewAndLights(fViewpointVector);
1474 if (verbosity >= G4VisManager::confirmations) {
1475 G4cout << "Viewpoint direction set to "
1476 << vp.GetViewpointDirection() << G4endl;
1477 if (vp.GetLightsMoveWithCamera ()) {
1478 G4cout << "Lightpoint direction set to "
1479 << vp.GetActualLightpointDirection () << G4endl;
1480 }
1481 }
1482 }
1483 }
1484
1485 else if (command == fpCommandViewpointVector) {
1486 G4ThreeVector viewpointVector = G4UIcommand::ConvertTo3Vector(newValue);
1487 if (viewpointVector.mag2() <= 0.) {
1488 if (verbosity >= G4VisManager::errors) {
1489 G4warn << "ERROR: Null viewpoint vector. No action taken." << G4endl;
1490 }
1491 } else {
1492 fViewpointVector = viewpointVector.unit();
1493 vp.SetViewAndLights(fViewpointVector);
1494 if (verbosity >= G4VisManager::confirmations) {
1495 G4cout << "Viewpoint direction set to "
1496 << vp.GetViewpointDirection() << G4endl;
1497 if (vp.GetLightsMoveWithCamera ()) {
1498 G4cout << "Lightpoint direction set to "
1499 << vp.GetActualLightpointDirection () << G4endl;
1500 }
1501 }
1502 }
1503 }
1504
1505 else if (command == fpCommandTimeWindowDisplayHeadTime)
1506 {
1507 G4String display;
1508 G4double screenX, screenY, screenSize, red, green, blue;
1509 std::istringstream iss(newValue);
1510 iss >> display >> screenX >> screenY
1511 >> screenSize >> red >> green >> blue;
1512 vp.SetDisplayHeadTime(command->ConvertToBool(display));
1513 vp.SetDisplayHeadTimeX(screenX);
1514 vp.SetDisplayHeadTimeY(screenY);
1515 vp.SetDisplayHeadTimeSize(screenSize);
1516 vp.SetDisplayHeadTimeRed(red);
1517 vp.SetDisplayHeadTimeGreen(green);
1518 vp.SetDisplayHeadTimeBlue(blue);
1519 if (verbosity >= G4VisManager::confirmations) {
1520 G4cout << "Display head time flag set: "
1521 << vp
1522 << G4endl;
1523 }
1524 }
1525
1526 else if (command == fpCommandTimeWindowDisplayLightFront)
1527 {
1528 G4String display, originX, originY, originZ, unitS, originT, unitT;
1529 G4double red, green, blue;
1530 std::istringstream iss(newValue);
1531 iss >> display
1532 >> originX >> originY >> originZ >> unitS
1533 >> originT >> unitT
1534 >> red >> green >> blue;
1535 vp.SetDisplayLightFront(command->ConvertToBool(display));
1536 vp.SetDisplayLightFrontX
1537 (command->ConvertToDimensionedDouble(G4String(originX + ' ' + unitS)));
1538 vp.SetDisplayLightFrontY
1539 (command->ConvertToDimensionedDouble(G4String(originY + ' ' + unitS)));
1540 vp.SetDisplayLightFrontZ
1541 (command->ConvertToDimensionedDouble(G4String(originZ + ' ' + unitS)));
1542 vp.SetDisplayLightFrontT
1543 (command->ConvertToDimensionedDouble(G4String(originT + ' ' + unitT)));
1544 vp.SetDisplayLightFrontRed(red);
1545 vp.SetDisplayLightFrontGreen(green);
1546 vp.SetDisplayLightFrontBlue(blue);
1547 if (verbosity >= G4VisManager::confirmations) {
1548 G4cout << "Display light front flag set: "
1549 << vp
1550 << G4endl;
1551 }
1552 }
1553
1554 else if (command == fpCommandTimeWindowEndTime)
1555 {
1556 G4String end_time_string, end_time_unit,
1557 time_range_string, time_range_unit;
1558 std::istringstream iss(newValue);
1559 iss >> end_time_string >> end_time_unit
1560 >> time_range_string >> time_range_unit;
1561 vp.SetEndTime
1562 (command->ConvertToDimensionedDouble
1563 (G4String(end_time_string + ' ' + end_time_unit)));
1564 G4double timeRange = command->ConvertToDimensionedDouble
1565 (G4String(time_range_string + ' ' + time_range_unit));
1566 if (timeRange > 0.) {
1567 vp.SetStartTime
1568 (vp.GetEndTime() - timeRange);
1569 }
1570 if (verbosity >= G4VisManager::confirmations) {
1571 G4cout
1572 << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1573 << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1574 if (timeRange > 0.) {
1575 G4cout << "\n (time range: " << timeRange/ns << " ns)";
1576 }
1577 G4cout << G4endl;
1578 }
1579 }
1580
1581 else if (command == fpCommandTimeWindowFadeFactor) {
1582 vp.SetFadeFactor(command->ConvertToDouble(newValue));
1583 if (verbosity >= G4VisManager::confirmations) {
1584 G4cout << "Time window fade factor changed to " << vp.GetFadeFactor()
1585 << G4endl;
1586 }
1587 }
1588
1589 else if (command == fpCommandTimeWindowStartTime)
1590 {
1591 G4String start_time_string, start_time_unit,
1592 time_range_string, time_range_unit;
1593 std::istringstream iss(newValue);
1594 iss >> start_time_string >> start_time_unit
1595 >> time_range_string >> time_range_unit;
1596 vp.SetStartTime
1597 (command->ConvertToDimensionedDouble
1598 (G4String(start_time_string + ' ' + start_time_unit)));
1599 G4double timeRange = command->ConvertToDimensionedDouble
1600 (G4String(time_range_string + ' ' + time_range_unit));
1601 if (timeRange > 0.) {
1602 vp.SetEndTime
1603 (vp.GetStartTime() + timeRange);
1604 }
1605 if (verbosity >= G4VisManager::confirmations) {
1606 G4cout
1607 << "Time window start time: " << vp.GetStartTime()/ns << " ns"
1608 << ", time window end time: " << vp.GetEndTime()/ns << " ns";
1609 if (timeRange > 0.) {
1610 G4cout << "\n (time range: " << timeRange/ns << " ns)";
1611 }
1612 G4cout << G4endl;
1613 }
1614 }
1615
1616 else {
1617 if (verbosity >= G4VisManager::errors) {
1618 G4warn <<
1619 "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1620 << G4endl;
1621 }
1622 return;
1623 }
1624
1625 SetViewParameters(currentViewer,vp);
1626}
G4Normal3D
HepGeom::Normal3D< G4double > G4Normal3D
Definition G4Normal3D.hh:34
G4Plane3D
HepGeom::Plane3D< G4double > G4Plane3D
Definition G4Plane3D.hh:34
G4Point3D
HepGeom::Point3D< G4double > G4Point3D
Definition G4Point3D.hh:34
G4warn
#define G4warn
Definition G4Scene.cc:41
G4BestUnit
#define G4BestUnit(a, b)
Definition G4SteppingVerbose.cc:46
G4ThreeVector
CLHEP::Hep3Vector G4ThreeVector
Definition G4ThreeVector.hh:36
G4double
double G4double
Definition G4Types.hh:83
G4bool
bool G4bool
Definition G4Types.hh:86
G4int
int G4int
Definition G4Types.hh:85
G4endl
#define G4endl
Definition G4ios.hh:67
G4cout
G4GLOB_DLL std::ostream G4cout
CLHEP::Hep3Vector::unit
Hep3Vector unit() const
CLHEP::Hep3Vector::mag2
double mag2() const
G4Scene::GetStandardTargetPoint
const G4Point3D & GetStandardTargetPoint() const
G4UIcommand::GetGuidanceLine
const G4String & GetGuidanceLine(G4int i) const
Definition G4UIcommand.hh:124
G4UIcommand::ConvertTo3Vector
static G4ThreeVector ConvertTo3Vector(const char *st)
Definition G4UIcommand.cc:452
G4UIcommand::ValueOf
static G4double ValueOf(const char *unitName)
Definition G4UIcommand.cc:282
G4UIcommand::ConvertToString
static G4String ConvertToString(G4bool boolVal)
Definition G4UIcommand.cc:350
G4UIcommand::ConvertToInt
static G4int ConvertToInt(const char *st)
Definition G4UIcommand.cc:421
G4UIcommand::ConvertToBool
static G4bool ConvertToBool(const char *st)
Definition G4UIcommand.cc:414
G4UIcommand::ConvertToDouble
static G4double ConvertToDouble(const char *st)
Definition G4UIcommand.cc:433
G4UIcommand::ConvertToDimensionedDouble
static G4double ConvertToDimensionedDouble(const char *st)
Definition G4UIcommand.cc:439
G4UIparameter::SetDefaultValue
void SetDefaultValue(const char *theDefaultValue)
Definition G4UIparameter.hh:68
G4UIparameter::SetGuidance
void SetGuidance(const char *theGuidance)
Definition G4UIparameter.hh:108
G4UIparameter::SetParameterRange
void SetParameterRange(const char *theRange)
Definition G4UIparameter.hh:86
G4UIparameter::SetParameterCandidates
void SetParameterCandidates(const char *theString)
Definition G4UIparameter.hh:95
G4VSceneHandler::GetScene
G4Scene * GetScene() const
G4VViewer::GetName
const G4String & GetName() const
G4VViewer::GetViewParameters
const G4ViewParameters & GetViewParameters() const
G4VViewer::GetPrivateVisAttributesModifiers
virtual const std::vector< G4ModelingParameters::VisAttributesModifier > * GetPrivateVisAttributesModifiers() const
G4VViewer::GetDefaultViewParameters
const G4ViewParameters & GetDefaultViewParameters() const
G4VViewer::SetViewParameters
void SetViewParameters(const G4ViewParameters &vp)
Definition G4VViewer.cc:129
G4VViewer::GetSceneHandler
G4VSceneHandler * GetSceneHandler() const
G4VVisCommand::ConvertToColour
void ConvertToColour(G4Colour &colour, const G4String &redOrString, G4double green, G4double blue, G4double opacity)
Definition G4VVisCommand.cc:126
G4VVisCommand::fpVisManager
static G4VisManager * fpVisManager
Definition G4VVisCommand.hh:148
G4VVisCommand::ConvertToDoublePair
static G4bool ConvertToDoublePair(const G4String &paramString, G4double &xval, G4double &yval)
Definition G4VVisCommand.cc:91
G4VVisCommand::SetViewParameters
void SetViewParameters(G4VViewer *viewer, const G4ViewParameters &viewParams)
Definition G4VVisCommand.cc:272
G4VVisCommand::ConvertToColourGuidance
const G4String & ConvertToColourGuidance()
Definition G4VVisCommand.cc:115
G4VVisCommand::ProvideValueOfUnit
G4bool ProvideValueOfUnit(const G4String &where, const G4String &unit, const G4String &category, G4double &value)
Definition G4VVisCommand.cc:182
G4ViewParameters::SetViewpointDirection
void SetViewpointDirection(const G4Vector3D &viewpointDirection)
G4ViewParameters::SetNumberOfCloudPoints
G4int SetNumberOfCloudPoints(G4int)
Definition G4ViewParameters.cc:235
G4ViewParameters::SetNoOfSides
G4int SetNoOfSides(G4int nSides)
Definition G4ViewParameters.cc:223
G4ViewParameters::SetViewAndLights
void SetViewAndLights(const G4Vector3D &viewpointDirection)
Definition G4ViewParameters.cc:248
G4ViewParameters::SetAutoRefresh
void SetAutoRefresh(G4bool)
G4ViewParameters::SetBackgroundColour
void SetBackgroundColour(const G4Colour &)
G4ViewParameters::SetGlobalMarkerScale
void SetGlobalMarkerScale(G4double globalMarkerScale)
G4ViewParameters::SetExplodeCentre
void SetExplodeCentre(const G4Point3D &explodeCentre)
G4ViewParameters::SetDisplayLightFrontY
void SetDisplayLightFrontY(G4double)
G4ViewParameters::IsSpecialMeshRendering
G4bool IsSpecialMeshRendering() const
G4ViewParameters::GetCutawayMode
CutawayMode GetCutawayMode() const
G4ViewParameters::GetExplodeFactor
G4double GetExplodeFactor() const
G4ViewParameters::SetSpecialMeshRenderingOption
void SetSpecialMeshRenderingOption(SMROption)
G4ViewParameters::IsMarkerNotHidden
G4bool IsMarkerNotHidden() const
G4ViewParameters::SetDisplayHeadTimeBlue
void SetDisplayHeadTimeBlue(G4double)
G4ViewParameters::SetVisibleDensity
void SetVisibleDensity(G4double visibleDensity)
Definition G4ViewParameters.cc:206
G4ViewParameters::GetGlobalLineWidthScale
G4double GetGlobalLineWidthScale() const
G4ViewParameters::AddVisAttributesModifier
void AddVisAttributesModifier(const G4ModelingParameters::VisAttributesModifier &)
Definition G4ViewParameters.cc:302
G4ViewParameters::GetActualLightpointDirection
G4Vector3D & GetActualLightpointDirection()
Definition G4ViewParameters.cc:131
G4ViewParameters::SetCulling
void SetCulling(G4bool)
G4ViewParameters::SetCurrentTargetPoint
void SetCurrentTargetPoint(const G4Point3D &currentTargetPoint)
G4ViewParameters::SetDisplayLightFrontT
void SetDisplayLightFrontT(G4double)
G4ViewParameters::UnsetSectionPlane
void UnsetSectionPlane()
G4ViewParameters::SetDrawingStyle
void SetDrawingStyle(G4ViewParameters::DrawingStyle style)
G4ViewParameters::GetBackgroundColour
const G4Colour & GetBackgroundColour() const
G4ViewParameters::GetLightpointDirection
const G4Vector3D & GetLightpointDirection() const
G4ViewParameters::SetDisplayHeadTimeX
void SetDisplayHeadTimeX(G4double)
G4ViewParameters::SetDefaultVisAttributes
void SetDefaultVisAttributes(const G4VisAttributes &)
G4ViewParameters::SetFieldHalfAngle
void SetFieldHalfAngle(G4double fieldHalfAngle)
G4ViewParameters::SetCullingCovered
void SetCullingCovered(G4bool)
G4ViewParameters::GetViewpointDirection
const G4Vector3D & GetViewpointDirection() const
G4ViewParameters::IsSection
G4bool IsSection() const
G4ViewParameters::SetExplodeFactor
void SetExplodeFactor(G4double explodeFactor)
G4ViewParameters::SetGlobalLineWidthScale
void SetGlobalLineWidthScale(G4double globalLineWidthScale)
G4ViewParameters::GetCurrentTargetPoint
const G4Point3D & GetCurrentTargetPoint() const
G4ViewParameters::IsPicking
G4bool IsPicking() const
G4ViewParameters::SetStartTime
void SetStartTime(G4double)
G4ViewParameters::SetSpecialMeshVolumes
void SetSpecialMeshVolumes(const std::vector< G4ModelingParameters::PVNameCopyNo > &)
G4ViewParameters::SetPicking
void SetPicking(G4bool)
G4ViewParameters::SetDisplayLightFrontBlue
void SetDisplayLightFrontBlue(G4double)
G4ViewParameters::SetMarkerHidden
void SetMarkerHidden()
G4ViewParameters::SetDisplayHeadTime
void SetDisplayHeadTime(G4bool)
G4ViewParameters::GetDefaultTextVisAttributes
const G4VisAttributes * GetDefaultTextVisAttributes() const
G4ViewParameters::SetDisplayHeadTimeY
void SetDisplayHeadTimeY(G4double)
G4ViewParameters::SetDensityCulling
void SetDensityCulling(G4bool)
G4ViewParameters::SetDisplayLightFrontZ
void SetDisplayLightFrontZ(G4double)
G4ViewParameters::GetStartTime
G4double GetStartTime() const
G4ViewParameters::SetDisplayLightFront
void SetDisplayLightFront(G4bool)
G4ViewParameters::SetDisplayLightFrontRed
void SetDisplayLightFrontRed(G4double)
G4ViewParameters::GetUpVector
const G4Vector3D & GetUpVector() const
G4ViewParameters::SetDisplayHeadTimeSize
void SetDisplayHeadTimeSize(G4double)
G4ViewParameters::SetMarkerNotHidden
void SetMarkerNotHidden()
G4ViewParameters::SetDisplayHeadTimeRed
void SetDisplayHeadTimeRed(G4double)
G4ViewParameters::GetEndTime
G4double GetEndTime() const
G4ViewParameters::GetSpecialMeshVolumes
const std::vector< G4ModelingParameters::PVNameCopyNo > & GetSpecialMeshVolumes() const
G4ViewParameters::GetFadeFactor
G4double GetFadeFactor() const
G4ViewParameters::GetGlobalMarkerScale
G4double GetGlobalMarkerScale() const
G4ViewParameters::GetDefaultVisAttributes
const G4VisAttributes * GetDefaultVisAttributes() const
G4ViewParameters::SetCullingInvisible
void SetCullingInvisible(G4bool)
G4ViewParameters::SetUpVector
void SetUpVector(const G4Vector3D &upVector)
G4ViewParameters::SetEndTime
void SetEndTime(G4double)
G4ViewParameters::SetFadeFactor
void SetFadeFactor(G4double)
G4ViewParameters::GetRotationStyle
RotationStyle GetRotationStyle() const
G4ViewParameters::SetCutawayMode
void SetCutawayMode(CutawayMode)
G4ViewParameters::SetSpecialMeshRendering
void SetSpecialMeshRendering(G4bool)
G4ViewParameters::IsDensityCulling
G4bool IsDensityCulling() const
G4ViewParameters::SetDefaultTextVisAttributes
void SetDefaultTextVisAttributes(const G4VisAttributes &)
G4ViewParameters::SetLightpointDirection
void SetLightpointDirection(const G4Vector3D &lightpointDirection)
Definition G4ViewParameters.cc:280
G4ViewParameters::SetDisplayLightFrontX
void SetDisplayLightFrontX(G4double)
G4ViewParameters::SetLightsMoveWithCamera
void SetLightsMoveWithCamera(G4bool moves)
G4ViewParameters::SetDisplayHeadTimeGreen
void SetDisplayHeadTimeGreen(G4double)
G4ViewParameters::SetRotationStyle
void SetRotationStyle(RotationStyle)
G4ViewParameters::IsAutoRefresh
G4bool IsAutoRefresh() const
G4ViewParameters::GetVisibleDensity
G4double GetVisibleDensity() const
G4ViewParameters::GetSpecialMeshRenderingOption
SMROption GetSpecialMeshRenderingOption() const
G4ViewParameters::GetLightsMoveWithCamera
G4bool GetLightsMoveWithCamera() const
G4ViewParameters::SetSectionPlane
void SetSectionPlane(const G4Plane3D &sectionPlane)
G4ViewParameters::SetAuxEdgeVisible
void SetAuxEdgeVisible(G4bool)
G4ViewParameters::SetDisplayLightFrontGreen
void SetDisplayLightFrontGreen(G4double)
G4ViewParameters::GetExplodeCentre
const G4Point3D & GetExplodeCentre() const
G4ViewParameters::GetSectionPlane
const G4Plane3D & GetSectionPlane() const
G4ViewParameters::GetDrawingStyle
DrawingStyle GetDrawingStyle() const
G4ViewParameters::IsAuxEdgeVisible
G4bool IsAuxEdgeVisible() const
G4VisAttributes::SetColour
void SetColour(const G4Colour &)
G4VisAttributes::GetColour
const G4Colour & GetColour() const
G4VisAttributes::fVeryLongTime
static constexpr G4double fVeryLongTime
Definition G4VisAttributes.hh:141
G4VisCommandsViewerSet::SetNewValue
void SetNewValue(G4UIcommand *command, G4String newValue)
Definition G4VisCommandsViewerSet.cc:685
G4VisCommandsViewerSet::GetCurrentValue
G4String GetCurrentValue(G4UIcommand *command)
Definition G4VisCommandsViewerSet.cc:680
HepGeom::BasicVector3D::unit
BasicVector3D< T > unit() const
Definition BasicVector3D.h:310
ns
#define ns(x)
Definition xmltok.c:1649