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

Last change on this file since 1337 was 1337, checked in by garnier, 14 years ago

tag geant4.9.4 beta 1 + modifs locales
  • Property svn:mime-type set to text/cpp
File size: 37.8 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.50 2009/05/13 18:17:25 allison Exp $
28// GEANT4 tag $Name: geant4-09-04-beta-01 $
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  fpCommandEdge = new G4UIcmdWithABool("/vis/viewer/set/edge",this);
146  fpCommandEdge->SetGuidance
147    ("Edges become visible/invisible in surface mode.");
148  fpCommandEdge->SetParameterName("edge",omitable = true);
149  fpCommandEdge->SetDefaultValue(true);
150
151  fpCommandExplodeFactor = new G4UIcommand
152    ("/vis/viewer/set/explodeFactor", this);
153  fpCommandExplodeFactor->SetGuidance
154    ("Moves top-level drawn volumes by this factor from this centre.");
155  parameter = new G4UIparameter("explodeFactor", 'd', omitable=true);
156  parameter->SetParameterRange("explodeFactor>=1.");
157  parameter->SetDefaultValue(1.);
158  fpCommandExplodeFactor->SetParameter(parameter);
159  parameter = new G4UIparameter("x",'d',omitable = true);
160  parameter->SetDefaultValue  (0);
161  parameter->SetGuidance      ("Coordinate of explode centre.");
162  fpCommandExplodeFactor->SetParameter(parameter);
163  parameter = new G4UIparameter("y",'d',omitable = true);
164  parameter->SetDefaultValue  (0);
165  parameter->SetGuidance      ("Coordinate of explode centre.");
166  fpCommandExplodeFactor->SetParameter(parameter);
167  parameter = new G4UIparameter("z",'d',omitable = true);
168  parameter->SetDefaultValue  (0);
169  parameter->SetGuidance      ("Coordinate of explode centre.");
170  fpCommandExplodeFactor->SetParameter(parameter);
171  parameter = new G4UIparameter("unit",'s',omitable = true);
172  parameter->SetDefaultValue  ("m");
173  parameter->SetGuidance      ("Unit of explode centre.");
174  fpCommandExplodeFactor->SetParameter(parameter);
175
176  fpCommandGlobalLineWidthScale = new G4UIcmdWithADouble
177    ("/vis/viewer/set/globalLineWidthScale", this);
178  fpCommandGlobalLineWidthScale->SetGuidance
179    ("Multiplies line widths by this factor.");
180  fpCommandGlobalLineWidthScale->
181    SetParameterName("scale-factor", omitable=true);
182  fpCommandGlobalLineWidthScale->SetDefaultValue(1.);
183
184  fpCommandGlobalMarkerScale = new G4UIcmdWithADouble
185    ("/vis/viewer/set/globalMarkerScale", this);
186  fpCommandGlobalMarkerScale->SetGuidance
187    ("Multiplies marker sizes by this factor.");
188  fpCommandGlobalMarkerScale->
189    SetParameterName("scale-factor", omitable=true);
190  fpCommandGlobalMarkerScale->SetDefaultValue(1.);
191
192  fpCommandHiddenEdge =
193    new G4UIcmdWithABool("/vis/viewer/set/hiddenEdge",this);
194  fpCommandHiddenEdge->SetGuidance
195    ("Edges become hidden/seen in wireframe or surface mode.");
196  fpCommandHiddenEdge->SetParameterName("hidden-edge",omitable = true);
197  fpCommandHiddenEdge->SetDefaultValue(true);
198
199  fpCommandHiddenMarker =
200    new G4UIcmdWithABool("/vis/viewer/set/hiddenMarker",this);
201  fpCommandHiddenMarker->SetGuidance
202    ("If true, closer objects hide markers. Otherwise, markers always show.");
203  fpCommandHiddenMarker->SetParameterName("hidden-marker",omitable = true);
204  fpCommandHiddenMarker->SetDefaultValue(true);
205
206  fpCommandLightsMove = new G4UIcmdWithAString
207    ("/vis/viewer/set/lightsMove",this);
208  fpCommandLightsMove->SetGuidance
209    ("Lights move with camera or with object");
210  fpCommandLightsMove->SetParameterName("lightsMove",omitable = false);
211  fpCommandLightsMove->SetCandidates
212    ("cam camera with-camera obj object with-object");
213
214  fpCommandLightsThetaPhi = new G4UIcommand
215    ("/vis/viewer/set/lightsThetaPhi", this);
216  fpCommandLightsThetaPhi->SetGuidance
217    ("Set direction from target to lights.");
218  parameter = new G4UIparameter("theta", 'd', omitable = true);
219  parameter -> SetDefaultValue(60.);
220  fpCommandLightsThetaPhi -> SetParameter (parameter);
221  parameter = new G4UIparameter("phi", 'd', omitable = true);
222  parameter -> SetDefaultValue(45.);
223  fpCommandLightsThetaPhi -> SetParameter (parameter);
224  parameter = new G4UIparameter ("unit", 's', omitable = true);
225  parameter -> SetDefaultValue ("deg");
226  fpCommandLightsThetaPhi -> SetParameter (parameter);
227
228  fpCommandLightsVector = new G4UIcommand
229    ("/vis/viewer/set/lightsVector", this);
230  fpCommandLightsVector->SetGuidance
231    ("Set direction from target to lights.");
232  parameter = new G4UIparameter("x", 'd', omitable = true);
233  parameter -> SetDefaultValue (1);
234  fpCommandLightsVector -> SetParameter (parameter);
235  parameter = new G4UIparameter("y", 'd', omitable = true);
236  parameter -> SetDefaultValue (1);
237  fpCommandLightsVector -> SetParameter (parameter);
238  parameter = new G4UIparameter ("z", 'd', omitable = true);
239  parameter -> SetDefaultValue (1);
240  fpCommandLightsVector -> SetParameter (parameter);
241
242  fpCommandLineSegments = new G4UIcmdWithAnInteger
243    ("/vis/viewer/set/lineSegmentsPerCircle",this);
244  fpCommandLineSegments->SetGuidance
245    ("Set number of sides per circle for polygon/polyhedron drawing.");
246  fpCommandLineSegments->SetGuidance
247 ("Refers to graphical representation of objects with curved lines/surfaces.");
248  fpCommandLineSegments->SetParameterName("line-segments",omitable = true);
249  fpCommandLineSegments->SetDefaultValue(24);
250
251  fpCommandPicking = new G4UIcmdWithABool
252    ("/vis/viewer/set/picking",this);
253  fpCommandPicking->SetGuidance("Sets picking, if available.");
254  fpCommandPicking->SetGuidance
255    ("If true, view is set up for picking, if available."
256     "\nFor required actions, watch for instructions for viewer.");
257  fpCommandPicking->SetParameterName("picking",omitable = true);
258  fpCommandPicking->SetDefaultValue(true);
259
260  fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
261  fpCommandProjection->SetGuidance
262    ("Orthogonal or perspective projection.");
263  parameter = new G4UIparameter("projection",'s',omitable = true);
264  parameter->SetParameterCandidates("o orthogonal p perspective");
265  parameter->SetDefaultValue("orthogonal");
266  fpCommandProjection->SetParameter(parameter);
267  parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
268  parameter->SetDefaultValue(30.);
269  fpCommandProjection->SetParameter(parameter);
270  parameter = new G4UIparameter("unit",'s',omitable = true);
271  parameter->SetDefaultValue("deg");
272  fpCommandProjection->SetParameter(parameter);
273
274  fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
275  fpCommandSectionPlane -> SetGuidance
276    ("Set plane for drawing section (DCUT).");
277  fpCommandSectionPlane -> SetGuidance
278    ("E.g., for a y-z plane at x = 1 cm:"
279     "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
280     "\nTo turn off: /vis/viewer/set/sectionPlane off");
281  parameter  =  new G4UIparameter("Selector",'c',true);
282  parameter  -> SetDefaultValue  ("on");
283  fpCommandSectionPlane->SetParameter(parameter);
284  parameter  =  new G4UIparameter("x",'d',omitable = true);
285  parameter  -> SetDefaultValue  (0);
286  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
287  fpCommandSectionPlane->SetParameter(parameter);
288  parameter  =  new G4UIparameter("y",'d',omitable = true);
289  parameter  -> SetDefaultValue  (0);
290  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
291  fpCommandSectionPlane->SetParameter(parameter);
292  parameter  =  new G4UIparameter("z",'d',omitable = true);
293  parameter  -> SetDefaultValue  (0);
294  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
295  fpCommandSectionPlane->SetParameter(parameter);
296  parameter  =  new G4UIparameter("unit",'s',omitable = true);
297  parameter  -> SetDefaultValue  ("m");
298  parameter  -> SetGuidance      ("Unit of point on the plane.");
299  fpCommandSectionPlane->SetParameter(parameter);
300  parameter  =  new G4UIparameter("nx",'d',omitable = true);
301  parameter  -> SetDefaultValue  (1);
302  parameter  -> SetGuidance      ("Component of plane normal.");
303  fpCommandSectionPlane->SetParameter(parameter);
304  parameter  =  new G4UIparameter("ny",'d',omitable = true);
305  parameter  -> SetDefaultValue  (0);
306  parameter  -> SetGuidance      ("Component of plane normal.");
307  fpCommandSectionPlane->SetParameter(parameter);
308  parameter  =  new G4UIparameter("nz",'d',omitable = true);
309  parameter  -> SetDefaultValue  (0);
310  parameter  -> SetGuidance      ("Component of plane normal.");
311  fpCommandSectionPlane->SetParameter(parameter);
312
313  fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
314  fpCommandStyle->SetGuidance
315    ("Set style of drawing - w[ireframe] or s[urface].");
316  fpCommandStyle->SetGuidance
317    ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
318  fpCommandStyle->SetParameterName ("style",omitable = false);
319
320  fpCommandTargetPoint = new G4UIcmdWith3VectorAndUnit
321    ("/vis/viewer/set/targetPoint", this);
322  fpCommandTargetPoint->SetGuidance
323    ("Set target point.");
324  fpCommandTargetPoint->SetGuidance
325    ("This sets the \"Current Target Point\" relative to the \"Standard");
326  fpCommandTargetPoint->SetGuidance
327    ("Target Point\" so that the actual target point is as requested.");
328  fpCommandTargetPoint->SetGuidance
329    ("(See G4ViewParameters.hh for an explanation of target points.)");
330  fpCommandTargetPoint->SetParameterName("x", "y", "z", omitable = false);
331  fpCommandTargetPoint->SetUnitCategory("Length");
332
333  fpCommandUpThetaPhi = new G4UIcommand
334    ("/vis/viewer/set/upThetaPhi", this);
335  fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
336  fpCommandUpThetaPhi -> SetGuidance
337    ("Viewer will attempt always to show this direction upwards.");
338  parameter = new G4UIparameter("theta", 'd', omitable = true);
339  parameter -> SetDefaultValue (90.);
340  fpCommandUpThetaPhi -> SetParameter (parameter);
341  parameter = new G4UIparameter("phi", 'd', omitable = true);
342  parameter -> SetDefaultValue (90.);
343  fpCommandUpThetaPhi -> SetParameter (parameter);
344  parameter = new G4UIparameter ("unit", 's', omitable = true);
345  parameter -> SetDefaultValue ("deg");
346  fpCommandUpThetaPhi -> SetParameter (parameter);
347
348  fpCommandUpVector = new G4UIcommand
349    ("/vis/viewer/set/upVector", this);
350  fpCommandUpVector -> SetGuidance ("Set up vector.");
351  fpCommandUpVector -> SetGuidance
352    ("Viewer will attempt always to show this direction upwards.");
353  parameter = new G4UIparameter("x", 'd', omitable = true);
354  parameter -> SetDefaultValue (0.);
355  fpCommandUpVector -> SetParameter (parameter);
356  parameter = new G4UIparameter("y", 'd', omitable = true);
357  parameter -> SetDefaultValue (1.);
358  fpCommandUpVector -> SetParameter (parameter);
359  parameter = new G4UIparameter ("z", 'd', omitable = true);
360  parameter -> SetDefaultValue (0.);
361  fpCommandUpVector -> SetParameter (parameter);
362
363  fpCommandViewpointThetaPhi = new G4UIcommand
364    ("/vis/viewer/set/viewpointThetaPhi", this);
365  fpCommandViewpointThetaPhi -> SetGuidance
366    ("Set direction from target to camera.");
367  fpCommandViewpointThetaPhi -> SetGuidance
368  ("Also changes lightpoint direction if lights are set to move with camera.");
369  parameter = new G4UIparameter("theta", 'd', omitable = true);
370  parameter -> SetDefaultValue (60.);
371  fpCommandViewpointThetaPhi -> SetParameter (parameter);
372  parameter = new G4UIparameter("phi", 'd', omitable = true);
373  parameter -> SetDefaultValue (45.);
374  fpCommandViewpointThetaPhi -> SetParameter (parameter);
375  parameter = new G4UIparameter ("unit", 's', omitable = true);
376  parameter -> SetDefaultValue ("deg");
377  fpCommandViewpointThetaPhi -> SetParameter (parameter);
378
379  fpCommandViewpointVector = new G4UIcommand
380    ("/vis/viewer/set/viewpointVector", this);
381  fpCommandViewpointVector -> SetGuidance
382    ("Set direction from target to camera.");
383  fpCommandViewpointVector -> SetGuidance
384  ("Also changes lightpoint direction if lights are set to move with camera.");
385  parameter = new G4UIparameter("x", 'd', omitable = true);
386  parameter -> SetDefaultValue (1.);
387  fpCommandViewpointVector -> SetParameter (parameter);
388  parameter = new G4UIparameter("y", 'd', omitable = true);
389  parameter -> SetDefaultValue (1.);
390  fpCommandViewpointVector -> SetParameter (parameter);
391  parameter = new G4UIparameter ("z", 'd', omitable = true);
392  parameter -> SetDefaultValue (1.);
393  fpCommandViewpointVector -> SetParameter (parameter);
394}
395
396G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
397  delete fpCommandAll;
398  delete fpCommandAuxEdge;
399  delete fpCommandAutoRefresh;
400  delete fpCommandBackground;
401  delete fpCommandCulling;
402  delete fpCommandCutawayMode;
403  delete fpCommandEdge;
404  delete fpCommandExplodeFactor;
405  delete fpCommandGlobalLineWidthScale;
406  delete fpCommandGlobalMarkerScale;
407  delete fpCommandHiddenEdge;
408  delete fpCommandHiddenMarker;
409  delete fpCommandLineSegments;
410  delete fpCommandLightsMove;
411  delete fpCommandLightsThetaPhi;
412  delete fpCommandLightsVector;
413  delete fpCommandPicking;
414  delete fpCommandProjection;
415  delete fpCommandSectionPlane;
416  delete fpCommandStyle;
417  delete fpCommandTargetPoint;
418  delete fpCommandUpThetaPhi;
419  delete fpCommandUpVector;
420  delete fpCommandViewpointThetaPhi;
421  delete fpCommandViewpointVector;
422}
423
424G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
425  return "";
426}
427
428void G4VisCommandsViewerSet::SetNewValue
429(G4UIcommand* command,G4String newValue) {
430
431  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
432
433  G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
434  if (!currentViewer) {
435    if (verbosity >= G4VisManager::errors) {
436      G4cout <<
437        "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
438             << G4endl;
439    }
440    return;
441  }
442
443  G4ViewParameters vp = currentViewer->GetViewParameters();
444
445  if (command == fpCommandAll) {
446    G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
447    if (!fromViewer) {
448      if (verbosity >= G4VisManager::errors) {
449        G4cout <<
450          "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
451          "\n  unrecognised from-viewer."
452               << G4endl;
453      }
454      return;
455    }
456    if (fromViewer == currentViewer) {
457      if (verbosity >= G4VisManager::warnings) {
458      G4cout <<
459        "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
460        "\n  from-viewer and current viewer are identical."
461             << G4endl;
462      }
463      return;
464    }
465    // Copy view parameters except for autoRefresh...
466    G4bool currentAutoRefresh =
467      currentViewer->GetViewParameters().IsAutoRefresh();
468    vp = fromViewer->GetViewParameters();
469    vp.SetAutoRefresh(currentAutoRefresh);
470    if (verbosity >= G4VisManager::confirmations) {
471      G4cout << "View parameters of viewer \"" << currentViewer->GetName()
472             << "\"\n  set to those of viewer \"" << fromViewer->GetName()
473             << "\"."
474             << G4endl;
475    }
476  }
477
478  else if (command == fpCommandAutoRefresh) {
479    G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
480    vp.SetAutoRefresh(autoRefresh);
481    if (verbosity >= G4VisManager::confirmations) {
482      G4cout << "Views will ";
483      if (!vp.IsAutoRefresh()) G4cout << "not ";
484      G4cout << "be automatically refreshed after a change of view parameters."
485             << G4endl;
486    }
487    if (!vp.IsAutoRefresh()) {
488      currentViewer->SetViewParameters(vp);
489      return;  // Avoid a refresh id auto-refresh has been set to off...
490    }  // ...otherwise take normal action.
491  }
492
493  else if (command == fpCommandAuxEdge) {
494    vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
495    if (verbosity >= G4VisManager::confirmations) {
496      G4cout << "Auxiliary edges will ";
497      if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
498      G4cout << "be visible." << G4endl;
499    }
500  }
501
502  else if (command == fpCommandBackground) {
503    G4String redOrString;
504    G4double green, blue, opacity;
505    std::istringstream iss(newValue);
506    iss >> redOrString >> green >> blue >> opacity;
507    G4Colour colour(0.,0.,0.);  // Default black and opaque.
508    const size_t iPos0 = 0;
509    if (std::isalpha(redOrString[iPos0])) {
510      G4Colour::GetColour(redOrString, colour); // Remains default (black) if
511                                                // not found.
512    } else {
513      colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
514    }
515    colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
516    vp.SetBackgroundColour(colour);
517    if (verbosity >= G4VisManager::confirmations) {
518      G4cout << "Background colour "
519             << vp.GetBackgroundColour()
520             << " requested."
521             << G4endl;
522    }
523  }
524
525  else if (command == fpCommandCulling) {
526    G4String cullingOption, stringFlag, unit;
527    G4double density;
528    std::istringstream is (newValue);
529    is >> cullingOption >> stringFlag >> density >> unit;
530    G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
531    if (cullingOption == "global") {
532      vp.SetCulling(boolFlag);
533      if (verbosity >= G4VisManager::confirmations) {
534        G4cout <<
535          "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
536          " set to " << G4UIcommand::ConvertToString(boolFlag) <<
537          ".\n  Does not change specific culling flags."
538               << G4endl;
539      }
540    }
541    else if (cullingOption == "coveredDaughters") {
542      vp.SetCullingCovered(boolFlag);
543      if (verbosity >= G4VisManager::confirmations) {
544        G4cout <<
545          "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
546          "\n  daughters flag set to "
547               << G4UIcommand::ConvertToString(boolFlag) <<
548          ".  Daughters covered by opaque mothers"
549          "\n  will be culled, i.e., not drawn, if this flag is true."
550          "\n  Note: this is only effective in surface drawing style,"
551          "\n  and then only if the volumes are visible and opaque, and then"
552          "\n  only if no sections or cutaways are in operation."
553               << G4endl;
554      }
555    }
556    else if (cullingOption == "invisible") {
557      vp.SetCullingInvisible(boolFlag);
558      if (verbosity >= G4VisManager::confirmations) {
559        G4cout <<
560          "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
561          "\n  flag set to "
562               << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
563          ".  Volumes marked invisible will be culled,"
564          "\n  i.e., not drawn, if this flag is true."
565               << G4endl;
566      }
567    }
568    else if (cullingOption == "density") {
569      vp.SetDensityCulling(boolFlag);
570      if (boolFlag) {
571        density *= G4UnitDefinition::GetValueOf(unit);
572        vp.SetVisibleDensity(density);
573      }
574      else {
575        density = vp.GetVisibleDensity();
576      }
577      if (verbosity >= G4VisManager::confirmations) {
578        G4cout <<
579          "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
580          "\n  flag set to " << G4UIcommand::ConvertToString(boolFlag) <<
581          ".  Volumes with density less than " <<
582          G4BestUnit(density,"Volumic Mass") <<
583          "\n  will be culled, i.e., not drawn, if this flag is true."
584               << G4endl;
585      }
586    }
587    else {
588      if (verbosity >= G4VisManager::errors) {
589        G4cout <<
590          "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
591          "\n  option not recognised."
592               << G4endl;
593      }
594    }
595  }
596
597  else if (command == fpCommandCutawayMode) {
598    if (newValue == "add" || newValue == "union")
599      vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
600    if (newValue == "multiply" || newValue == "intersection")
601      vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
602 
603    if (verbosity >= G4VisManager::confirmations) {
604      G4cout << "Cutaway mode set to ";
605      if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
606        G4cout << "cutawayUnion";
607      if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
608        G4cout << "cutawayIntersection";
609      G4cout << G4endl;
610    }
611  }
612
613  else if (command == fpCommandEdge) {
614    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
615    if (G4UIcommand::ConvertToBool(newValue)) {
616      switch (existingStyle) {
617      case G4ViewParameters::wireframe:
618        break;
619      case G4ViewParameters::hlr:
620        break;
621      case G4ViewParameters::hsr:
622        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
623        break;
624      case G4ViewParameters::hlhsr:
625        break;
626      }
627    }
628    else {
629      switch (existingStyle) {
630      case G4ViewParameters::wireframe:
631        break;
632      case G4ViewParameters::hlr:
633        break;
634      case G4ViewParameters::hsr:
635        break;
636      case G4ViewParameters::hlhsr:
637        vp.SetDrawingStyle(G4ViewParameters::hsr);
638        break;
639      }
640    }
641    if (verbosity >= G4VisManager::confirmations) {
642      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
643             << "\" set to " << vp.GetDrawingStyle()
644             << G4endl;
645    }
646  }
647
648  else if (command == fpCommandExplodeFactor) {
649    G4double explodeFactor, x, y, z;
650    G4String unitString;
651    std::istringstream is (newValue);
652    is >> explodeFactor >> x >> y >> z >> unitString;
653    G4double unit = G4UIcommand::ValueOf(unitString);
654    vp.SetExplodeFactor(explodeFactor);
655    vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
656    if (verbosity >= G4VisManager::confirmations) {
657      G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
658             << " from centre " << vp.GetExplodeCentre()
659             << G4endl;
660    }
661  }
662
663  else if (command == fpCommandGlobalLineWidthScale) {
664    G4double globalLineWidthScale
665      = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
666    vp.SetGlobalLineWidthScale(globalLineWidthScale);
667    if (verbosity >= G4VisManager::confirmations) {
668      G4cout << "Global Line Width Scale changed to "
669             << vp.GetGlobalLineWidthScale() << G4endl;
670    }
671  }
672
673  else if (command == fpCommandGlobalMarkerScale) {
674    G4double globalMarkerScale
675      = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
676    vp.SetGlobalMarkerScale(globalMarkerScale);
677    if (verbosity >= G4VisManager::confirmations) {
678      G4cout << "Global Marker Scale changed to "
679             << vp.GetGlobalMarkerScale() << G4endl;
680    }
681  }
682
683  else if (command == fpCommandHiddenEdge) {
684    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
685    if (G4UIcommand::ConvertToBool(newValue)) {
686      switch (existingStyle) {
687      case G4ViewParameters::wireframe:
688        vp.SetDrawingStyle(G4ViewParameters::hlr);
689        break;
690      case G4ViewParameters::hlr:
691        break;
692      case G4ViewParameters::hsr:
693        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
694        break;
695      case G4ViewParameters::hlhsr:
696        break;
697      }
698    }
699    else {
700      switch (existingStyle) {
701      case G4ViewParameters::wireframe:
702        break;
703      case G4ViewParameters::hlr:
704        vp.SetDrawingStyle(G4ViewParameters::wireframe);
705        break;
706      case G4ViewParameters::hsr:
707        break;
708      case G4ViewParameters::hlhsr:
709        vp.SetDrawingStyle(G4ViewParameters::hsr);
710        break;
711      }
712    }
713    if (verbosity >= G4VisManager::confirmations) {
714      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
715             << "\" set to " << vp.GetDrawingStyle()
716             << G4endl;
717    }
718  }
719
720  else if (command == fpCommandHiddenMarker) {
721    G4bool hidden = G4UIcommand::ConvertToBool(newValue);
722    if (hidden) vp.SetMarkerHidden();
723    else vp.SetMarkerNotHidden();
724    if (verbosity >= G4VisManager::confirmations) {
725      G4cout << "Markers will ";
726      if (vp.IsMarkerNotHidden()) G4cout << "not ";
727      G4cout << "be hidden under solid objects." << G4endl;
728    }
729  }
730
731  else if (command == fpCommandLightsMove) {
732    G4String s (newValue);
733    if (s.find("cam") != G4String::npos) vp.SetLightsMoveWithCamera(true);
734    else if(s.find("obj") != G4String::npos) vp.SetLightsMoveWithCamera(false);
735    else {
736      if (verbosity >= G4VisManager::errors) {
737        G4cout << "ERROR: \"" << newValue << "\" not recognised."
738        "  Looking for \"cam\" or \"obj\" in string." << G4endl;
739      }
740    }
741    if (verbosity >= G4VisManager::confirmations) {
742      G4cout << "Lights move with ";
743      if (vp.GetLightsMoveWithCamera())
744        G4cout << "camera (object appears to rotate).";
745      else G4cout << "object (the viewer appears to be moving).";
746      G4cout << G4endl;
747    }
748  }
749
750  else if (command == fpCommandLightsThetaPhi) {
751    G4double theta, phi;
752    ConvertToDoublePair(newValue, theta, phi);
753    G4double x = std::sin (theta) * std::cos (phi);
754    G4double y = std::sin (theta) * std::sin (phi);
755    G4double z = std::cos (theta);
756    fLightsVector = G4ThreeVector (x, y, z);
757    vp.SetLightpointDirection(fLightsVector);
758    if (verbosity >= G4VisManager::confirmations) {
759      G4cout << "Lights direction set to "
760             << vp.GetLightpointDirection() << G4endl;
761    }
762  }
763
764  else if (command == fpCommandLightsVector) {
765    fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
766    vp.SetLightpointDirection(fLightsVector);
767    if (verbosity >= G4VisManager::confirmations) {
768      G4cout << "Lights direction set to "
769             << vp.GetLightpointDirection() << G4endl;
770    }
771  }
772
773  else if (command == fpCommandLineSegments) {
774    G4int nSides = G4UIcommand::ConvertToInt(newValue);
775    nSides = vp.SetNoOfSides(nSides);
776    if (verbosity >= G4VisManager::confirmations) {
777      G4cout <<
778        "Number of line segements per circle in polygon approximation is "
779             << nSides << G4endl;
780    }
781  }
782
783  else if (command == fpCommandPicking) {
784    vp.SetPicking(G4UIcommand::ConvertToBool(newValue));
785    if (verbosity >= G4VisManager::confirmations) {
786      G4cout << "Picking ";
787      if (vp.IsPicking()) G4cout << "requested.";
788      else G4cout << "inhibited.";
789      G4cout << G4endl;
790    }
791  }
792
793  else if (command == fpCommandProjection) {
794    G4double fieldHalfAngle;
795    const size_t iPos0 = 0;
796    if (newValue[iPos0] == 'o') {  // "orthogonal"
797      fieldHalfAngle = 0.;
798    }
799    else if (newValue[iPos0] == 'p') {  // "perspective"
800      G4String dummy;
801      G4String unit;
802      std::istringstream is (newValue);
803      is >> dummy >> fieldHalfAngle >> unit;
804      fieldHalfAngle *= G4UIcommand::ValueOf(unit);
805      if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
806        if (verbosity >= G4VisManager::errors) {
807          G4cout <<
808            "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
809          G4cout << G4endl;
810        }
811        return;
812      }
813    }
814    else {
815      if (verbosity >= G4VisManager::errors) {
816        G4cout << "ERROR: \"" << newValue << "\" not recognised."
817          "  Looking for 'o' or 'p' first character." << G4endl;
818      }
819      return;
820    }
821    vp.SetFieldHalfAngle(fieldHalfAngle);
822    if (verbosity >= G4VisManager::confirmations) {
823      G4cout << "Projection style of viewer \"" << currentViewer->GetName()
824             << "\" set to ";
825      if (fieldHalfAngle == 0.) {
826        G4cout << "orthogonal.";
827      }
828      else {
829        G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
830               << " degrees.";
831      }
832      G4cout << G4endl;
833    }
834  }
835
836  else if (command == fpCommandSectionPlane) {
837    G4String choice, unit;
838    G4double x, y, z, nx, ny, nz;
839    std::istringstream is (newValue);
840    is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
841
842    G4int iSelector = -1;
843    if (choice.compareTo("off",G4String::ignoreCase) == 0 ||
844        !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
845    if (choice.compareTo("on",G4String::ignoreCase) == 0 ||
846        G4UIcommand::ConvertToBool(choice)) iSelector = 1;
847    if (iSelector < 0) {
848      if (verbosity >= G4VisManager::errors) {
849        G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
850        G4cout << "Section drawing is currently: ";
851        if (vp.IsSection ()) G4cout << "on";
852        else                    G4cout << "off";
853        G4cout << ".\nSection plane is currently: "
854               << vp.GetSectionPlane ();
855        G4cout << G4endl;
856      }
857      return;
858    }
859
860    G4double F = 1.;
861    switch (iSelector) {
862    default:
863    case 0:
864      vp.UnsetSectionPlane();
865      break;
866    case 1:
867      F = G4UIcommand::ValueOf(unit);
868      x *= F; y *= F; z *= F;
869      vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
870      vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
871      break;
872    }
873
874    if (verbosity >= G4VisManager::confirmations) {
875      G4cout << "Section drawing is now: ";
876      if (vp.IsSection ()) G4cout << "on";
877      else                    G4cout << "off";
878      G4cout << ".\nSection plane is now: "
879             << vp.GetSectionPlane ();
880      G4cout << G4endl;
881    }
882  }
883
884  else if (command == fpCommandStyle) {
885    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
886    const size_t iPos0 = 0;
887    if (newValue[iPos0] == 'w') {  // "wireframe"
888      switch (existingStyle) {
889      case G4ViewParameters::wireframe:
890        break;
891      case G4ViewParameters::hlr:
892        break;
893      case G4ViewParameters::hsr:
894        vp.SetDrawingStyle(G4ViewParameters::wireframe);
895        break;
896      case G4ViewParameters::hlhsr:
897        vp.SetDrawingStyle(G4ViewParameters::hlr);
898        break;
899      }
900    }
901    else if (newValue[iPos0] == 's') {  // "surface"
902      switch (existingStyle) {
903      case G4ViewParameters::wireframe:
904        vp.SetDrawingStyle(G4ViewParameters::hsr);
905        break;
906      case G4ViewParameters::hlr:
907        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
908        break;
909      case G4ViewParameters::hsr:
910        break;
911      case G4ViewParameters::hlhsr:
912        break;
913      }
914    }
915    else {
916      if (verbosity >= G4VisManager::errors) {
917        G4cout << "ERROR: \"" << newValue << "\" not recognised."
918          "  Looking for 'w' or 's' first character." << G4endl;
919      }
920      return;
921    }
922    if (verbosity >= G4VisManager::confirmations) {
923      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
924             << "\" set to " << vp.GetDrawingStyle()
925             << G4endl;
926    }
927  }
928
929  else if (command == fpCommandTargetPoint) {
930    G4ThreeVector targetPoint =
931      fpCommandTargetPoint->GetNew3VectorValue(newValue);
932    const G4Point3D& standardTargetPoint =
933      currentViewer->GetSceneHandler()->GetScene()->GetStandardTargetPoint();
934    vp.SetCurrentTargetPoint(targetPoint - standardTargetPoint);
935    if (verbosity >= G4VisManager::confirmations) {
936      G4cout << "Target point set to "
937             << fpCommandTargetPoint->ConvertToStringWithBestUnit
938        (targetPoint)
939             << "\n\"Current Target Point\" set to  "
940             << fpCommandTargetPoint->ConvertToStringWithBestUnit
941        (vp.GetCurrentTargetPoint())
942             << "\n\"Standard Target Point\" is "
943             << fpCommandTargetPoint->ConvertToStringWithBestUnit
944        (standardTargetPoint)
945             << G4endl;
946    }
947  }
948
949  else if (command == fpCommandUpThetaPhi) {
950    G4double theta, phi;
951    ConvertToDoublePair(newValue, theta, phi);
952    G4double x = std::sin (theta) * std::cos (phi);
953    G4double y = std::sin (theta) * std::sin (phi);
954    G4double z = std::cos (theta);
955    fUpVector = G4ThreeVector (x, y, z);
956    vp.SetUpVector(fUpVector);
957    if (verbosity >= G4VisManager::confirmations) {
958      G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
959    }
960  }
961
962  else if (command == fpCommandUpVector) {
963    fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
964    vp.SetUpVector(fUpVector);
965    if (verbosity >= G4VisManager::confirmations) {
966      G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
967    }
968  }
969
970  else if (command == fpCommandViewpointThetaPhi) {
971    G4double theta, phi;
972    ConvertToDoublePair(newValue, theta, phi);
973    G4double x = std::sin (theta) * std::cos (phi);
974    G4double y = std::sin (theta) * std::sin (phi);
975    G4double z = std::cos (theta);
976    fViewpointVector = G4ThreeVector (x, y, z);
977    vp.SetViewAndLights(fViewpointVector);
978    if (verbosity >= G4VisManager::confirmations) {
979      G4cout << "Viewpoint direction set to "
980             << vp.GetViewpointDirection() << G4endl;
981      if (vp.GetLightsMoveWithCamera ()) {
982        G4cout << "Lightpoint direction set to "
983               << vp.GetActualLightpointDirection () << G4endl;
984      }
985    }
986  }
987
988  else if (command == fpCommandViewpointVector) {
989    fViewpointVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
990    vp.SetViewAndLights(fViewpointVector);
991    if (verbosity >= G4VisManager::confirmations) {
992      G4cout << "Viewpoint direction set to "
993             << vp.GetViewpointDirection() << G4endl;
994      if (vp.GetLightsMoveWithCamera ()) {
995        G4cout << "Lightpoint direction set to "
996               << vp.GetActualLightpointDirection () << G4endl;
997      }
998    }
999  }
1000
1001  else {
1002    if (verbosity >= G4VisManager::errors) {
1003      G4cout <<
1004        "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
1005             << G4endl;
1006    }
1007    return;
1008  }
1009
1010  SetViewParameters(currentViewer,vp);
1011}
Note: See TracBrowser for help on using the repository browser.