source: trunk/source/visualization/management/src/G4VisCommandsViewerSet.cc@ 1354

Last change on this file since 1354 was 1346, checked in by garnier, 15 years ago

before tag
  • Property svn:mime-type set to text/cpp
File size: 42.1 KB
Line 
1//
2// ********************************************************************
3// * License and Disclaimer *
4// * *
5// * The Geant4 software is copyright of the Copyright Holders of *
6// * the Geant4 Collaboration. It is provided under the terms and *
7// * conditions of the Geant4 Software License, included in the file *
8// * LICENSE and available at http://cern.ch/geant4/license . These *
9// * include a list of copyright holders. *
10// * *
11// * Neither the authors of this software system, nor their employing *
12// * institutes,nor the agencies providing financial support for this *
13// * work make any representation or warranty, express or implied, *
14// * regarding this software system or assume any liability for its *
15// * use. Please see the license in the file LICENSE and URL above *
16// * for the full disclaimer and the limitation of liability. *
17// * *
18// * This code implementation is the result of the scientific and *
19// * technical work of the GEANT4 collaboration. *
20// * By using, copying, modifying or distributing the software (or *
21// * any work based on the software) you agree to acknowledge its *
22// * use in resulting scientific publications, and indicate your *
23// * acceptance of all terms of the Geant4 Software license. *
24// ********************************************************************
25//
26//
27// $Id: G4VisCommandsViewerSet.cc,v 1.53 2010/11/05 15:57:20 allison Exp $
28// GEANT4 tag $Name: $
29
30// /vis/viewer/set commands - John Allison 16th May 2000
31
32#include "G4VisCommandsViewerSet.hh"
33
34#include "G4UIcommand.hh"
35#include "G4UIcmdWithAString.hh"
36#include "G4UIcmdWithABool.hh"
37#include "G4UIcmdWithAnInteger.hh"
38#include "G4UIcmdWithADouble.hh"
39#include "G4UIcmdWith3VectorAndUnit.hh"
40#include "G4UnitsTable.hh"
41#include "G4VisManager.hh"
42#include "G4Polyhedron.hh"
43
44#include <sstream>
45#include <cctype>
46
47G4VisCommandsViewerSet::G4VisCommandsViewerSet ():
48 fLightsVector (G4ThreeVector(1.,1.,1.)),
49 fUpVector (G4ThreeVector(0.,1.,0.)),
50 fViewpointVector (G4ThreeVector(0.,0.,1.))
51{
52 G4bool omitable;
53 G4UIparameter* parameter;
54
55 fpCommandAll = new G4UIcmdWithAString ("/vis/viewer/set/all",this);
56 fpCommandAll->SetGuidance
57 ("Copies view parameters.");
58 fpCommandAll->SetGuidance
59 ("Copies view parameters (except the autoRefresh status) from"
60 "\nfrom-viewer to current viewer.");
61 fpCommandAll->SetParameterName ("from-viewer-name",omitable = false);
62
63 fpCommandAutoRefresh = new G4UIcmdWithABool
64 ("/vis/viewer/set/autoRefresh",this);
65 fpCommandAutoRefresh->SetGuidance("Sets auto-refresh.");
66 fpCommandAutoRefresh->SetGuidance
67 ("If true, view is automatically refreshed after a change of"
68 "\nview parameters.");
69 fpCommandAutoRefresh->SetParameterName("auto-refresh",omitable = true);
70 fpCommandAutoRefresh->SetDefaultValue(true);
71
72 fpCommandAuxEdge = new G4UIcmdWithABool
73 ("/vis/viewer/set/auxiliaryEdge",this);
74 fpCommandAuxEdge->SetGuidance("Sets visibility of auxiliary edges");
75 fpCommandAuxEdge->SetGuidance
76 ("Auxiliary edges, i.e., those that are part of a curved surface,"
77 "\nsometimes called soft edges, become visible/invisible.");
78 fpCommandAuxEdge->SetParameterName("edge",omitable = true);
79 fpCommandAuxEdge->SetDefaultValue(true);
80
81 fpCommandBackground = new G4UIcommand
82 ("/vis/viewer/set/background",this);
83 fpCommandBackground->SetGuidance
84 ("Set background colour and transparency (default black and opaque).");
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.");
91 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
92 parameter -> SetDefaultValue ("0.");
93 fpCommandBackground -> SetParameter (parameter);
94 parameter = new G4UIparameter("green", 'd', omitable = true);
95 parameter -> SetDefaultValue (0.);
96 fpCommandBackground -> SetParameter (parameter);
97 parameter = new G4UIparameter ("blue", 'd', omitable = true);
98 parameter -> SetDefaultValue (0.);
99 fpCommandBackground -> SetParameter (parameter);
100 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
101 parameter -> SetDefaultValue (1.);
102 fpCommandBackground -> SetParameter (parameter);
103
104 fpCommandCulling = new G4UIcommand("/vis/viewer/set/culling",this);
105 fpCommandCulling->SetGuidance ("Set culling options.");
106 fpCommandCulling->SetGuidance
107 ("\"global\": enables/disables all other culling options.");
108 fpCommandCulling->SetGuidance
109 ("\"coveredDaughters\": culls, i.e., eliminates, volumes that would not"
110 "\nbe seen because covered by ancester volumes in surface drawing mode,"
111 "\nand then only if the ancesters are visible and opaque, and then only"
112 "\nif no sections or cutaways are in operation. Intended solely to"
113 "\nimprove the speed of rendering visible volumes.");
114 fpCommandCulling->SetGuidance
115 ("\"invisible\": culls objects with the invisible attribute set.");
116 fpCommandCulling->SetGuidance
117 ("\"density\": culls volumes with density lower than threshold. Useful"
118 "\nfor eliminating \"container volumes\" with no physical correspondence,"
119 "\nwhose material is usually air. If this is selected, provide threshold"
120 "\ndensity and unit (g/cm3 mg/cm3 or kg/m3)."
121 );
122 parameter = new G4UIparameter("culling-option",'s',omitable = false);
123 parameter->SetParameterCandidates
124 ("global coveredDaughters invisible density");
125 fpCommandCulling->SetParameter(parameter);
126 parameter = new G4UIparameter("action",'b',omitable = true);
127 parameter->SetDefaultValue(1);
128 fpCommandCulling->SetParameter(parameter);
129 parameter = new G4UIparameter("density-threshold",'d',omitable = true);
130 parameter->SetDefaultValue("0.01");
131 fpCommandCulling->SetParameter(parameter);
132 parameter = new G4UIparameter("unit",'s',omitable = true);
133 parameter->SetParameterCandidates ("g/cm3, mg/cm3 kg/m3");
134 parameter->SetDefaultValue("g/cm3");
135 fpCommandCulling->SetParameter(parameter);
136
137 fpCommandCutawayMode =
138 new G4UIcmdWithAString ("/vis/viewer/set/cutawayMode", this);
139 fpCommandCutawayMode->SetGuidance
140 ("Sets cutaway mode - add (union) or multiply (intersection).");
141 fpCommandCutawayMode->SetParameterName ("cutaway-mode",omitable = false);
142 fpCommandCutawayMode->SetCandidates ("add union multiply intersection");
143 fpCommandCutawayMode->SetDefaultValue("union");
144
145 fpCommandDefaultColour = new G4UIcommand
146 ("/vis/viewer/set/defaultColour",this);
147 fpCommandDefaultColour->SetGuidance
148 ("Set defaultColour colour and transparency (default white and opaque).");
149 fpCommandDefaultColour->SetGuidance
150 ("Accepts (a) RGB triplet. e.g., \".3 .4 .5\", or"
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.");
155 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
156 parameter -> SetDefaultValue ("1.");
157 fpCommandDefaultColour -> SetParameter (parameter);
158 parameter = new G4UIparameter("green", 'd', omitable = true);
159 parameter -> SetDefaultValue (1.);
160 fpCommandDefaultColour -> SetParameter (parameter);
161 parameter = new G4UIparameter ("blue", 'd', omitable = true);
162 parameter -> SetDefaultValue (1.);
163 fpCommandDefaultColour -> SetParameter (parameter);
164 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
165 parameter -> SetDefaultValue (1.);
166 fpCommandDefaultColour -> SetParameter (parameter);
167
168 fpCommandDefaultTextColour = new G4UIcommand
169 ("/vis/viewer/set/defaultTextColour",this);
170 fpCommandDefaultTextColour->SetGuidance
171 ("Set defaultTextColour colour and transparency (default white and opaque).");
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.");
178 parameter = new G4UIparameter("red_or_string", 's', omitable = true);
179 parameter -> SetDefaultValue ("1.");
180 fpCommandDefaultTextColour -> SetParameter (parameter);
181 parameter = new G4UIparameter("green", 'd', omitable = true);
182 parameter -> SetDefaultValue (1.);
183 fpCommandDefaultTextColour -> SetParameter (parameter);
184 parameter = new G4UIparameter ("blue", 'd', omitable = true);
185 parameter -> SetDefaultValue (1.);
186 fpCommandDefaultTextColour -> SetParameter (parameter);
187 parameter = new G4UIparameter ("opacity", 'd', omitable = true);
188 parameter -> SetDefaultValue (1.);
189 fpCommandDefaultTextColour -> SetParameter (parameter);
190
191 fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
192 fpCommandEdge->SetGuidance
193 ("Edges become visible/invisible in surface mode.");
194 fpCommandEdge->SetParameterName("edge",omitable = true);
195 fpCommandEdge->SetDefaultValue(true);
196
197 fpCommandExplodeFactor = new G4UIcommand
198 ("/vis/viewer/set/explodeFactor", this);
199 fpCommandExplodeFactor->SetGuidance
200 ("Moves top-level drawn volumes by this factor from this centre.");
201 parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
202 parameter->SetParameterRange("explodeFactor>=1.");
203 parameter->SetDefaultValue(1.);
204 fpCommandExplodeFactor->SetParameter(parameter);
205 parameter = new G4UIparameter("x",'d',omitable = true);
206 parameter->SetDefaultValue (0);
207 parameter->SetGuidance ("Coordinate of explode centre.");
208 fpCommandExplodeFactor->SetParameter(parameter);
209 parameter = new G4UIparameter("y",'d',omitable = true);
210 parameter->SetDefaultValue (0);
211 parameter->SetGuidance ("Coordinate of explode centre.");
212 fpCommandExplodeFactor->SetParameter(parameter);
213 parameter = new G4UIparameter("z",'d',omitable = true);
214 parameter->SetDefaultValue (0);
215 parameter->SetGuidance ("Coordinate of explode centre.");
216 fpCommandExplodeFactor->SetParameter(parameter);
217 parameter = new G4UIparameter("unit",'s',omitable = true);
218 parameter->SetDefaultValue ("m");
219 parameter->SetGuidance ("Unit of explode centre.");
220 fpCommandExplodeFactor->SetParameter(parameter);
221
222 fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
223 ("/vis/viewer/set/globalLineWidthScale", this);
224 fpCommandGlobalLineWidthScale->SetGuidance
225 ("Multiplies line widths by this factor.");
226 fpCommandGlobalLineWidthScale->
227 SetParameterName("scale-factor", omitable=true);
228 fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
229
230 fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
231 ("/vis/viewer/set/globalMarkerScale", this);
232 fpCommandGlobalMarkerScale->SetGuidance
233 ("Multiplies marker sizes by this factor.");
234 fpCommandGlobalMarkerScale->
235 SetParameterName("scale-factor", omitable=true);
236 fpCommandGlobalMarkerScale->SetDefaultValue(1.);
237
238 fpCommandHiddenEdge =
239 new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
240 fpCommandHiddenEdge->SetGuidance
241 ("Edges become hidden/seen in wireframe or surface mode.");
242 fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
243 fpCommandHiddenEdge->SetDefaultValue(true);
244
245 fpCommandHiddenMarker =
246 new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
247 fpCommandHiddenMarker->SetGuidance
248 ("If true, closer objects hide markers. Otherwise, markers always show.");
249 fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
250 fpCommandHiddenMarker->SetDefaultValue(true);
251
252 fpCommandLightsMove = new G4UIcmdWithAString
253 ("/vis/viewer/set/lightsMove",this);
254 fpCommandLightsMove->SetGuidance
255 ("Lights move with camera or with object");
256 fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
257 fpCommandLightsMove->SetCandidates
258 ("cam camera with-camera obj object with-object");
259
260 fpCommandLightsThetaPhi = new G4UIcommand
261 ("/vis/viewer/set/lightsThetaPhi", this);
262 fpCommandLightsThetaPhi->SetGuidance
263 ("Set direction from target to lights.");
264 parameter = new G4UIparameter("theta", 'd', omitable = true);
265 parameter -> SetDefaultValue(60.);
266 fpCommandLightsThetaPhi -> SetParameter (parameter);
267 parameter = new G4UIparameter("phi", 'd', omitable = true);
268 parameter -> SetDefaultValue(45.);
269 fpCommandLightsThetaPhi -> SetParameter (parameter);
270 parameter = new G4UIparameter ("unit", 's', omitable = true);
271 parameter -> SetDefaultValue ("deg");
272 fpCommandLightsThetaPhi -> SetParameter (parameter);
273
274 fpCommandLightsVector = new G4UIcommand
275 ("/vis/viewer/set/lightsVector", this);
276 fpCommandLightsVector->SetGuidance
277 ("Set direction from target to lights.");
278 parameter = new G4UIparameter("x", 'd', omitable = true);
279 parameter -> SetDefaultValue (1);
280 fpCommandLightsVector -> SetParameter (parameter);
281 parameter = new G4UIparameter("y", 'd', omitable = true);
282 parameter -> SetDefaultValue (1);
283 fpCommandLightsVector -> SetParameter (parameter);
284 parameter = new G4UIparameter ("z", 'd', omitable = true);
285 parameter -> SetDefaultValue (1);
286 fpCommandLightsVector -> SetParameter (parameter);
287
288 fpCommandLineSegments = new G4UIcmdWithAnInteger
289 ("/vis/viewer/set/lineSegmentsPerCircle",this);
290 fpCommandLineSegments->SetGuidance
291 ("Set number of sides per circle for polygon/polyhedron drawing.");
292 fpCommandLineSegments->SetGuidance
293 ("Refers to graphical representation of objects with curved lines/surfaces.");
294 fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
295 fpCommandLineSegments->SetDefaultValue(24);
296
297 fpCommandPicking = new G4UIcmdWithABool
298 ("/vis/viewer/set/picking",this);
299 fpCommandPicking->SetGuidance("Sets picking, if available.");
300 fpCommandPicking->SetGuidance
301 ("If true, view is set up for picking, if available."
302 "\nFor required actions, watch for instructions for viewer.");
303 fpCommandPicking->SetParameterName("picking",omitable = true);
304 fpCommandPicking->SetDefaultValue(true);
305
306 fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
307 fpCommandProjection->SetGuidance
308 ("Orthogonal or perspective projection.");
309 parameter = new G4UIparameter("projection",'s',omitable = true);
310 parameter->SetParameterCandidates("o orthogonal p perspective");
311 parameter->SetDefaultValue("orthogonal");
312 fpCommandProjection->SetParameter(parameter);
313 parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
314 parameter->SetDefaultValue(30.);
315 //parameter->SetCurrentAsDefault(true);
316 fpCommandProjection->SetParameter(parameter);
317 parameter = new G4UIparameter("unit",'s',omitable = true);
318 parameter->SetDefaultValue("deg");
319 //parameter->SetCurrentAsDefault(true);
320 fpCommandProjection->SetParameter(parameter);
321
322 fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
323 fpCommandSectionPlane -> SetGuidance
324 ("Set plane for drawing section (DCUT).");
325 fpCommandSectionPlane -> SetGuidance
326 ("E.g., for a y-z plane at x = 1 cm:"
327 "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
328 "\nTo turn off: /vis/viewer/set/sectionPlane off");
329 parameter = new G4UIparameter("Selector",'c',true);
330 parameter -> SetDefaultValue ("on");
331 fpCommandSectionPlane->SetParameter(parameter);
332 parameter = new G4UIparameter("x",'d',omitable = true);
333 parameter -> SetDefaultValue (0);
334 parameter -> SetGuidance ("Coordinate of point on the plane.");
335 fpCommandSectionPlane->SetParameter(parameter);
336 parameter = new G4UIparameter("y",'d',omitable = true);
337 parameter -> SetDefaultValue (0);
338 parameter -> SetGuidance ("Coordinate of point on the plane.");
339 fpCommandSectionPlane->SetParameter(parameter);
340 parameter = new G4UIparameter("z",'d',omitable = true);
341 parameter -> SetDefaultValue (0);
342 parameter -> SetGuidance ("Coordinate of point on the plane.");
343 fpCommandSectionPlane->SetParameter(parameter);
344 parameter = new G4UIparameter("unit",'s',omitable = true);
345 parameter -> SetDefaultValue ("m");
346 parameter -> SetGuidance ("Unit of point on the plane.");
347 fpCommandSectionPlane->SetParameter(parameter);
348 parameter = new G4UIparameter("nx",'d',omitable = true);
349 parameter -> SetDefaultValue (1);
350 parameter -> SetGuidance ("Component of plane normal.");
351 fpCommandSectionPlane->SetParameter(parameter);
352 parameter = new G4UIparameter("ny",'d',omitable = true);
353 parameter -> SetDefaultValue (0);
354 parameter -> SetGuidance ("Component of plane normal.");
355 fpCommandSectionPlane->SetParameter(parameter);
356 parameter = new G4UIparameter("nz",'d',omitable = true);
357 parameter -> SetDefaultValue (0);
358 parameter -> SetGuidance ("Component of plane normal.");
359 fpCommandSectionPlane->SetParameter(parameter);
360
361 fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
362 fpCommandStyle->SetGuidance
363 ("Set style of drawing - w[ireframe] or s[urface].");
364 fpCommandStyle->SetGuidance
365 ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
366 fpCommandStyle->SetParameterName ("style",omitable = false);
367
368 fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
369 ("/vis/viewer/set/targetPoint", this);
370 fpCommandTargetPoint->SetGuidance
371 ("Set target point.");
372 fpCommandTargetPoint->SetGuidance
373 ("This sets the \"Current Target Point\" relative to the \"Standard");
374 fpCommandTargetPoint->SetGuidance
375 ("Target Point\" so that the actual target point is as requested.");
376 fpCommandTargetPoint->SetGuidance
377 ("(See G4ViewParameters.hh for an explanation of target points.)");
378 fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
379 fpCommandTargetPoint->SetUnitCategory("Length");
380
381 fpCommandUpThetaPhi = new G4UIcommand
382 ("/vis/viewer/set/upThetaPhi", this);
383 fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
384 fpCommandUpThetaPhi -> SetGuidance
385 ("Viewer will attempt always to show this direction upwards.");
386 parameter = new G4UIparameter("theta", 'd', omitable = true);
387 parameter -> SetDefaultValue (90.);
388 fpCommandUpThetaPhi -> SetParameter (parameter);
389 parameter = new G4UIparameter("phi", 'd', omitable = true);
390 parameter -> SetDefaultValue (90.);
391 fpCommandUpThetaPhi -> SetParameter (parameter);
392 parameter = new G4UIparameter ("unit", 's', omitable = true);
393 parameter -> SetDefaultValue ("deg");
394 fpCommandUpThetaPhi -> SetParameter (parameter);
395
396 fpCommandUpVector = new G4UIcommand
397 ("/vis/viewer/set/upVector", this);
398 fpCommandUpVector -> SetGuidance ("Set up vector.");
399 fpCommandUpVector -> SetGuidance
400 ("Viewer will attempt always to show this direction upwards.");
401 parameter = new G4UIparameter("x", 'd', omitable = true);
402 parameter -> SetDefaultValue (0.);
403 fpCommandUpVector -> SetParameter (parameter);
404 parameter = new G4UIparameter("y", 'd', omitable = true);
405 parameter -> SetDefaultValue (1.);
406 fpCommandUpVector -> SetParameter (parameter);
407 parameter = new G4UIparameter ("z", 'd', omitable = true);
408 parameter -> SetDefaultValue (0.);
409 fpCommandUpVector -> SetParameter (parameter);
410
411 fpCommandViewpointThetaPhi = new G4UIcommand
412 ("/vis/viewer/set/viewpointThetaPhi", this);
413 fpCommandViewpointThetaPhi -> SetGuidance
414 ("Set direction from target to camera.");
415 fpCommandViewpointThetaPhi -> SetGuidance
416 ("Also changes lightpoint direction if lights are set to move with camera.");
417 parameter = new G4UIparameter("theta", 'd', omitable = true);
418 parameter -> SetDefaultValue (60.);
419 fpCommandViewpointThetaPhi -> SetParameter (parameter);
420 parameter = new G4UIparameter("phi", 'd', omitable = true);
421 parameter -> SetDefaultValue (45.);
422 fpCommandViewpointThetaPhi -> SetParameter (parameter);
423 parameter = new G4UIparameter ("unit", 's', omitable = true);
424 parameter -> SetDefaultValue ("deg");
425 fpCommandViewpointThetaPhi -> SetParameter (parameter);
426
427 fpCommandViewpointVector = new G4UIcommand
428 ("/vis/viewer/set/viewpointVector", this);
429 fpCommandViewpointVector -> SetGuidance
430 ("Set direction from target to camera.");
431 fpCommandViewpointVector -> SetGuidance
432 ("Also changes lightpoint direction if lights are set to move with camera.");
433 parameter = new G4UIparameter("x", 'd', omitable = true);
434 parameter -> SetDefaultValue (1.);
435 fpCommandViewpointVector -> SetParameter (parameter);
436 parameter = new G4UIparameter("y", 'd', omitable = true);
437 parameter -> SetDefaultValue (1.);
438 fpCommandViewpointVector -> SetParameter (parameter);
439 parameter = new G4UIparameter ("z", 'd', omitable = true);
440 parameter -> SetDefaultValue (1.);
441 fpCommandViewpointVector -> SetParameter (parameter);
442}
443
444G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
445 delete fpCommandAll;
446 delete fpCommandAuxEdge;
447 delete fpCommandAutoRefresh;
448 delete fpCommandBackground;
449 delete fpCommandCulling;
450 delete fpCommandCutawayMode;
451 delete fpCommandDefaultColour;
452 delete fpCommandDefaultTextColour;
453 delete fpCommandEdge;
454 delete fpCommandExplodeFactor;
455 delete fpCommandGlobalLineWidthScale;
456 delete fpCommandGlobalMarkerScale;
457 delete fpCommandHiddenEdge;
458 delete fpCommandHiddenMarker;
459 delete fpCommandLineSegments;
460 delete fpCommandLightsMove;
461 delete fpCommandLightsThetaPhi;
462 delete fpCommandLightsVector;
463 delete fpCommandPicking;
464 delete fpCommandProjection;
465 delete fpCommandSectionPlane;
466 delete fpCommandStyle;
467 delete fpCommandTargetPoint;
468 delete fpCommandUpThetaPhi;
469 delete fpCommandUpVector;
470 delete fpCommandViewpointThetaPhi;
471 delete fpCommandViewpointVector;
472}
473
474G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
475 return "";
476}
477
478void G4VisCommandsViewerSet::SetNewValue
479(G4UIcommand* command,G4String newValue) {
480
481 G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
482
483 G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
484 if (!currentViewer) {
485 if (verbosity >= G4VisManager::errors) {
486 G4cout <<
487 "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
488 << G4endl;
489 }
490 return;
491 }
492
493 G4ViewParameters vp = currentViewer->GetViewParameters();
494
495 if (command == fpCommandAll) {
496 G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
497 if (!fromViewer) {
498 if (verbosity >= G4VisManager::errors) {
499 G4cout <<
500 "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
501 "\n unrecognised from-viewer."
502 << G4endl;
503 }
504 return;
505 }
506 if (fromViewer == currentViewer) {
507 if (verbosity >= G4VisManager::warnings) {
508 G4cout <<
509 "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
510 "\n from-viewer and current viewer are identical."
511 << G4endl;
512 }
513 return;
514 }
515 // Copy view parameters except for autoRefresh...
516 G4bool currentAutoRefresh =
517 currentViewer->GetViewParameters().IsAutoRefresh();
518 vp = fromViewer->GetViewParameters();
519 vp.SetAutoRefresh(currentAutoRefresh);
520 if (verbosity >= G4VisManager::confirmations) {
521 G4cout << "View parameters of viewer \"" << currentViewer->GetName()
522 << "\"\n set to those of viewer \"" << fromViewer->GetName()
523 << "\"."
524 << G4endl;
525 }
526 }
527
528 else if (command == fpCommandAutoRefresh) {
529 G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
530 vp.SetAutoRefresh(autoRefresh);
531 if (verbosity >= G4VisManager::confirmations) {
532 G4cout << "Views will ";
533 if (!vp.IsAutoRefresh()) G4cout << "not ";
534 G4cout << "be automatically refreshed after a change of view parameters."
535 << G4endl;
536 }
537 if (!vp.IsAutoRefresh()) {
538 currentViewer->SetViewParameters(vp);
539 return; // Avoid a refresh id auto-refresh has been set to off...
540 } // ...otherwise take normal action.
541 }
542
543 else if (command == fpCommandAuxEdge) {
544 vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
545 if (verbosity >= G4VisManager::confirmations) {
546 G4cout << "Auxiliary edges will ";
547 if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
548 G4cout << "be visible." << G4endl;
549 }
550 }
551
552 else if (command == fpCommandBackground) {
553 G4String redOrString;
554 G4double green, blue, opacity;
555 std::istringstream iss(newValue);
556 iss >> redOrString >> green >> blue >> opacity;
557 G4Colour colour(0.,0.,0.); // Default black and opaque.
558 const size_t iPos0 = 0;
559 if (std::isalpha(redOrString[iPos0])) {
560 G4Colour::GetColour(redOrString, colour); // Remains default (black) if
561 // not found.
562 } else {
563 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
564 }
565 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
566 vp.SetBackgroundColour(colour);
567 if (verbosity >= G4VisManager::confirmations) {
568 G4cout << "Background colour "
569 << vp.GetBackgroundColour()
570 << " requested."
571 << G4endl;
572 }
573 }
574
575 else if (command == fpCommandCulling) {
576 G4String cullingOption, stringFlag, unit;
577 G4double density;
578 std::istringstream is (newValue);
579 is >> cullingOption >> stringFlag >> density >> unit;
580 G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
581 if (cullingOption == "global") {
582 vp.SetCulling(boolFlag);
583 if (verbosity >= G4VisManager::confirmations) {
584 G4cout <<
585 "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
586 " set to " << G4UIcommand::ConvertToString(boolFlag) <<
587 ".\n Does not change specific culling flags."
588 << G4endl;
589 }
590 }
591 else if (cullingOption == "coveredDaughters") {
592 vp.SetCullingCovered(boolFlag);
593 if (verbosity >= G4VisManager::confirmations) {
594 G4cout <<
595 "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
596 "\n daughters flag set to "
597 << G4UIcommand::ConvertToString(boolFlag) <<
598 ". Daughters covered by opaque mothers"
599 "\n will be culled, i.e., not drawn, if this flag is true."
600 "\n Note: this is only effective in surface drawing style,"
601 "\n and then only if the volumes are visible and opaque, and then"
602 "\n only if no sections or cutaways are in operation."
603 << G4endl;
604 }
605 }
606 else if (cullingOption == "invisible") {
607 vp.SetCullingInvisible(boolFlag);
608 if (verbosity >= G4VisManager::confirmations) {
609 G4cout <<
610 "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
611 "\n flag set to "
612 << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
613 ". Volumes marked invisible will be culled,"
614 "\n i.e., not drawn, if this flag is true."
615 << G4endl;
616 }
617 }
618 else if (cullingOption == "density") {
619 vp.SetDensityCulling(boolFlag);
620 if (boolFlag) {
621 density *= G4UnitDefinition::GetValueOf(unit);
622 vp.SetVisibleDensity(density);
623 }
624 else {
625 density = vp.GetVisibleDensity();
626 }
627 if (verbosity >= G4VisManager::confirmations) {
628 G4cout <<
629 "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
630 "\n flag set to " << G4UIcommand::ConvertToString(boolFlag) <<
631 ". Volumes with density less than " <<
632 G4BestUnit(density,"Volumic Mass") <<
633 "\n will be culled, i.e., not drawn, if this flag is true."
634 << G4endl;
635 }
636 }
637 else {
638 if (verbosity >= G4VisManager::errors) {
639 G4cout <<
640 "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
641 "\n option not recognised."
642 << G4endl;
643 }
644 }
645 }
646
647 else if (command == fpCommandCutawayMode) {
648 if (newValue == "add" || newValue == "union")
649 vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
650 if (newValue == "multiply" || newValue == "intersection")
651 vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
652
653 if (verbosity >= G4VisManager::confirmations) {
654 G4cout << "Cutaway mode set to ";
655 if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
656 G4cout << "cutawayUnion";
657 if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
658 G4cout << "cutawayIntersection";
659 G4cout << G4endl;
660 }
661 }
662
663 else if (command == fpCommandDefaultColour) {
664 G4String redOrString;
665 G4double green, blue, opacity;
666 std::istringstream iss(newValue);
667 iss >> redOrString >> green >> blue >> opacity;
668 G4Colour colour(1.,1.,1.); // Default white and opaque.
669 const size_t iPos0 = 0;
670 if (std::isalpha(redOrString[iPos0])) {
671 G4Colour::GetColour(redOrString, colour); // Remains default (white) if
672 // not found.
673 } else {
674 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
675 }
676 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
677 G4VisAttributes va = vp.GetDefaultVisAttributes();
678 va.SetColour(colour);
679 vp.SetDefaultVisAttributes(va);
680 if (verbosity >= G4VisManager::confirmations) {
681 G4cout << "Default colour "
682 << vp.GetDefaultVisAttributes()->GetColour()
683 << " requested."
684 << G4endl;
685 }
686 }
687
688 else if (command == fpCommandDefaultTextColour) {
689 G4String redOrString;
690 G4double green, blue, opacity;
691 std::istringstream iss(newValue);
692 iss >> redOrString >> green >> blue >> opacity;
693 G4Colour colour(1.,1.,1.); // Default white and opaque.
694 const size_t iPos0 = 0;
695 if (std::isalpha(redOrString[iPos0])) {
696 G4Colour::GetColour(redOrString, colour); // Remains default (white) if
697 // not found.
698 } else {
699 colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
700 }
701 colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
702 G4VisAttributes va = vp.GetDefaultTextVisAttributes();
703 va.SetColour(colour);
704 vp.SetDefaultTextVisAttributes(va);
705 if (verbosity >= G4VisManager::confirmations) {
706 G4cout << "Default colour "
707 << vp.GetDefaultTextVisAttributes()->GetColour()
708 << " requested."
709 << G4endl;
710 }
711 }
712
713 else if (command == fpCommandEdge) {
714 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
715 if (G4UIcommand::ConvertToBool(newValue)) {
716 switch (existingStyle) {
717 case G4ViewParameters::wireframe:
718 break;
719 case G4ViewParameters::hlr:
720 break;
721 case G4ViewParameters::hsr:
722 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
723 break;
724 case G4ViewParameters::hlhsr:
725 break;
726 }
727 }
728 else {
729 switch (existingStyle) {
730 case G4ViewParameters::wireframe:
731 break;
732 case G4ViewParameters::hlr:
733 break;
734 case G4ViewParameters::hsr:
735 break;
736 case G4ViewParameters::hlhsr:
737 vp.SetDrawingStyle(G4ViewParameters::hsr);
738 break;
739 }
740 }
741 if (verbosity >= G4VisManager::confirmations) {
742 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
743 << "\" set to " << vp.GetDrawingStyle()
744 << G4endl;
745 }
746 }
747
748 else if (command == fpCommandExplodeFactor) {
749 G4double explodeFactor, x, y, z;
750 G4String unitString;
751 std::istringstream is (newValue);
752 is >> explodeFactor >> x >> y >> z >> unitString;
753 G4double unit = G4UIcommand::ValueOf(unitString);
754 vp.SetExplodeFactor(explodeFactor);
755 vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
756 if (verbosity >= G4VisManager::confirmations) {
757 G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
758 << " from centre " << vp.GetExplodeCentre()
759 << G4endl;
760 }
761 }
762
763 else if (command == fpCommandGlobalLineWidthScale) {
764 G4double globalLineWidthScale
765 = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
766 vp.SetGlobalLineWidthScale(globalLineWidthScale);
767 if (verbosity >= G4VisManager::confirmations) {
768 G4cout << "Global Line Width Scale changed to "
769 << vp.GetGlobalLineWidthScale() << G4endl;
770 }
771 }
772
773 else if (command == fpCommandGlobalMarkerScale) {
774 G4double globalMarkerScale
775 = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
776 vp.SetGlobalMarkerScale(globalMarkerScale);
777 if (verbosity >= G4VisManager::confirmations) {
778 G4cout << "Global Marker Scale changed to "
779 << vp.GetGlobalMarkerScale() << G4endl;
780 }
781 }
782
783 else if (command == fpCommandHiddenEdge) {
784 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
785 if (G4UIcommand::ConvertToBool(newValue)) {
786 switch (existingStyle) {
787 case G4ViewParameters::wireframe:
788 vp.SetDrawingStyle(G4ViewParameters::hlr);
789 break;
790 case G4ViewParameters::hlr:
791 break;
792 case G4ViewParameters::hsr:
793 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
794 break;
795 case G4ViewParameters::hlhsr:
796 break;
797 }
798 }
799 else {
800 switch (existingStyle) {
801 case G4ViewParameters::wireframe:
802 break;
803 case G4ViewParameters::hlr:
804 vp.SetDrawingStyle(G4ViewParameters::wireframe);
805 break;
806 case G4ViewParameters::hsr:
807 break;
808 case G4ViewParameters::hlhsr:
809 vp.SetDrawingStyle(G4ViewParameters::hsr);
810 break;
811 }
812 }
813 if (verbosity >= G4VisManager::confirmations) {
814 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
815 << "\" set to " << vp.GetDrawingStyle()
816 << G4endl;
817 }
818 }
819
820 else if (command == fpCommandHiddenMarker) {
821 G4bool hidden = G4UIcommand::ConvertToBool(newValue);
822 if (hidden) vp.SetMarkerHidden();
823 else vp.SetMarkerNotHidden();
824 if (verbosity >= G4VisManager::confirmations) {
825 G4cout << "Markers will ";
826 if (vp.IsMarkerNotHidden()) G4cout << "not ";
827 G4cout << "be hidden under solid objects." << G4endl;
828 }
829 }
830
831 else if (command == fpCommandLightsMove) {
832 G4String s (newValue);
833 if (s.find("cam") != G4String::npos) vp.SetLightsMoveWithCamera(true);
834 else if(s.find("obj") != G4String::npos) vp.SetLightsMoveWithCamera(false);
835 else {
836 if (verbosity >= G4VisManager::errors) {
837 G4cout << "ERROR: \"" << newValue << "\" not recognised."
838 " Looking for \"cam\" or \"obj\" in string." << G4endl;
839 }
840 }
841 if (verbosity >= G4VisManager::confirmations) {
842 G4cout << "Lights move with ";
843 if (vp.GetLightsMoveWithCamera())
844 G4cout << "camera (object appears to rotate).";
845 else G4cout << "object (the viewer appears to be moving).";
846 G4cout << G4endl;
847 }
848 }
849
850 else if (command == fpCommandLightsThetaPhi) {
851 G4double theta, phi;
852 ConvertToDoublePair(newValue, theta, phi);
853 G4double x = std::sin (theta) * std::cos (phi);
854 G4double y = std::sin (theta) * std::sin (phi);
855 G4double z = std::cos (theta);
856 fLightsVector = G4ThreeVector (x, y, z);
857 vp.SetLightpointDirection(fLightsVector);
858 if (verbosity >= G4VisManager::confirmations) {
859 G4cout << "Lights direction set to "
860 << vp.GetLightpointDirection() << G4endl;
861 }
862 }
863
864 else if (command == fpCommandLightsVector) {
865 fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
866 vp.SetLightpointDirection(fLightsVector);
867 if (verbosity >= G4VisManager::confirmations) {
868 G4cout << "Lights direction set to "
869 << vp.GetLightpointDirection() << G4endl;
870 }
871 }
872
873 else if (command == fpCommandLineSegments) {
874 G4int nSides = G4UIcommand::ConvertToInt(newValue);
875 nSides = vp.SetNoOfSides(nSides);
876 if (verbosity >= G4VisManager::confirmations) {
877 G4cout <<
878 "Number of line segements per circle in polygon approximation is "
879 << nSides << G4endl;
880 }
881 }
882
883 else if (command == fpCommandPicking) {
884 vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
885 if (verbosity >= G4VisManager::confirmations) {
886 G4cout << "Picking ";
887 if (vp.IsPicking()) G4cout << "requested.";
888 else G4cout << "inhibited.";
889 G4cout << G4endl;
890 }
891 }
892
893 else if (command == fpCommandProjection) {
894 G4double fieldHalfAngle;
895 const size_t iPos0 = 0;
896 if (newValue[iPos0] == 'o') { // "orthogonal"
897 fieldHalfAngle = 0.;
898 }
899 else if (newValue[iPos0] == 'p') { // "perspective"
900 G4String dummy;
901 G4String unit;
902 std::istringstream is (newValue);
903 is >> dummy >> fieldHalfAngle >> unit;
904 fieldHalfAngle *= G4UIcommand::ValueOf(unit);
905 if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
906 if (verbosity >= G4VisManager::errors) {
907 G4cout <<
908 "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
909 G4cout << G4endl;
910 }
911 return;
912 }
913 }
914 else {
915 if (verbosity >= G4VisManager::errors) {
916 G4cout << "ERROR: \"" << newValue << "\" not recognised."
917 " Looking for 'o' or 'p' first character." << G4endl;
918 }
919 return;
920 }
921 vp.SetFieldHalfAngle(fieldHalfAngle);
922 if (verbosity >= G4VisManager::confirmations) {
923 G4cout << "Projection style of viewer \"" << currentViewer->GetName()
924 << "\" set to ";
925 if (fieldHalfAngle == 0.) {
926 G4cout << "orthogonal.";
927 }
928 else {
929 G4cout << "perspective\n with half angle " << fieldHalfAngle / deg
930 << " degrees.";
931 }
932 G4cout << G4endl;
933 }
934 }
935
936 else if (command == fpCommandSectionPlane) {
937 G4String choice, unit;
938 G4double x, y, z, nx, ny, nz;
939 std::istringstream is (newValue);
940 is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
941
942 G4int iSelector = -1;
943 if (choice.compareTo("off",G4String::ignoreCase) == 0 ||
944 !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
945 if (choice.compareTo("on",G4String::ignoreCase) == 0 ||
946 G4UIcommand::ConvertToBool(choice)) iSelector = 1;
947 if (iSelector < 0) {
948 if (verbosity >= G4VisManager::errors) {
949 G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
950 G4cout << "Section drawing is currently: ";
951 if (vp.IsSection ()) G4cout << "on";
952 else G4cout << "off";
953 G4cout << ".\nSection plane is currently: "
954 << vp.GetSectionPlane ();
955 G4cout << G4endl;
956 }
957 return;
958 }
959
960 G4double F = 1.;
961 switch (iSelector) {
962 default:
963 case 0:
964 vp.UnsetSectionPlane();
965 break;
966 case 1:
967 F = G4UIcommand::ValueOf(unit);
968 x *= F; y *= F; z *= F;
969 vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
970 vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
971 break;
972 }
973
974 if (verbosity >= G4VisManager::confirmations) {
975 G4cout << "Section drawing is now: ";
976 if (vp.IsSection ()) G4cout << "on";
977 else G4cout << "off";
978 G4cout << ".\nSection plane is now: "
979 << vp.GetSectionPlane ();
980 G4cout << G4endl;
981 }
982 }
983
984 else if (command == fpCommandStyle) {
985 G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
986 const size_t iPos0 = 0;
987 if (newValue[iPos0] == 'w') { // "wireframe"
988 switch (existingStyle) {
989 case G4ViewParameters::wireframe:
990 break;
991 case G4ViewParameters::hlr:
992 break;
993 case G4ViewParameters::hsr:
994 vp.SetDrawingStyle(G4ViewParameters::wireframe);
995 break;
996 case G4ViewParameters::hlhsr:
997 vp.SetDrawingStyle(G4ViewParameters::hlr);
998 break;
999 }
1000 }
1001 else if (newValue[iPos0] == 's') { // "surface"
1002 switch (existingStyle) {
1003 case G4ViewParameters::wireframe:
1004 vp.SetDrawingStyle(G4ViewParameters::hsr);
1005 break;
1006 case G4ViewParameters::hlr:
1007 vp.SetDrawingStyle(G4ViewParameters::hlhsr);
1008 break;
1009 case G4ViewParameters::hsr:
1010 break;
1011 case G4ViewParameters::hlhsr:
1012 break;
1013 }
1014 }
1015 else {
1016 if (verbosity >= G4VisManager::errors) {
1017 G4cout << "ERROR: \"" << newValue << "\" not recognised."
1018 " Looking for 'w' or 's' first character." << G4endl;
1019 }
1020 return;
1021 }
1022 if (verbosity >= G4VisManager::confirmations) {
1023 G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
1024 << "\" set to " << vp.GetDrawingStyle()
1025 << G4endl;
1026 }
1027 }
1028
1029 else if (command == fpCommandTargetPoint) {
1030 G4ThreeVector targetPoint =
1031 fpCommandTargetPoint->GetNew3VectorValue(newValue);
1032 const G4Point3D& standardTargetPoint =
1033 currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
1034 vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
1035 if (verbosity >= G4VisManager::confirmations) {
1036 G4cout << "Target point set to "
1037 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1038 (targetPoint)
1039 << "\n\"Current Target Point\" set to "
1040 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1041 (vp.GetCurrentTargetPoint())
1042 << "\n\"Standard Target Point\" is "
1043 << fpCommandTargetPoint->ConvertToStringWithBestUnit
1044 (standardTargetPoint)
1045 << G4endl;
1046 }
1047 }
1048
1049 else if (command == fpCommandUpThetaPhi) {
1050 G4double theta, phi;
1051 ConvertToDoublePair(newValue, theta, phi);
1052 G4double x = std::sin (theta) * std::cos (phi);
1053 G4double y = std::sin (theta) * std::sin (phi);
1054 G4double z = std::cos (theta);
1055 fUpVector = G4ThreeVector (x, y, z);
1056 vp.SetUpVector(fUpVector);
1057 if (verbosity >= G4VisManager::confirmations) {
1058 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1059 }
1060 }
1061
1062 else if (command == fpCommandUpVector) {
1063 fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1064 vp.SetUpVector(fUpVector);
1065 if (verbosity >= G4VisManager::confirmations) {
1066 G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
1067 }
1068 }
1069
1070 else if (command == fpCommandViewpointThetaPhi) {
1071 G4double theta, phi;
1072 ConvertToDoublePair(newValue, theta, phi);
1073 G4double x = std::sin (theta) * std::cos (phi);
1074 G4double y = std::sin (theta) * std::sin (phi);
1075 G4double z = std::cos (theta);
1076 fViewpointVector = G4ThreeVector (x, y, z);
1077 vp.SetViewAndLights(fViewpointVector);
1078 if (verbosity >= G4VisManager::confirmations) {
1079 G4cout << "Viewpoint direction set to "
1080 << vp.GetViewpointDirection() << G4endl;
1081 if (vp.GetLightsMoveWithCamera ()) {
1082 G4cout << "Lightpoint direction set to "
1083 << vp.GetActualLightpointDirection () << G4endl;
1084 }
1085 }
1086 }
1087
1088 else if (command == fpCommandViewpointVector) {
1089 fViewpointVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
1090 vp.SetViewAndLights(fViewpointVector);
1091 if (verbosity >= G4VisManager::confirmations) {
1092 G4cout << "Viewpoint direction set to "
1093 << vp.GetViewpointDirection() << G4endl;
1094 if (vp.GetLightsMoveWithCamera ()) {
1095 G4cout << "Lightpoint direction set to "
1096 << vp.GetActualLightpointDirection () << G4endl;
1097 }
1098 }
1099 }
1100
1101 else {
1102 if (verbosity >= G4VisManager::errors) {
1103 G4cout <<
1104 "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1105 << G4endl;
1106 }
1107 return;
1108 }
1109
1110 SetViewParameters(currentViewer,vp);
1111}
Note: See TracBrowser for help on using the repository browser.