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