source: tags/Visualization_after-vis09-02-01-tag/management/src/G4VisCommandsViewerSet.cc @ 958

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

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