| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // 7 //
>> 8 // $Id: G4VisCommandsViewerSet.cc,v 1.3 2000/05/19 09:18:09 johna Exp $
>> 9 // GEANT4 tag $Name: geant4-02-00 $
27 10
28 // /vis/viewer/set commands - John Allison 16 11 // /vis/viewer/set commands - John Allison 16th May 2000
29 12
30 #include "G4VisCommandsViewerSet.hh" 13 #include "G4VisCommandsViewerSet.hh"
31 14
32 #include "G4UIcommand.hh" 15 #include "G4UIcommand.hh"
33 #include "G4UIcmdWithoutParameter.hh" <<
34 #include "G4UIcmdWithAString.hh" 16 #include "G4UIcmdWithAString.hh"
35 #include "G4UIcmdWithABool.hh" 17 #include "G4UIcmdWithABool.hh"
36 #include "G4UIcmdWithAnInteger.hh" <<
37 #include "G4UIcmdWithADouble.hh" <<
38 #include "G4UIcmdWith3VectorAndUnit.hh" <<
39 #include "G4UnitsTable.hh" <<
40 #include "G4VisManager.hh" 18 #include "G4VisManager.hh"
41 #include "G4Polyhedron.hh" << 19 #include "G4UnitsTable.hh"
42 #include "G4SystemOfUnits.hh" << 20 #include "g4std/strstream"
>> 21
>> 22 G4String G4VisCommandsViewerSet::ConvertToString(G4bool blValue)
>> 23 {
>> 24 G4String vl = "false";
>> 25 if(blValue) vl = "true";
>> 26 return vl;
>> 27 }
43 28
44 #include <sstream> << 29 G4bool G4VisCommandsViewerSet::GetNewBoolValue(const G4String& paramString)
45 #include <iomanip> <<
46 #include <utility> <<
47 <<
48 #define G4warn G4cout <<
49 <<
50 G4VisCommandsViewerSet::G4VisCommandsViewerSet <<
51 fLightsVector (G4ThreeVector(1.,1.,1.)), <<
52 fUpVector (G4ThreeVector(0.,1.,0.)), <<
53 fViewpointVector (G4ThreeVector(0.,0.,1.)) <<
54 { 30 {
>> 31 G4String v = paramString;
>> 32 v.toUpper();
>> 33 G4bool vl = false;
>> 34 if( v=="Y" || v=="YES" || v=="1" || v=="T" || v=="TRUE" )
>> 35 { vl = true; }
>> 36 return vl;
>> 37 }
>> 38
>> 39 G4VisCommandsViewerSet::G4VisCommandsViewerSet () {
55 G4bool omitable; 40 G4bool omitable;
56 G4UIparameter* parameter; 41 G4UIparameter* parameter;
57 42
58 fpCommandAll = new G4UIcmdWithAString ("/vis 43 fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
59 fpCommandAll->SetGuidance 44 fpCommandAll->SetGuidance
60 ("Copies view parameters."); << 45 ("/vis/viewer/set/all <from-viewer-name>"
61 fpCommandAll->SetGuidance << 46 "\nCopies view parameters from from-viewer to current viewer.");
62 ("Copies ALL view parameters (except the aut <<
63 "\nfrom-viewer to current viewer. You may n <<
64 fpCommandAll->SetGuidance <<
65 ("Note: to copy only the camera-specific par <<
66 "\n\"/vis/viewer/copyfrom\"."); <<
67 fpCommandAll->SetParameterName ("from-viewer 47 fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
>> 48 viewerNameCommands.push_back (fpCommandAll);
>> 49
>> 50 fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
>> 51 fpCommandStyle->SetGuidance ("/vis/viewer/set/style wireframe|surface");
>> 52 fpCommandStyle->SetParameterName ("style",omitable = false);
>> 53 fpCommandStyle->SetCandidates("wireframe surface");
68 54
69 fpCommandAutoRefresh = new G4UIcmdWithABool << 55 fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
70 ("/vis/viewer/set/autoRefresh",this); << 56 fpCommandEdge->SetGuidance("/vis/viewer/set/edge [true|false]");
71 fpCommandAutoRefresh->SetGuidance("Sets auto << 57 fpCommandEdge->SetParameterName("edge",omitable = true);
72 fpCommandAutoRefresh->SetGuidance << 58 fpCommandEdge->SetDefaultValue(true);
73 ("If true, view is automatically refreshed a << 59
74 "\nview parameters."); << 60 fpCommandHiddenEdge =
75 fpCommandAutoRefresh->SetParameterName("auto << 61 new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
76 fpCommandAutoRefresh->SetDefaultValue(true); << 62 fpCommandHiddenEdge->SetGuidance("/vis/viewer/set/edge [true|false]");
77 << 63 fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
78 fpCommandAuxEdge = new G4UIcmdWithABool << 64 fpCommandHiddenEdge->SetDefaultValue(true);
79 ("/vis/viewer/set/auxiliaryEdge",this); <<
80 fpCommandAuxEdge->SetGuidance("Sets visibili <<
81 fpCommandAuxEdge->SetGuidance <<
82 ("Auxiliary edges, i.e., those that are part <<
83 "\nsometimes called soft edges, become visi <<
84 fpCommandAuxEdge->SetParameterName("edge",om <<
85 fpCommandAuxEdge->SetDefaultValue(true); <<
86 <<
87 fpCommandBackground = new G4UIcommand <<
88 ("/vis/viewer/set/background",this); <<
89 fpCommandBackground->SetGuidance <<
90 ("Set background colour and transparency (de <<
91 fpCommandBackground->SetGuidance(ConvertToCo <<
92 parameter = new G4UIparameter("red_or_string <<
93 parameter -> SetDefaultValue ("0."); <<
94 fpCommandBackground -> SetParameter (paramet <<
95 parameter = new G4UIparameter("green", 'd', <<
96 parameter -> SetDefaultValue (0.); <<
97 fpCommandBackground -> SetParameter (paramet <<
98 parameter = new G4UIparameter ("blue", 'd', <<
99 parameter -> SetDefaultValue (0.); <<
100 fpCommandBackground -> SetParameter (paramet <<
101 parameter = new G4UIparameter ("opacity", 'd <<
102 parameter -> SetDefaultValue (1.); <<
103 fpCommandBackground -> SetParameter (paramet <<
104 65
105 fpCommandCulling = new G4UIcommand("/vis/vie 66 fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
106 fpCommandCulling->SetGuidance ("Set culling <<
107 fpCommandCulling->SetGuidance 67 fpCommandCulling->SetGuidance
108 ("\"global\": enables/disables all other cul << 68 ("/vis/viewer/set/culling global|coveredDaughters|invisible|density"
>> 69 " [true|false] [density] [unit]");
109 fpCommandCulling->SetGuidance 70 fpCommandCulling->SetGuidance
110 ("\"coveredDaughters\": culls, i.e., elimina << 71 ("If density option is true, provide threshold density and unit");
111 "\nbe seen because covered by ancestor volu <<
112 "\nand then only if the ancestors are visib <<
113 "\nif no sections or cutaways are in operat <<
114 "\nimprove the speed of rendering visible v <<
115 fpCommandCulling->SetGuidance 72 fpCommandCulling->SetGuidance
116 ("\"invisible\": culls objects with the invi << 73 ("Unit is g/cm3, mg/cm3 or kg/m3");
117 fpCommandCulling->SetGuidance <<
118 ("\"density\": culls volumes with density lo <<
119 "\nfor eliminating \"container volumes\" wi <<
120 "\nwhose material is usually air. If this <<
121 "\ndensity and unit (e.g., g/cm3, mg/cm3 or <<
122 ); <<
123 parameter = new G4UIparameter("culling-optio 74 parameter = new G4UIparameter("culling-option",'s',omitable = false);
124 parameter->SetParameterCandidates 75 parameter->SetParameterCandidates
125 ("global coveredDaughters invisible density" << 76 ("global coveredDaughters invisible density");
126 fpCommandCulling->SetParameter(parameter); 77 fpCommandCulling->SetParameter(parameter);
127 parameter = new G4UIparameter("action",'b',o << 78 parameter = new G4UIparameter("flag",'b',omitable = true);
128 parameter->SetDefaultValue(1); << 79 parameter->SetDefaultValue("true");
129 fpCommandCulling->SetParameter(parameter); 80 fpCommandCulling->SetParameter(parameter);
130 parameter = new G4UIparameter("density-thres << 81 parameter = new G4UIparameter("density",'d',omitable = true);
131 parameter->SetDefaultValue("0.01"); 82 parameter->SetDefaultValue("0.01");
132 fpCommandCulling->SetParameter(parameter); 83 fpCommandCulling->SetParameter(parameter);
133 parameter = new G4UIparameter("unit",'s',omi 84 parameter = new G4UIparameter("unit",'s',omitable = true);
134 // parameter->SetParameterCandidates ("g/cm3 <<
135 // Instead of the above, SetNewValue accepts <<
136 parameter->SetDefaultValue("g/cm3"); 85 parameter->SetDefaultValue("g/cm3");
137 fpCommandCulling->SetParameter(parameter); 86 fpCommandCulling->SetParameter(parameter);
138 <<
139 fpCommandCutawayMode = <<
140 new G4UIcmdWithAString ("/vis/viewer/set/cut <<
141 fpCommandCutawayMode->SetGuidance <<
142 ("Sets cutaway mode - add (union) or multipl <<
143 fpCommandCutawayMode->SetParameterName ("cut <<
144 fpCommandCutawayMode->SetCandidates ("add un <<
145 fpCommandCutawayMode->SetDefaultValue("union <<
146 <<
147 fpCommandDefaultColour = new G4UIcommand <<
148 ("/vis/viewer/set/defaultColour",this); <<
149 fpCommandDefaultColour->SetGuidance <<
150 ("Set defaultColour colour and transparency <<
151 fpCommandDefaultColour->SetGuidance(ConvertT <<
152 parameter = new G4UIparameter("red_or_string <<
153 parameter -> SetDefaultValue ("1."); <<
154 fpCommandDefaultColour -> SetParameter (para <<
155 parameter = new G4UIparameter("green", 'd', <<
156 parameter -> SetDefaultValue (1.); <<
157 fpCommandDefaultColour -> SetParameter (para <<
158 parameter = new G4UIparameter ("blue", 'd', <<
159 parameter -> SetDefaultValue (1.); <<
160 fpCommandDefaultColour -> SetParameter (para <<
161 parameter = new G4UIparameter ("opacity", 'd <<
162 parameter -> SetDefaultValue (1.); <<
163 fpCommandDefaultColour -> SetParameter (para <<
164 <<
165 fpCommandDefaultTextColour = new G4UIcommand <<
166 ("/vis/viewer/set/defaultTextColour",this); <<
167 fpCommandDefaultTextColour->SetGuidance <<
168 ("Set defaultTextColour colour and transpare <<
169 fpCommandDefaultTextColour->SetGuidance(Conv <<
170 parameter = new G4UIparameter("red_or_string <<
171 parameter -> SetDefaultValue ("0."); <<
172 fpCommandDefaultTextColour -> SetParameter ( <<
173 parameter = new G4UIparameter("green", 'd', <<
174 parameter -> SetDefaultValue (0.); <<
175 fpCommandDefaultTextColour -> SetParameter ( <<
176 parameter = new G4UIparameter ("blue", 'd', <<
177 parameter -> SetDefaultValue (1.); <<
178 fpCommandDefaultTextColour -> SetParameter ( <<
179 parameter = new G4UIparameter ("opacity", 'd <<
180 parameter -> SetDefaultValue (1.); <<
181 fpCommandDefaultTextColour -> SetParameter ( <<
182 <<
183 fpCommandEdge = new G4UIcmdWithABool("/vis/v <<
184 fpCommandEdge->SetGuidance <<
185 ("Edges become visible/invisible in surface <<
186 fpCommandEdge->SetParameterName("edge",omita <<
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 fact <<
193 parameter = new G4UIparameter("explodeFactor <<
194 parameter->SetParameterRange("explodeFactor> <<
195 parameter->SetDefaultValue(1.); <<
196 fpCommandExplodeFactor->SetParameter(paramet <<
197 parameter = new G4UIparameter("x",'d',omitab <<
198 parameter->SetDefaultValue (0); <<
199 parameter->SetGuidance ("Coordinate of <<
200 fpCommandExplodeFactor->SetParameter(paramet <<
201 parameter = new G4UIparameter("y",'d',omitab <<
202 parameter->SetDefaultValue (0); <<
203 parameter->SetGuidance ("Coordinate of <<
204 fpCommandExplodeFactor->SetParameter(paramet <<
205 parameter = new G4UIparameter("z",'d',omitab <<
206 parameter->SetDefaultValue (0); <<
207 parameter->SetGuidance ("Coordinate of <<
208 fpCommandExplodeFactor->SetParameter(paramet <<
209 parameter = new G4UIparameter("unit",'s',omi <<
210 parameter->SetDefaultValue ("m"); <<
211 parameter->SetGuidance ("Unit of explod <<
212 fpCommandExplodeFactor->SetParameter(paramet <<
213 <<
214 fpCommandGlobalLineWidthScale = new G4UIcmdW <<
215 ("/vis/viewer/set/globalLineWidthScale", thi <<
216 fpCommandGlobalLineWidthScale->SetGuidance <<
217 ("Multiplies line widths by this factor."); <<
218 fpCommandGlobalLineWidthScale-> <<
219 SetParameterName("scale-factor", omitable=tr <<
220 fpCommandGlobalLineWidthScale->SetDefaultVal <<
221 <<
222 fpCommandGlobalMarkerScale = new G4UIcmdWith <<
223 ("/vis/viewer/set/globalMarkerScale", this); <<
224 fpCommandGlobalMarkerScale->SetGuidance <<
225 ("Multiplies marker sizes by this factor."); <<
226 fpCommandGlobalMarkerScale-> <<
227 SetParameterName("scale-factor", omitable=tr <<
228 fpCommandGlobalMarkerScale->SetDefaultValue( <<
229 <<
230 fpCommandHiddenEdge = <<
231 new G4UIcmdWithABool("/vis/viewer/set/hidden <<
232 fpCommandHiddenEdge->SetGuidance <<
233 ("Edges become hidden/seen in wireframe or s <<
234 fpCommandHiddenEdge->SetParameterName("hidde <<
235 fpCommandHiddenEdge->SetDefaultValue(true); <<
236 <<
237 fpCommandHiddenMarker = <<
238 new G4UIcmdWithABool("/vis/viewer/set/hidden <<
239 fpCommandHiddenMarker->SetGuidance <<
240 ("If true, closer objects hide markers. Othe <<
241 fpCommandHiddenMarker->SetParameterName("hid <<
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("light <<
249 fpCommandLightsMove->SetCandidates <<
250 ("cam camera with-camera obj object with-obj <<
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', <<
257 parameter -> SetDefaultValue(60.); <<
258 fpCommandLightsThetaPhi -> SetParameter (par <<
259 parameter = new G4UIparameter("phi", 'd', om <<
260 parameter -> SetDefaultValue(45.); <<
261 fpCommandLightsThetaPhi -> SetParameter (par <<
262 parameter = new G4UIparameter ("unit", 's', <<
263 parameter -> SetDefaultValue ("deg"); <<
264 fpCommandLightsThetaPhi -> SetParameter (par <<
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', omit <<
271 parameter -> SetDefaultValue (1); <<
272 fpCommandLightsVector -> SetParameter (param <<
273 parameter = new G4UIparameter("y", 'd', omit <<
274 parameter -> SetDefaultValue (1); <<
275 fpCommandLightsVector -> SetParameter (param <<
276 parameter = new G4UIparameter ("z", 'd', omi <<
277 parameter -> SetDefaultValue (1); <<
278 fpCommandLightsVector -> SetParameter (param <<
279 <<
280 fpCommandLineSegments = new G4UIcmdWithAnInt <<
281 ("/vis/viewer/set/lineSegmentsPerCircle",thi <<
282 fpCommandLineSegments->SetGuidance <<
283 ("Set number of sides per circle for polygon <<
284 fpCommandLineSegments->SetGuidance <<
285 ("Refers to graphical representation of obje <<
286 fpCommandLineSegments->SetParameterName("lin <<
287 fpCommandLineSegments->SetDefaultValue(24); <<
288 <<
289 fpCommandLineWidth = new G4UIcmdWithoutParam <<
290 ("/vis/viewer/set/lineWidth",this); <<
291 fpCommandLineWidth->SetGuidance <<
292 ("Use \"/vis/viewer/set/globalLineWidthScale <<
293 "\nFor trajectories use \"/vis/modeling/tra <<
294 "\nFor volumes use \"/vis/geometry/set/line <<
295 <<
296 fpCommandNumberOfCloudPoints = new G4UIcmdWi <<
297 ("/vis/viewer/set/numberOfCloudPoints",this) <<
298 fpCommandNumberOfCloudPoints->SetGuidance <<
299 ("Set number of points to be used for cloud <<
300 fpCommandNumberOfCloudPoints->SetParameterNa <<
301 fpCommandNumberOfCloudPoints->SetDefaultValu <<
302 <<
303 fpCommandPicking = new G4UIcmdWithABool <<
304 ("/vis/viewer/set/picking",this); <<
305 fpCommandPicking->SetGuidance("Sets picking, <<
306 fpCommandPicking->SetGuidance <<
307 ("If true, view is set up for picking, if av <<
308 fpCommandPicking->SetGuidance <<
309 ("You may need to issue \"/vis/viewer/update <<
310 fpCommandPicking->SetGuidance <<
311 ("For required actions, watch for instructio <<
312 fpCommandPicking->SetParameterName("picking" <<
313 fpCommandPicking->SetDefaultValue(true); <<
314 <<
315 fpCommandProjection = new G4UIcommand("/vis/ <<
316 fpCommandProjection->SetGuidance <<
317 ("Set projection style - o[rthogonal] or p[e <<
318 "\nIf p[erspective], also set field half an <<
319 parameter = new G4UIparameter("projection",' <<
320 parameter->SetParameterCandidates("o orthogo <<
321 parameter->SetDefaultValue("orthogonal"); <<
322 fpCommandProjection->SetParameter(parameter) <<
323 parameter = new G4UIparameter("field-half-an <<
324 parameter->SetDefaultValue(30.); <<
325 //parameter->SetCurrentAsDefault(true); <<
326 fpCommandProjection->SetParameter(parameter) <<
327 parameter = new G4UIparameter("unit",'s',omi <<
328 parameter->SetDefaultValue("deg"); <<
329 //parameter->SetCurrentAsDefault(true); <<
330 fpCommandProjection->SetParameter(parameter) <<
331 <<
332 fpCommandRotationStyle = new G4UIcmdWithAStr <<
333 ("/vis/viewer/set/rotationStyle",this); <<
334 fpCommandRotationStyle->SetGuidance <<
335 ("Set style of rotation - constrainUpDirecti <<
336 fpCommandRotationStyle->SetGuidance <<
337 ("constrainUpDirection: conventional HEP vie <<
338 fpCommandRotationStyle->SetGuidance <<
339 ("freeRotation: Google-like rotation, using <<
340 fpCommandRotationStyle->SetParameterName ("s <<
341 fpCommandRotationStyle->SetCandidates("const <<
342 <<
343 fpCommandSectionPlane = new G4UIcommand("/vi <<
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 <<
349 "\nTo turn off: /vis/viewer/set/sectionPlan <<
350 parameter = new G4UIparameter("Selector",' <<
351 parameter -> SetDefaultValue ("on"); <<
352 fpCommandSectionPlane->SetParameter(paramete <<
353 parameter = new G4UIparameter("x",'d',omit <<
354 parameter -> SetDefaultValue (0); <<
355 parameter -> SetGuidance ("Coordinate <<
356 fpCommandSectionPlane->SetParameter(paramete <<
357 parameter = new G4UIparameter("y",'d',omit <<
358 parameter -> SetDefaultValue (0); <<
359 parameter -> SetGuidance ("Coordinate <<
360 fpCommandSectionPlane->SetParameter(paramete <<
361 parameter = new G4UIparameter("z",'d',omit <<
362 parameter -> SetDefaultValue (0); <<
363 parameter -> SetGuidance ("Coordinate <<
364 fpCommandSectionPlane->SetParameter(paramete <<
365 parameter = new G4UIparameter("unit",'s',o <<
366 parameter -> SetDefaultValue ("m"); <<
367 parameter -> SetGuidance ("Unit of poi <<
368 fpCommandSectionPlane->SetParameter(paramete <<
369 parameter = new G4UIparameter("nx",'d',omi <<
370 parameter -> SetDefaultValue (1); <<
371 parameter -> SetGuidance ("Component o <<
372 fpCommandSectionPlane->SetParameter(paramete <<
373 parameter = new G4UIparameter("ny",'d',omi <<
374 parameter -> SetDefaultValue (0); <<
375 parameter -> SetGuidance ("Component o <<
376 fpCommandSectionPlane->SetParameter(paramete <<
377 parameter = new G4UIparameter("nz",'d',omi <<
378 parameter -> SetDefaultValue (0); <<
379 parameter -> SetGuidance ("Component o <<
380 fpCommandSectionPlane->SetParameter(paramete <<
381 <<
382 fpCommandSpecialMeshRendering = new G4UIcmdW <<
383 ("/vis/viewer/set/specialMeshRendering",this <<
384 fpCommandSpecialMeshRendering -> SetGuidance <<
385 ("Request special rendering of volumes (mesh <<
386 fpCommandSpecialMeshRendering->SetParameterN <<
387 fpCommandSpecialMeshRendering->SetDefaultVal <<
388 <<
389 fpCommandSpecialMeshRenderingOption = new G4 <<
390 ("/vis/viewer/set/specialMeshRenderingOption <<
391 fpCommandSpecialMeshRenderingOption->SetGuid <<
392 ("Set special mesh rendering option - \"defa <<
393 fpCommandSpecialMeshRenderingOption->SetPara <<
394 fpCommandSpecialMeshRenderingOption->SetCand <<
395 fpCommandSpecialMeshRenderingOption->SetDefa <<
396 <<
397 fpCommandSpecialMeshVolumes = new G4UIcomman <<
398 ("/vis/viewer/set/specialMeshVolumes",this); <<
399 fpCommandSpecialMeshVolumes -> SetGuidance <<
400 ("Specify the volumes for special rendering. <<
401 "\nand is interpreted to mean \"all found m <<
402 fpCommandSpecialMeshVolumes->SetGuidance <<
403 ("Please provide a list of space-separated p <<
404 "\nnumber pairs. Negative copy number means <<
405 parameter = new G4UIparameter("volumes",'s', <<
406 parameter->SetGuidance <<
407 ("List of physical volume names and copy num <<
408 fpCommandSpecialMeshVolumes->SetParameter(pa <<
409 <<
410 fpCommandStyle = new G4UIcmdWithAString ("/v <<
411 fpCommandStyle->SetGuidance <<
412 ("Set style of drawing - w[ireframe] or s[ur <<
413 fpCommandStyle->SetGuidance <<
414 ("(Hidden line drawing is controlled by \"/v <<
415 fpCommandStyle->SetParameterName ("style",om <<
416 fpCommandStyle->SetCandidates("w wireframe s <<
417 <<
418 fpCommandTargetPoint = new G4UIcmdWith3Vecto <<
419 ("/vis/viewer/set/targetPoint", this); <<
420 fpCommandTargetPoint->SetGuidance <<
421 ("Set target point."); <<
422 fpCommandTargetPoint->SetGuidance <<
423 ("This sets the \"Current Target Point\" rel <<
424 fpCommandTargetPoint->SetGuidance <<
425 ("Target Point\" so that the actual target p <<
426 fpCommandTargetPoint->SetGuidance <<
427 ("(See G4ViewParameters.hh for an explanatio <<
428 fpCommandTargetPoint->SetParameterName("x", <<
429 fpCommandTargetPoint->SetUnitCategory("Lengt <<
430 <<
431 fpCommandUpThetaPhi = new G4UIcommand <<
432 ("/vis/viewer/set/upThetaPhi", this); <<
433 fpCommandUpThetaPhi -> SetGuidance ("Set up <<
434 fpCommandUpThetaPhi -> SetGuidance <<
435 ("Viewer will attempt always to show this di <<
436 parameter = new G4UIparameter("theta", 'd', <<
437 parameter -> SetDefaultValue (90.); <<
438 fpCommandUpThetaPhi -> SetParameter (paramet <<
439 parameter = new G4UIparameter("phi", 'd', om <<
440 parameter -> SetDefaultValue (90.); <<
441 fpCommandUpThetaPhi -> SetParameter (paramet <<
442 parameter = new G4UIparameter ("unit", 's', <<
443 parameter -> SetDefaultValue ("deg"); <<
444 fpCommandUpThetaPhi -> SetParameter (paramet <<
445 <<
446 fpCommandUpVector = new G4UIcommand <<
447 ("/vis/viewer/set/upVector", this); <<
448 fpCommandUpVector -> SetGuidance ("Set up ve <<
449 fpCommandUpVector -> SetGuidance <<
450 ("Viewer will attempt always to show this di <<
451 parameter = new G4UIparameter("x", 'd', omit <<
452 parameter -> SetDefaultValue (0.); <<
453 fpCommandUpVector -> SetParameter (parameter <<
454 parameter = new G4UIparameter("y", 'd', omit <<
455 parameter -> SetDefaultValue (1.); <<
456 fpCommandUpVector -> SetParameter (parameter <<
457 parameter = new G4UIparameter ("z", 'd', omi <<
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 light <<
467 parameter = new G4UIparameter("theta", 'd', <<
468 parameter -> SetDefaultValue (60.); <<
469 fpCommandViewpointThetaPhi -> SetParameter ( <<
470 parameter = new G4UIparameter("phi", 'd', om <<
471 parameter -> SetDefaultValue (45.); <<
472 fpCommandViewpointThetaPhi -> SetParameter ( <<
473 parameter = new G4UIparameter ("unit", 's', <<
474 parameter -> SetDefaultValue ("deg"); <<
475 fpCommandViewpointThetaPhi -> SetParameter ( <<
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 light <<
483 parameter = new G4UIparameter("x", 'd', omit <<
484 parameter -> SetDefaultValue (1.); <<
485 fpCommandViewpointVector -> SetParameter (pa <<
486 parameter = new G4UIparameter("y", 'd', omit <<
487 parameter -> SetDefaultValue (1.); <<
488 fpCommandViewpointVector -> SetParameter (pa <<
489 parameter = new G4UIparameter ("z", 'd', omi <<
490 parameter -> SetDefaultValue (1.); <<
491 fpCommandViewpointVector -> SetParameter (pa <<
492 <<
493 fpTimeWindowDirectory = new G4UIdirectory (" <<
494 fpTimeWindowDirectory -> SetGuidance ("Set t <<
495 G4String timeWindowGuidance = <<
496 "For these commands use" <<
497 "\n /vis/scene/add/trajectories rich" <<
498 "\n /vis/modeling/trajectories/drawByCharge <<
499 "\nthen typically" <<
500 "\n /vis/viewer/set/timeWindow/displayLight <<
501 "\n /vis/viewer/set/timeWindow/displayHeadT <<
502 "\n /vis/viewer/set/timeWindow/fadeFactor 1 <<
503 "\n /run/beamOn # or several until you get <<
504 "\n /vis/viewer/set/timeWindow/startTime 0 <<
505 "\n /vis/viewer/save" <<
506 "\n /vis/viewer/set/timeWindow/startTime 1 <<
507 "\nthen zoom, pan etc to a view of interest <<
508 "\n /vis/viewer/save" <<
509 "\nthen repeat with next start time, another <<
510 "\n /vis/viewer/interpolate"; <<
511 <<
512 fpCommandTimeWindowDisplayHeadTime = <<
513 new G4UIcommand("/vis/viewer/set/timeWindow/ <<
514 fpCommandTimeWindowDisplayHeadTime->SetGuida <<
515 ("Display head time of range in 2D text."); <<
516 fpCommandTimeWindowDisplayHeadTime->SetGuida <<
517 parameter = new G4UIparameter ("displayHeadT <<
518 parameter->SetDefaultValue(false); <<
519 fpCommandTimeWindowDisplayHeadTime->SetParam <<
520 parameter = new G4UIparameter ("screenX", 'd <<
521 parameter->SetGuidance("-1 < screenX < 1"); <<
522 parameter->SetParameterRange("screenX >= -1. <<
523 parameter->SetDefaultValue(-0.9); <<
524 fpCommandTimeWindowDisplayHeadTime->SetParam <<
525 parameter = new G4UIparameter ("screenY", 'd <<
526 parameter->SetGuidance("-1 < screenY < 1"); <<
527 parameter->SetParameterRange("screenY >= -1. <<
528 parameter->SetDefaultValue(-0.9); <<
529 fpCommandTimeWindowDisplayHeadTime->SetParam <<
530 parameter = new G4UIparameter ("screenSize", <<
531 parameter->SetDefaultValue(24.); <<
532 fpCommandTimeWindowDisplayHeadTime->SetParam <<
533 parameter = new G4UIparameter ("red", 'd', o <<
534 parameter->SetParameterRange("red >= 0. && r <<
535 parameter->SetDefaultValue(0.); <<
536 fpCommandTimeWindowDisplayHeadTime->SetParam <<
537 parameter = new G4UIparameter ("green", 'd', <<
538 parameter->SetParameterRange("green >= 0. && <<
539 parameter->SetDefaultValue(1.); <<
540 fpCommandTimeWindowDisplayHeadTime->SetParam <<
541 parameter = new G4UIparameter ("blue", 'd', <<
542 parameter->SetParameterRange("blue >= 0. && <<
543 parameter->SetDefaultValue(1.); <<
544 fpCommandTimeWindowDisplayHeadTime->SetParam <<
545 <<
546 fpCommandTimeWindowDisplayLightFront = <<
547 new G4UIcommand("/vis/viewer/set/timeWindow/ <<
548 fpCommandTimeWindowDisplayLightFront->SetGui <<
549 ("Display the light front at head time."); <<
550 fpCommandTimeWindowDisplayLightFront->SetGui <<
551 ("Tip: The trajectories can appear of jump a <<
552 "\nbecause their time range overlaps the vi <<
553 "\naverage out this discrete time effect, a <<
554 "\nhalf the trajectories interval. E.g., if <<
555 "\ninterval is 0.01 ns:" <<
556 "\n /vis/viewer/set/timeWindow/displayLigh <<
557 "\nTo prevent them beating the light front <<
558 "\n /vis/viewer/set/timeWindow/displayLigh <<
559 fpCommandTimeWindowDisplayLightFront->SetGui <<
560 parameter = new G4UIparameter ("displayLight <<
561 parameter->SetDefaultValue(true); <<
562 fpCommandTimeWindowDisplayLightFront->SetPar <<
563 parameter = new G4UIparameter ("originX", 'd <<
564 parameter->SetDefaultValue(0.); <<
565 fpCommandTimeWindowDisplayLightFront->SetPar <<
566 parameter = new G4UIparameter ("originY", 'd <<
567 parameter->SetDefaultValue(0.); <<
568 fpCommandTimeWindowDisplayLightFront->SetPar <<
569 parameter = new G4UIparameter ("originZ", 'd <<
570 parameter->SetDefaultValue(0.); <<
571 fpCommandTimeWindowDisplayLightFront->SetPar <<
572 parameter = new G4UIparameter ("space_unit", <<
573 parameter->SetDefaultValue("m"); <<
574 fpCommandTimeWindowDisplayLightFront->SetPar <<
575 parameter = new G4UIparameter ("originT", 'd <<
576 parameter->SetDefaultValue(0.); <<
577 fpCommandTimeWindowDisplayLightFront->SetPar <<
578 parameter = new G4UIparameter ("time_unit", <<
579 parameter->SetDefaultValue("s"); <<
580 fpCommandTimeWindowDisplayLightFront->SetPar <<
581 parameter = new G4UIparameter ("red", 'd', o <<
582 parameter->SetParameterRange("red >= 0. && r <<
583 parameter->SetDefaultValue(0.); <<
584 fpCommandTimeWindowDisplayLightFront->SetPar <<
585 parameter = new G4UIparameter ("green", 'd', <<
586 parameter->SetParameterRange("green >= 0. && <<
587 parameter->SetDefaultValue(1.); <<
588 fpCommandTimeWindowDisplayLightFront->SetPar <<
589 parameter = new G4UIparameter ("blue", 'd', <<
590 parameter->SetParameterRange("blue >= 0. && <<
591 parameter->SetDefaultValue(0.); <<
592 fpCommandTimeWindowDisplayLightFront->SetPar <<
593 <<
594 fpCommandTimeWindowEndTime = <<
595 new G4UIcommand("/vis/viewer/set/timeWindow/ <<
596 fpCommandTimeWindowEndTime->SetGuidance("Set <<
597 fpCommandTimeWindowEndTime->SetGuidance(time <<
598 parameter = new G4UIparameter ("end-time", ' <<
599 parameter->SetDefaultValue(G4VisAttributes:: <<
600 fpCommandTimeWindowEndTime->SetParameter(par <<
601 parameter = new G4UIparameter ("end-time-uni <<
602 parameter->SetDefaultValue("ns"); <<
603 fpCommandTimeWindowEndTime->SetParameter(par <<
604 parameter = new G4UIparameter ("time-range", <<
605 parameter->SetDefaultValue(-1.); <<
606 fpCommandTimeWindowEndTime->SetParameter(par <<
607 parameter = new G4UIparameter ("time-range-u <<
608 parameter->SetDefaultValue("ns"); <<
609 fpCommandTimeWindowEndTime->SetParameter(par <<
610 <<
611 fpCommandTimeWindowFadeFactor = <<
612 new G4UIcmdWithADouble("/vis/viewer/set/time <<
613 fpCommandTimeWindowFadeFactor->SetGuidance <<
614 ("0: no fade; 1: maximum fade with time wind <<
615 fpCommandTimeWindowFadeFactor->SetGuidance(t <<
616 fpCommandTimeWindowFadeFactor->SetParameterN <<
617 fpCommandTimeWindowFadeFactor->SetRange("fad <<
618 fpCommandTimeWindowFadeFactor->SetDefaultVal <<
619 <<
620 fpCommandTimeWindowStartTime = <<
621 new G4UIcommand("/vis/viewer/set/timeWindow/ <<
622 fpCommandTimeWindowStartTime->SetGuidance("S <<
623 fpCommandTimeWindowStartTime->SetGuidance(ti <<
624 parameter = new G4UIparameter ("start-time", <<
625 parameter->SetDefaultValue(-G4VisAttributes: <<
626 fpCommandTimeWindowStartTime->SetParameter(p <<
627 parameter = new G4UIparameter ("start-time-u <<
628 parameter->SetDefaultValue("ns"); <<
629 fpCommandTimeWindowStartTime->SetParameter(p <<
630 parameter = new G4UIparameter ("time-range", <<
631 parameter->SetDefaultValue(-1.); <<
632 fpCommandTimeWindowStartTime->SetParameter(p <<
633 parameter = new G4UIparameter ("time-range-u <<
634 parameter->SetDefaultValue("ns"); <<
635 fpCommandTimeWindowStartTime->SetParameter(p <<
636 } 87 }
637 88
638 G4VisCommandsViewerSet::~G4VisCommandsViewerSe 89 G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
639 delete fpCommandTimeWindowStartTime; << 90 delete fpCommandAll;
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; 91 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; 92 delete fpCommandEdge;
670 delete fpCommandDefaultTextColour; << 93 delete fpCommandHiddenEdge;
671 delete fpCommandDefaultColour; <<
672 delete fpCommandCutawayMode; <<
673 delete fpCommandCulling; 94 delete fpCommandCulling;
674 delete fpCommandBackground; <<
675 delete fpCommandAuxEdge; <<
676 delete fpCommandAutoRefresh; <<
677 delete fpCommandAll; <<
678 } 95 }
679 96
680 G4String G4VisCommandsViewerSet::GetCurrentVal << 97 G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand* command) {
681 return ""; << 98 return "invalid";
682 } 99 }
683 100
684 void G4VisCommandsViewerSet::SetNewValue 101 void G4VisCommandsViewerSet::SetNewValue
685 (G4UIcommand* command,G4String newValue) { 102 (G4UIcommand* command,G4String newValue) {
686 103
687 G4VisManager::Verbosity verbosity = fpVisMan <<
688 <<
689 G4VViewer* currentViewer = fpVisManager->Get 104 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
690 if (!currentViewer) { 105 if (!currentViewer) {
691 if (verbosity >= G4VisManager::errors) { << 106 G4cout << "G4VisCommandsViewerSet::SetNewValue: no current viewer."
692 G4warn << << 107 << G4endl;
693 "ERROR: G4VisCommandsViewerSet::SetNewVa <<
694 << G4endl; <<
695 } <<
696 return; 108 return;
697 } 109 }
698 110
699 G4ViewParameters vp = currentViewer->GetView 111 G4ViewParameters vp = currentViewer->GetViewParameters();
700 112
701 if (command == fpCommandAll) { 113 if (command == fpCommandAll) {
702 G4VViewer* fromViewer = fpVisManager->GetV 114 G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
703 if (!fromViewer) { 115 if (!fromViewer) {
704 if (verbosity >= G4VisManager::errors) { << 116 G4cout <<
705 G4warn << << 117 "G4VisCommandsViewerSet::SetNewValue: all: unrecognised from-viewer."
706 "ERROR: G4VisCommandsViewerSet::SetNew << 118 << G4endl;
707 "\n unrecognised from-viewer." <<
708 << G4endl; <<
709 } <<
710 return; 119 return;
711 } 120 }
712 if (fromViewer == currentViewer) { 121 if (fromViewer == currentViewer) {
713 if (verbosity >= G4VisManager::warnings) << 122 G4cout <<
714 G4warn << << 123 "G4VisCommandsViewerSet::SetNewValue: all:"
715 "WARNING: G4VisCommandsViewerSet::SetN << 124 "\n from-viewer and current viewer are identical."
716 "\n from-viewer and current viewer ar << 125 << G4endl;
717 << G4endl; <<
718 } <<
719 return; 126 return;
720 } 127 }
721 // Copy view parameters except for autoRef <<
722 auto keepAutoRefresh = vp.IsAutoRefresh(); <<
723 auto keepBackground = vp.GetBackgroundCol <<
724 vp = fromViewer->GetViewParameters(); 128 vp = fromViewer->GetViewParameters();
725 vp.SetAutoRefresh(keepAutoRefresh); << 129 G4cout << "View parameters of viewer \"" << currentViewer->GetName()
726 vp.SetBackgroundColour(keepBackground); << 130 << "\"\n set to those of viewer \"" << fromViewer->GetName()
727 // Concatenate any private vis attributes << 131 << "\"."
728 const std::vector<G4ModelingParameters::Vi << 132 << G4endl;
729 privateVAMs = fromViewer->GetPrivateVisAtt <<
730 if (privateVAMs) { <<
731 std::vector<G4ModelingParameters::VisAtt <<
732 for (i = privateVAMs->begin(); i != priv <<
733 vp.AddVisAttributesModifier(*i); <<
734 } <<
735 } <<
736 if (verbosity >= G4VisManager::confirmatio <<
737 G4cout << "View parameters of viewer \"" <<
738 << "\"\n set to those of viewer \"" << <<
739 << "\"." <<
740 << G4endl; <<
741 } <<
742 if (verbosity >= G4VisManager::warnings) { <<
743 G4warn << "You may need \"/vis/viewer/re <<
744 << G4endl; <<
745 } <<
746 } <<
747 <<
748 else if (command == fpCommandAutoRefresh) { <<
749 G4bool autoRefresh = G4UIcommand::ConvertT <<
750 const G4ViewParameters& defaultVP = <<
751 currentViewer->GetDefaultViewParameters(); <<
752 if (autoRefresh && !defaultVP.IsAutoRefres <<
753 if (verbosity >= G4VisManager::warnings) <<
754 G4warn <<
755 << "WARNING: " <<
756 << currentViewer->GetName() << " is NO <<
757 << "\n so cannot be set to auto-refre <<
758 << G4endl; <<
759 } <<
760 return; <<
761 } <<
762 vp.SetAutoRefresh(autoRefresh); <<
763 if (verbosity >= G4VisManager::confirmatio <<
764 G4cout << "Views will "; <<
765 if (!vp.IsAutoRefresh()) G4cout << "not <<
766 G4cout << "be automatically refreshed af <<
767 << G4endl; <<
768 } <<
769 if (!vp.IsAutoRefresh()) { <<
770 currentViewer->SetViewParameters(vp); <<
771 return; // Avoid a refresh if auto-refr <<
772 } // ...otherwise take normal action. <<
773 } <<
774 <<
775 else if (command == fpCommandAuxEdge) { <<
776 vp.SetAuxEdgeVisible(G4UIcommand::ConvertT <<
777 if (verbosity >= G4VisManager::confirmatio <<
778 G4cout << "Auxiliary edges will "; <<
779 if (!vp.IsAuxEdgeVisible()) G4cout << "n <<
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 >> opa <<
789 G4Colour colour(0.,0.,0.); // Default bla <<
790 ConvertToColour(colour, redOrString, green <<
791 vp.SetBackgroundColour(colour); <<
792 if (verbosity >= G4VisManager::confirmatio <<
793 G4cout << "Background colour " <<
794 << vp.GetBackgroundColour() <<
795 << " requested." <<
796 << G4endl; <<
797 } <<
798 } 133 }
799 134
800 else if (command == fpCommandCulling) { << 135 else if (command == fpCommandStyle) {
801 G4String cullingOption, stringFlag, unit; << 136 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
802 G4double density; << 137 if (newValue == "wireframe") {
803 std::istringstream is (newValue); << 138 switch (existingStyle) {
804 is >> cullingOption >> stringFlag >> densi << 139 case G4ViewParameters::wireframe:
805 G4bool boolFlag = G4UIcommand::ConvertToBo << 140 break;
806 if (cullingOption == "global") { << 141 case G4ViewParameters::hlr:
807 vp.SetCulling(boolFlag); << 142 break;
808 if (verbosity >= G4VisManager::confirmat << 143 case G4ViewParameters::hsr:
809 G4cout << << 144 vp.SetDrawingStyle(G4ViewParameters::wireframe);
810 "G4VisCommandsViewerSet::SetNewValue: << 145 break;
811 " set to " << G4UIcommand::ConvertToSt << 146 case G4ViewParameters::hlhsr:
812 ".\n Does not change specific culling << 147 vp.SetDrawingStyle(G4ViewParameters::hlr);
813 << G4endl; << 148 break;
814 } <<
815 } <<
816 else if (cullingOption == "coveredDaughter <<
817 vp.SetCullingCovered(boolFlag); <<
818 if (verbosity >= G4VisManager::confirmat <<
819 G4cout << <<
820 "G4VisCommandsViewerSet::SetNewValue: <<
821 "\n daughters flag set to " <<
822 << G4UIcommand::ConvertToString(boolFl <<
823 ". Daughters covered by opaque mother <<
824 "\n will be culled, i.e., not drawn, <<
825 "\n Note: this is only effective in s <<
826 "\n and then only if the volumes are <<
827 "\n only if no sections or cutaways a <<
828 << G4endl; <<
829 } <<
830 } <<
831 else if (cullingOption == "invisible") { <<
832 vp.SetCullingInvisible(boolFlag); <<
833 if (verbosity >= G4VisManager::confirmat <<
834 G4cout << <<
835 "G4VisCommandsViewerSet::SetNewValue: <<
836 "\n flag set to " <<
837 << boolFlag << G4UIcommand::ConvertToS <<
838 ". Volumes marked invisible will be c <<
839 "\n i.e., not drawn, if this flag is <<
840 << G4endl; <<
841 } 149 }
842 } 150 }
843 else if (cullingOption == "density") { << 151 else if (newValue == "surface") {
844 const G4String where = << 152 switch (existingStyle) {
845 "G4VisCommandsViewerSet::SetNewValue: cu << 153 case G4ViewParameters::wireframe:
846 if (boolFlag) { << 154 vp.SetDrawingStyle(G4ViewParameters::hsr);
847 G4double valueOfUnit; << 155 break;
848 // "Volumic Mass" is Michel's phrase f << 156 case G4ViewParameters::hlr:
849 if (ProvideValueOfUnit(where,unit,"Vol << 157 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
850 // Successful outcome of unit search << 158 break;
851 vp.SetDensityCulling(boolFlag); << 159 case G4ViewParameters::hsr:
852 density *= valueOfUnit; << 160 break;
853 vp.SetVisibleDensity(density); << 161 case G4ViewParameters::hlhsr:
854 } else { << 162 break;
855 // Unsuccessful outcome of unit sear <<
856 density = vp.GetVisibleDensity(); <<
857 } <<
858 } else { // Reset flag but density unch <<
859 vp.SetDensityCulling(boolFlag); <<
860 } <<
861 if (verbosity >= G4VisManager::confirmat <<
862 G4cout <<
863 << where <<
864 << "\n flag set to " <<
865 << std::boolalpha << vp.IsDensityCulli <<
866 << ". Volumes with density less than <<
867 << G4BestUnit(density,"Volumic Mass") <<
868 << "\n will be culled, i.e., not draw <<
869 << G4endl; <<
870 } 163 }
871 } 164 }
872 else { 165 else {
873 if (verbosity >= G4VisManager::errors) { << 166 G4cout <<
874 G4warn << << 167 "G4VisCommandsViewerSet::SetNewValue: style: unrecognised style."
875 "ERROR: G4VisCommandsViewerSet::SetNew << 168 << G4endl;
876 "\n option not recognised." << 169 return;
877 << G4endl; <<
878 } <<
879 } <<
880 } <<
881 <<
882 else if (command == fpCommandCutawayMode) { <<
883 if (newValue == "add" || newValue == "unio <<
884 vp.SetCutawayMode(G4ViewParameters::cuta <<
885 if (newValue == "multiply" || newValue == <<
886 vp.SetCutawayMode(G4ViewParameters::cuta <<
887 <<
888 if (verbosity >= G4VisManager::confirmatio <<
889 G4cout << "Cutaway mode set to "; <<
890 if (vp.GetCutawayMode() == G4ViewParamet <<
891 G4cout << "cutawayUnion"; <<
892 if (vp.GetCutawayMode() == G4ViewParamet <<
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 >> opa <<
903 G4Colour colour(1.,1.,1.); // Default whi <<
904 ConvertToColour(colour, redOrString, green <<
905 G4VisAttributes va = vp.GetDefaultVisAttri <<
906 va.SetColour(colour); <<
907 vp.SetDefaultVisAttributes(va); <<
908 if (verbosity >= G4VisManager::confirmatio <<
909 G4cout << "Default colour " <<
910 << vp.GetDefaultVisAttributes()->GetColo <<
911 << " requested." <<
912 << G4endl; <<
913 } <<
914 } <<
915 <<
916 else if (command == fpCommandDefaultTextColo <<
917 G4String redOrString; <<
918 G4double green, blue, opacity; <<
919 std::istringstream iss(newValue); <<
920 iss >> redOrString >> green >> blue >> opa <<
921 G4Colour colour(1.,1.,1.); // Default whi <<
922 ConvertToColour(colour, redOrString, green <<
923 G4VisAttributes va = vp.GetDefaultTextVisA <<
924 va.SetColour(colour); <<
925 vp.SetDefaultTextVisAttributes(va); <<
926 if (verbosity >= G4VisManager::confirmatio <<
927 G4cout << "Default colour " <<
928 << vp.GetDefaultTextVisAttributes()->Get <<
929 << " requested." <<
930 << G4endl; <<
931 } 170 }
>> 171 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
>> 172 << "\" set to " << vp.GetDrawingStyle()
>> 173 << G4endl;
932 } 174 }
933 175
934 else if (command == fpCommandEdge) { 176 else if (command == fpCommandEdge) {
935 G4ViewParameters::DrawingStyle existingSty 177 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
936 if (G4UIcommand::ConvertToBool(newValue)) << 178 if (GetNewBoolValue(newValue)) {
937 switch (existingStyle) { 179 switch (existingStyle) {
938 case G4ViewParameters::wireframe: << 180 case G4ViewParameters::wireframe:
939 break; << 181 break;
940 case G4ViewParameters::hlr: << 182 case G4ViewParameters::hlr:
941 break; << 183 break;
942 case G4ViewParameters::hsr: << 184 case G4ViewParameters::hsr:
943 vp.SetDrawingStyle(G4ViewParameters: << 185 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
944 break; << 186 break;
945 case G4ViewParameters::hlhsr: << 187 case G4ViewParameters::hlhsr:
946 break; << 188 break;
947 case G4ViewParameters::cloud: <<
948 break; <<
949 } 189 }
950 } 190 }
951 else { // false << 191 else {
952 switch (existingStyle) { 192 switch (existingStyle) {
953 case G4ViewParameters::wireframe: << 193 case G4ViewParameters::wireframe:
954 break; << 194 break;
955 case G4ViewParameters::hlr: << 195 case G4ViewParameters::hlr:
956 break; << 196 break;
957 case G4ViewParameters::hsr: << 197 case G4ViewParameters::hsr:
958 break; << 198 break;
959 case G4ViewParameters::hlhsr: << 199 case G4ViewParameters::hlhsr:
960 vp.SetDrawingStyle(G4ViewParameters: << 200 vp.SetDrawingStyle(G4ViewParameters::hsr);
961 break; << 201 break;
962 case G4ViewParameters::cloud: <<
963 break; <<
964 } 202 }
965 } 203 }
966 if (verbosity >= G4VisManager::confirmatio << 204 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
967 G4cout << "Drawing style of viewer \"" < << 205 << "\" set to " << vp.GetDrawingStyle()
968 << "\" set to " << vp.GetDrawingStyle() << 206 << G4endl;
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 >> unit <<
978 G4double unit = G4UIcommand::ValueOf(unitS <<
979 vp.SetExplodeFactor(explodeFactor); <<
980 vp.SetExplodeCentre(G4Point3D(x * unit, y <<
981 if (verbosity >= G4VisManager::confirmatio <<
982 G4cout << "Explode factor changed to " < <<
983 << " from centre " << vp.GetExplodeCentr <<
984 << G4endl; <<
985 } <<
986 } <<
987 <<
988 else if (command == fpCommandGlobalLineWidth <<
989 G4double globalLineWidthScale <<
990 = fpCommandGlobalLineWidthScale->GetNewDou <<
991 vp.SetGlobalLineWidthScale(globalLineWidth <<
992 if (verbosity >= G4VisManager::confirmatio <<
993 G4cout << "Global Line Width Scale chang <<
994 << vp.GetGlobalLineWidthScale() << G4end <<
995 } <<
996 } <<
997 <<
998 else if (command == fpCommandGlobalMarkerSca <<
999 G4double globalMarkerScale <<
1000 = fpCommandGlobalMarkerScale->GetNewDoubl <<
1001 vp.SetGlobalMarkerScale(globalMarkerScale <<
1002 if (verbosity >= G4VisManager::confirmati <<
1003 G4cout << "Global Marker Scale changed <<
1004 << vp.GetGlobalMarkerScale() << G4endl; <<
1005 } <<
1006 } 207 }
1007 208
1008 else if (command == fpCommandHiddenEdge) { 209 else if (command == fpCommandHiddenEdge) {
1009 G4ViewParameters::DrawingStyle existingSt 210 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
1010 if (G4UIcommand::ConvertToBool(newValue)) << 211 if (GetNewBoolValue(newValue)) {
1011 switch (existingStyle) { 212 switch (existingStyle) {
1012 case G4ViewParameters::wireframe: << 213 case G4ViewParameters::wireframe:
1013 vp.SetDrawingStyle(G4ViewParameters << 214 vp.SetDrawingStyle(G4ViewParameters::hlr);
1014 break; << 215 break;
1015 case G4ViewParameters::hlr: << 216 case G4ViewParameters::hlr:
1016 break; << 217 break;
1017 case G4ViewParameters::hsr: << 218 case G4ViewParameters::hsr:
1018 vp.SetDrawingStyle(G4ViewParameters << 219 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1019 break; << 220 break;
1020 case G4ViewParameters::hlhsr: << 221 case G4ViewParameters::hlhsr:
1021 break; << 222 break;
1022 case G4ViewParameters::cloud: <<
1023 break; <<
1024 } 223 }
1025 } 224 }
1026 else { 225 else {
1027 switch (existingStyle) { 226 switch (existingStyle) {
1028 case G4ViewParameters::wireframe: << 227 case G4ViewParameters::wireframe:
1029 break; << 228 break;
1030 case G4ViewParameters::hlr: << 229 case G4ViewParameters::hlr:
1031 vp.SetDrawingStyle(G4ViewParameters << 230 vp.SetDrawingStyle(G4ViewParameters::wireframe);
1032 break; << 231 break;
1033 case G4ViewParameters::hsr: << 232 case G4ViewParameters::hsr:
1034 break; << 233 break;
1035 case G4ViewParameters::hlhsr: << 234 case G4ViewParameters::hlhsr:
1036 vp.SetDrawingStyle(G4ViewParameters << 235 vp.SetDrawingStyle(G4ViewParameters::hsr);
1037 break; << 236 break;
1038 case G4ViewParameters::cloud: <<
1039 break; <<
1040 } 237 }
1041 } 238 }
1042 if (verbosity >= G4VisManager::confirmati << 239 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1043 G4cout << "Drawing style of viewer \"" << 240 << "\" set to " << vp.GetDrawingStyle()
1044 << "\" set to " << vp.GetDrawingStyle() << 241 << G4endl;
1045 << G4endl; <<
1046 } <<
1047 } <<
1048 <<
1049 else if (command == fpCommandHiddenMarker) <<
1050 G4bool hidden = G4UIcommand::ConvertToBoo <<
1051 if (hidden) vp.SetMarkerHidden(); <<
1052 else vp.SetMarkerNotHidden(); <<
1053 if (verbosity >= G4VisManager::confirmati <<
1054 G4cout << "Markers will "; <<
1055 if (vp.IsMarkerNotHidden()) G4cout << " <<
1056 G4cout << "be hidden under solid object <<
1057 } <<
1058 } <<
1059 <<
1060 else if (command == fpCommandLightsMove) { <<
1061 if (newValue.find("cam") != G4String::npo <<
1062 vp.SetLightsMoveWithCamera(true); <<
1063 else if(newValue.find("obj") != G4String: <<
1064 vp.SetLightsMoveWithCamera(false); <<
1065 else { <<
1066 if (verbosity >= G4VisManager::errors) <<
1067 G4warn << "ERROR: \"" << newValue << <<
1068 " Looking for \"cam\" or \"obj\" in <<
1069 } <<
1070 } <<
1071 if (verbosity >= G4VisManager::confirmati <<
1072 G4cout << "Lights move with "; <<
1073 if (vp.GetLightsMoveWithCamera()) <<
1074 G4cout << "camera (object appears to <<
1075 else G4cout << "object (the viewer appe <<
1076 G4cout << G4endl; <<
1077 } <<
1078 } 242 }
1079 243
1080 else if (command == fpCommandLightsThetaPhi << 244 else if (command == fpCommandCulling) {
1081 G4double theta, phi; << 245 G4String cullingOption, stringFlag, unit;
1082 if (ConvertToDoublePair(newValue, theta, << 246 G4double density;
1083 G4double x = std::sin (theta) * std::co << 247 G4bool boolFlag;
1084 G4double y = std::sin (theta) * std::si << 248 G4std::istrstream is ((char*)newValue.data());
1085 G4double z = std::cos (theta); << 249 is >> cullingOption >> stringFlag >> density >> unit;
1086 fLightsVector = G4ThreeVector (x, y, z) << 250 boolFlag = GetNewBoolValue(stringFlag);
1087 vp.SetLightpointDirection(fLightsVector << 251 if (cullingOption == "global") {
1088 if (verbosity >= G4VisManager::confirma << 252 vp.SetCulling(boolFlag);
1089 G4cout << "Lights direction set to " <<
1090 << vp.GetLightpointDirection() << G4e <<
1091 } <<
1092 } <<
1093 } <<
1094 <<
1095 else if (command == fpCommandLightsVector) <<
1096 fLightsVector = G4UIcommand::ConvertTo3Ve <<
1097 vp.SetLightpointDirection(fLightsVector); <<
1098 if (verbosity >= G4VisManager::confirmati <<
1099 G4cout << "Lights direction set to " <<
1100 << vp.GetLightpointDirection() << G4end <<
1101 } <<
1102 } <<
1103 <<
1104 else if (command == fpCommandLineWidth) { <<
1105 if (verbosity >= G4VisManager::errors) { <<
1106 // A do-nothing command <<
1107 G4warn << command->GetGuidanceLine(0) < <<
1108 } <<
1109 } <<
1110 <<
1111 else if (command == fpCommandLineSegments) <<
1112 G4int nSides = G4UIcommand::ConvertToInt( <<
1113 nSides = vp.SetNoOfSides(nSides); <<
1114 if (verbosity >= G4VisManager::confirmati <<
1115 G4cout << 253 G4cout <<
1116 "Number of line segments per circle in << 254 "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
1117 << nSides << G4endl; << 255 " set to " << ConvertToString(boolFlag) <<
>> 256 ".\n Does not change specific culling flags."
>> 257 << G4endl;
1118 } 258 }
1119 } << 259 else if (cullingOption == "coveredDaughters") {
1120 << 260 vp.SetCullingCovered(boolFlag);
1121 else if (command == fpCommandNumberOfCloudP <<
1122 G4int nPoints = G4UIcommand::ConvertToInt <<
1123 nPoints = vp.SetNumberOfCloudPoints(nPoin <<
1124 if (verbosity >= G4VisManager::confirmati <<
1125 G4cout << 261 G4cout <<
1126 "Number of points to be used in cloud r << 262 "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
1127 << nPoints << G4endl; << 263 "\n daughters flag set to " << ConvertToString(boolFlag) <<
1128 } << 264 ". Daughters covered by opaque mothers"
1129 } << 265 "\n will be culled, i.e., not drawn, if this flag is true."
1130 << 266 "\n Note: this is only effective in surface drawing style,"
1131 else if (command == fpCommandPicking) { << 267 "\n and then only if the volumes are visible and opaque, and then"
1132 vp.SetPicking(G4UIcommand::ConvertToBool( << 268 "\n only if no sections or cutways are in operation."
1133 if (verbosity >= G4VisManager::confirmati << 269 << G4endl;
1134 G4cout << "Picking "; <<
1135 if (vp.IsPicking()) G4cout << "requeste <<
1136 else G4cout << "inhibited."; <<
1137 G4cout << G4endl; <<
1138 } <<
1139 if (verbosity >= G4VisManager::warnings) <<
1140 G4warn << "You may need to issue \"/vis <<
1141 << G4endl; <<
1142 } 270 }
1143 } << 271 else if (cullingOption == "invisible") {
1144 << 272 vp.SetCullingInvisible(boolFlag);
1145 else if (command == fpCommandProjection) { << 273 G4cout <<
1146 G4double fieldHalfAngle; << 274 "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
1147 const size_t iPos0 = 0; << 275 "\n flag set to " << boolFlag << ConvertToString(boolFlag) <<
1148 if (newValue[iPos0] == 'o') { // "orthog << 276 ". Volumes marked invisible will be culled,"
1149 fieldHalfAngle = 0.; << 277 "\n i.e., not drawn, if this flag is true."
1150 } << 278 << G4endl;
1151 else if (newValue[iPos0] == 'p') { // "p <<
1152 G4String dummy; <<
1153 G4String unit; <<
1154 std::istringstream is (newValue); <<
1155 is >> dummy >> fieldHalfAngle >> unit; <<
1156 fieldHalfAngle *= G4UIcommand::ValueOf( <<
1157 if (fieldHalfAngle > 89.5 * deg || fiel <<
1158 if (verbosity >= G4VisManager::errors <<
1159 G4warn << <<
1160 "ERROR: Field half angle should be <<
1161 G4warn << G4endl; <<
1162 } <<
1163 return; <<
1164 } <<
1165 } <<
1166 else { <<
1167 if (verbosity >= G4VisManager::errors) <<
1168 G4warn << "ERROR: \"" << newValue << <<
1169 " Looking for 'o' or 'p' first chara <<
1170 } <<
1171 return; <<
1172 } 279 }
1173 vp.SetFieldHalfAngle(fieldHalfAngle); << 280 else if (cullingOption == "density") {
1174 if (verbosity >= G4VisManager::confirmati << 281 vp.SetDensityCulling(boolFlag);
1175 G4cout << "Projection style of viewer \ << 282 if (boolFlag) {
1176 << "\" set to "; << 283 density *= G4UnitDefinition::GetValueOf(unit);
1177 if (fieldHalfAngle == 0.) { << 284 vp.SetVisibleDensity(density);
1178 G4cout << "orthogonal."; <<
1179 } 285 }
1180 else { 286 else {
1181 G4cout << "perspective\n with half a << 287 density = vp.GetVisibleDensity();
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::constrainUpDi <<
1192 else if (newValue == "freeRotation") <<
1193 style = G4ViewParameters::freeRotation; <<
1194 else { <<
1195 if (verbosity >= G4VisManager::errors) <<
1196 G4warn << "ERROR: \"" << newValue << "\" no <<
1197 } <<
1198 return; <<
1199 } <<
1200 vp.SetRotationStyle(style); <<
1201 if (verbosity >= G4VisManager::confirmati <<
1202 G4cout << "Rotation style of viewer \"" <<
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 <<
1213 G4int iSelector = -1; <<
1214 if (G4StrUtil::icompare(choice, "off") == <<
1215 !G4UIcommand::ConvertToBool(choice)) <<
1216 if (G4StrUtil::icompare(choice, "on") == <<
1217 G4UIcommand::ConvertToBool(choice)) i <<
1218 if (iSelector < 0) { <<
1219 if (verbosity >= G4VisManager::errors) <<
1220 G4warn << "Choice not recognised (on/ <<
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::erro <<
1234 G4warn << "Null normal." << G4end <<
1235 } <<
1236 break;; <<
1237 } <<
1238 // Make sure normal is normalised <<
1239 const G4Normal3D& normal = G4Normal3D <<
1240 vp.SetSectionPlane(G4Plane3D(normal, <<
1241 vp.SetViewpointDirection(normal); <<
1242 break; <<
1243 } <<
1244 write_result: <<
1245 if (verbosity >= G4VisManager::confirmati <<
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 == fpCommandSpecialMeshRen <<
1256 vp.SetSpecialMeshRendering(G4UIcommand::C <<
1257 if (verbosity >= G4VisManager::confirmati <<
1258 G4cout << "Special mesh rendering"; <<
1259 if (vp.IsSpecialMeshRendering()) { <<
1260 G4cout << " requested. Current option <<
1261 << vp.GetSpecialMeshRenderingOption() <<
1262 if (vp.GetSpecialMeshVolumes().empty( <<
1263 G4cout << "any mesh."; <<
1264 } else{ <<
1265 G4cout << "selected volumes:"; <<
1266 for (const auto& pvNameCopyNo: vp.G <<
1267 G4cout << "\n " << pvNameCopyNo. <<
1268 if (pvNameCopyNo.GetCopyNo() >= 0 <<
1269 } <<
1270 } <<
1271 } <<
1272 else G4cout << ": off."; <<
1273 G4cout << G4endl; <<
1274 } <<
1275 } <<
1276 <<
1277 else if (command == fpCommandSpecialMeshRen <<
1278 G4ViewParameters::SMROption option = G4Vi <<
1279 if (newValue == "dots") { <<
1280 option = G4ViewParameters::meshAsDots; <<
1281 } <<
1282 else if(newValue == "surfaces") { <<
1283 option = G4ViewParameters::meshAsSurfac <<
1284 } <<
1285 vp.SetSpecialMeshRenderingOption(option); <<
1286 if (verbosity >= G4VisManager::confirmati <<
1287 G4cout << "Special mesh rendering optio <<
1288 << vp.GetSpecialMeshRenderingOption() < <<
1289 << G4endl; <<
1290 } <<
1291 } <<
1292 <<
1293 else if (command == fpCommandSpecialMeshVol <<
1294 std::vector<G4ModelingParameters::PVNameC <<
1295 if (newValue.empty()) { <<
1296 vp.SetSpecialMeshVolumes(requestedMeshe <<
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 <<
1307 iBegin = newValue.find_first_not_of(' ',iEn <<
1308 if (iBegin == G4String::npos) { <<
1309 if (verbosity >= G4VisManager::warnings) <<
1310 G4warn << <<
1311 "WARNING: G4VisCommandsViewerSet::SetNe <<
1312 "\n A pair not found. (There should b <<
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(iBeg <<
1324 if (!(iss >> copyNo)) { <<
1325 if (verbosity >= G4VisManager::warnings) <<
1326 G4warn << <<
1327 "WARNING: G4VisCommandsViewerSet::SetNe <<
1328 "\n Error reading copy number - it was <<
1329 "\n Command ignored." <<
1330 << G4endl; <<
1331 return; <<
1332 } <<
1333 } <<
1334 requestedMeshes.push_back(G4ModelingParamet <<
1335 iBegin = newValue.find_first_not_of(' ',iEn <<
1336 } <<
1337 vp.SetSpecialMeshVolumes(requestedMeshe <<
1338 } <<
1339 if (verbosity >= G4VisManager::confirmati <<
1340 if (vp.GetSpecialMeshVolumes().empty()) <<
1341 G4cout << <<
1342 "Special mesh list empty, which means \"all <<
1343 << G4endl; <<
1344 } else { <<
1345 G4cout << "Selected special mesh volumes ar <<
1346 for (const auto& pvNameCopyNo: vp.GetSpecia <<
1347 G4cout << "\n " << pvNameCopyNo.GetName( <<
1348 if (pvNameCopyNo.GetCopyNo() >= 0) G4cout <<
1349 } <<
1350 G4cout << G4endl; <<
1351 } <<
1352 } <<
1353 } <<
1354 <<
1355 else if (command == fpCommandStyle) { <<
1356 G4ViewParameters::DrawingStyle existingSt <<
1357 const size_t iPos0 = 0; <<
1358 if (newValue[iPos0] == 'w') { // "wirefr <<
1359 switch (existingStyle) { <<
1360 case G4ViewParameters::wireframe: <<
1361 break; <<
1362 case G4ViewParameters::hlr: <<
1363 break; <<
1364 case G4ViewParameters::hsr: <<
1365 vp.SetDrawingStyle(G4ViewParameters <<
1366 break; <<
1367 case G4ViewParameters::hlhsr: <<
1368 vp.SetDrawingStyle(G4ViewParameters <<
1369 break; <<
1370 case G4ViewParameters::cloud: <<
1371 vp.SetDrawingStyle(G4ViewParameters <<
1372 break; <<
1373 } <<
1374 } <<
1375 else if (newValue[iPos0] == 's') { // "s <<
1376 switch (existingStyle) { <<
1377 case G4ViewParameters::wireframe: <<
1378 vp.SetDrawingStyle(G4ViewParameters <<
1379 break; <<
1380 case G4ViewParameters::hlr: <<
1381 vp.SetDrawingStyle(G4ViewParameters <<
1382 break; <<
1383 case G4ViewParameters::hsr: <<
1384 break; <<
1385 case G4ViewParameters::hlhsr: <<
1386 break; <<
1387 case G4ViewParameters::cloud: <<
1388 vp.SetDrawingStyle(G4ViewParameters <<
1389 break; <<
1390 } <<
1391 } <<
1392 else if (newValue[iPos0] == 'c') { // "c <<
1393 switch (existingStyle) { <<
1394 case G4ViewParameters::wireframe: <<
1395 vp.SetDrawingStyle(G4ViewParameters <<
1396 break; <<
1397 case G4ViewParameters::hlr: <<
1398 vp.SetDrawingStyle(G4ViewParameters <<
1399 break; <<
1400 case G4ViewParameters::hsr: <<
1401 vp.SetDrawingStyle(G4ViewParameters <<
1402 break; <<
1403 case G4ViewParameters::hlhsr: <<
1404 vp.SetDrawingStyle(G4ViewParameters <<
1405 break; <<
1406 case G4ViewParameters::cloud: <<
1407 break; <<
1408 } 288 }
>> 289 G4cout <<
>> 290 "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
>> 291 "\n flag set to " << ConvertToString(boolFlag) <<
>> 292 ". Volumes with density less than " <<
>> 293 G4BestUnit(density,"Volumic Mass") <<
>> 294 "\n will be culled, i.e., not drawn, if this flag is true."
>> 295 << G4endl;
1409 } 296 }
1410 else { 297 else {
1411 if (verbosity >= G4VisManager::errors) << 298 G4cout <<
1412 G4warn << "ERROR: \"" << newValue << << 299 "G4VisCommandsViewerSet::SetNewValue: culling: option not recognised."
1413 " Looking for 'w' or 's' or 'c' firs << 300 << G4endl;
1414 } <<
1415 return; <<
1416 } <<
1417 if (verbosity >= G4VisManager::confirmati <<
1418 G4cout << "Drawing style of viewer \"" <<
1419 << "\" set to " << vp.GetDrawingStyle() <<
1420 << G4endl; <<
1421 } <<
1422 } <<
1423 <<
1424 else if (command == fpCommandTargetPoint) { <<
1425 G4ThreeVector targetPoint = <<
1426 fpCommandTargetPoint->GetNew3VectorValue( <<
1427 const G4Point3D& standardTargetPoint = <<
1428 currentViewer->GetSceneHandler()->GetScen <<
1429 vp.SetCurrentTargetPoint(targetPoint - st <<
1430 if (verbosity >= G4VisManager::confirmati <<
1431 G4cout << "Target point set to " <<
1432 << fpCommandTargetPoint->ConvertToStrin <<
1433 (targetPoint) <<
1434 << "\n\"Current Target Point\" set to <<
1435 << fpCommandTargetPoint->ConvertToStrin <<
1436 (vp.GetCurrentTargetPoint()) <<
1437 << "\n\"Standard Target Point\" is " <<
1438 << fpCommandTargetPoint->ConvertToStrin <<
1439 (standardTargetPoint) <<
1440 << G4endl; <<
1441 } <<
1442 } <<
1443 <<
1444 else if (command == fpCommandUpThetaPhi) { <<
1445 G4double theta, phi; <<
1446 if (ConvertToDoublePair(newValue, theta, <<
1447 G4double x = std::sin (theta) * std::co <<
1448 G4double y = std::sin (theta) * std::si <<
1449 G4double z = std::cos (theta); <<
1450 fUpVector = G4ThreeVector (x, y, z); <<
1451 vp.SetUpVector(fUpVector); <<
1452 if (verbosity >= G4VisManager::confirma <<
1453 G4cout << "Up direction set to " << v <<
1454 } <<
1455 } <<
1456 } <<
1457 <<
1458 else if (command == fpCommandUpVector) { <<
1459 fUpVector = G4UIcommand::ConvertTo3Vector <<
1460 vp.SetUpVector(fUpVector); <<
1461 if (verbosity >= G4VisManager::confirmati <<
1462 G4cout << "Up direction set to " << vp. <<
1463 } <<
1464 } <<
1465 <<
1466 else if (command == fpCommandViewpointTheta <<
1467 G4double theta, phi; <<
1468 if (ConvertToDoublePair(newValue, theta, <<
1469 G4double x = std::sin (theta) * std::co <<
1470 G4double y = std::sin (theta) * std::si <<
1471 G4double z = std::cos (theta); <<
1472 fViewpointVector = G4ThreeVector (x, y, <<
1473 vp.SetViewAndLights(fViewpointVector); <<
1474 if (verbosity >= G4VisManager::confirma <<
1475 G4cout << "Viewpoint direction set to <<
1476 << vp.GetViewpointDirection() << G4en <<
1477 if (vp.GetLightsMoveWithCamera ()) { <<
1478 G4cout << "Lightpoint direction set <<
1479 << vp.GetActualLightpointDirection <<
1480 } <<
1481 } <<
1482 } <<
1483 } <<
1484 <<
1485 else if (command == fpCommandViewpointVecto <<
1486 G4ThreeVector viewpointVector = G4UIcomma <<
1487 if (viewpointVector.mag2() <= 0.) { <<
1488 if (verbosity >= G4VisManager::errors) <<
1489 G4warn << "ERROR: Null viewpoint vect <<
1490 } <<
1491 } else { <<
1492 fViewpointVector = viewpointVector.unit <<
1493 vp.SetViewAndLights(fViewpointVector); <<
1494 if (verbosity >= G4VisManager::confirma <<
1495 G4cout << "Viewpoint direction set to <<
1496 << vp.GetViewpointDirection() << G4en <<
1497 if (vp.GetLightsMoveWithCamera ()) { <<
1498 G4cout << "Lightpoint direction set <<
1499 << vp.GetActualLightpointDirection <<
1500 } <<
1501 } <<
1502 } <<
1503 } <<
1504 <<
1505 else if (command == fpCommandTimeWindowDisp <<
1506 { <<
1507 G4String display; <<
1508 G4double screenX, screenY, screenSize, re <<
1509 std::istringstream iss(newValue); <<
1510 iss >> display >> screenX >> screenY <<
1511 >> screenSize >> red >> green >> blue; <<
1512 vp.SetDisplayHeadTime(command->ConvertToB <<
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::confirmati <<
1520 G4cout << "Display head time flag set: <<
1521 << vp <<
1522 << G4endl; <<
1523 } <<
1524 } <<
1525 <<
1526 else if (command == fpCommandTimeWindowDisp <<
1527 { <<
1528 G4String display, originX, originY, origi <<
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->ConvertT <<
1536 vp.SetDisplayLightFrontX <<
1537 (command->ConvertToDimensionedDouble(G4St <<
1538 vp.SetDisplayLightFrontY <<
1539 (command->ConvertToDimensionedDouble(G4St <<
1540 vp.SetDisplayLightFrontZ <<
1541 (command->ConvertToDimensionedDouble(G4St <<
1542 vp.SetDisplayLightFrontT <<
1543 (command->ConvertToDimensionedDouble(G4St <<
1544 vp.SetDisplayLightFrontRed(red); <<
1545 vp.SetDisplayLightFrontGreen(green); <<
1546 vp.SetDisplayLightFrontBlue(blue); <<
1547 if (verbosity >= G4VisManager::confirmati <<
1548 G4cout << "Display light front flag set <<
1549 << vp <<
1550 << G4endl; <<
1551 } <<
1552 } <<
1553 <<
1554 else if (command == fpCommandTimeWindowEndT <<
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_ti <<
1564 G4double timeRange = command->ConvertToDi <<
1565 (G4String(time_range_string + ' ' + time_ <<
1566 if (timeRange > 0.) { <<
1567 vp.SetStartTime <<
1568 (vp.GetEndTime() - timeRange); <<
1569 } <<
1570 if (verbosity >= G4VisManager::confirmati <<
1571 G4cout <<
1572 << "Time window start time: " << vp.Get <<
1573 << ", time window end time: " << vp.Get <<
1574 if (timeRange > 0.) { <<
1575 G4cout << "\n (time range: " << time <<
1576 } <<
1577 G4cout << G4endl; <<
1578 } <<
1579 } <<
1580 <<
1581 else if (command == fpCommandTimeWindowFade <<
1582 vp.SetFadeFactor(command->ConvertToDouble <<
1583 if (verbosity >= G4VisManager::confirmati <<
1584 G4cout << "Time window fade factor chan <<
1585 << G4endl; <<
1586 } <<
1587 } <<
1588 <<
1589 else if (command == fpCommandTimeWindowStar <<
1590 { <<
1591 G4String start_time_string, start_time_un <<
1592 time_range_string, time_range_unit; <<
1593 std::istringstream iss(newValue); <<
1594 iss >> start_time_string >> start_time_un <<
1595 >> time_range_string >> time_range_unit; <<
1596 vp.SetStartTime <<
1597 (command->ConvertToDimensionedDouble <<
1598 (G4String(start_time_string + ' ' + star <<
1599 G4double timeRange = command->ConvertToDi <<
1600 (G4String(time_range_string + ' ' + time_ <<
1601 if (timeRange > 0.) { <<
1602 vp.SetEndTime <<
1603 (vp.GetStartTime() + timeRange); <<
1604 } <<
1605 if (verbosity >= G4VisManager::confirmati <<
1606 G4cout <<
1607 << "Time window start time: " << vp.Get <<
1608 << ", time window end time: " << vp.Get <<
1609 if (timeRange > 0.) { <<
1610 G4cout << "\n (time range: " << time <<
1611 } <<
1612 G4cout << G4endl; <<
1613 } 301 }
1614 } 302 }
1615 303
1616 else { 304 else {
1617 if (verbosity >= G4VisManager::errors) { << 305 G4cout << "G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1618 G4warn << << 306 << G4endl;
1619 "ERROR: G4VisCommandsViewerSet::SetNewV <<
1620 << G4endl; <<
1621 } <<
1622 return; 307 return;
1623 } 308 }
1624 309
1625 SetViewParameters(currentViewer,vp); << 310 currentViewer->SetViewParameters(vp);
>> 311 G4cout << "Issue /vis/viewer/refresh to see effect." << G4endl;
>> 312 // For now...
>> 313 fpVisManager->SetCurrentViewParameters() = vp;
1626 } 314 }
1627 315