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