source: trunk/geant4/visualization/management/src/G4VisCommandsViewerSet.cc @ 534

Last change on this file since 534 was 531, checked in by garnier, 17 years ago

r660@mac-90108: laurentgarnier | 2007-06-25 16:10:12 +0200
ajout de fichiers NON modifies
  • Property svn:mime-type set to text/cpp
File size: 35.6 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.47 2006/11/14 14:59:55 allison Exp $
28// GEANT4 tag $Name: geant4-08-02-patch-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 "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(false);
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(false);
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  fpCommandProjection = new G4UIcommand("/vis/viewer/set/projection",this);
251  fpCommandProjection->SetGuidance
252    ("Orthogonal or perspective projection.");
253  parameter = new G4UIparameter("projection",'s',omitable = true);
254  parameter->SetParameterCandidates("o orthogonal p perspective");
255  parameter->SetDefaultValue("orthogonal");
256  fpCommandProjection->SetParameter(parameter);
257  parameter = new G4UIparameter("field-half-angle",'d',omitable = true);
258  parameter->SetDefaultValue(30.);
259  fpCommandProjection->SetParameter(parameter);
260  parameter = new G4UIparameter("unit",'s',omitable = true);
261  parameter->SetDefaultValue("deg");
262  fpCommandProjection->SetParameter(parameter);
263
264  fpCommandSectionPlane = new G4UIcommand("/vis/viewer/set/sectionPlane",this);
265  fpCommandSectionPlane -> SetGuidance
266    ("Set plane for drawing section (DCUT).");
267  fpCommandSectionPlane -> SetGuidance
268    ("E.g., for a y-z plane at x = 1 cm:"
269     "\n\"/vis/viewer/set/sectionPlane on 1 0 0 cm 1 0 0\"."
270     "\nTo turn off: /vis/viewer/set/sectionPlane off");
271  parameter  =  new G4UIparameter("Selector",'c',true);
272  parameter  -> SetDefaultValue  ("on");
273  fpCommandSectionPlane->SetParameter(parameter);
274  parameter  =  new G4UIparameter("x",'d',omitable = true);
275  parameter  -> SetDefaultValue  (0);
276  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
277  fpCommandSectionPlane->SetParameter(parameter);
278  parameter  =  new G4UIparameter("y",'d',omitable = true);
279  parameter  -> SetDefaultValue  (0);
280  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
281  fpCommandSectionPlane->SetParameter(parameter);
282  parameter  =  new G4UIparameter("z",'d',omitable = true);
283  parameter  -> SetDefaultValue  (0);
284  parameter  -> SetGuidance      ("Coordinate of point on the plane.");
285  fpCommandSectionPlane->SetParameter(parameter);
286  parameter  =  new G4UIparameter("unit",'s',omitable = true);
287  parameter  -> SetDefaultValue  ("m");
288  parameter  -> SetGuidance      ("Unit of point on the plane.");
289  fpCommandSectionPlane->SetParameter(parameter);
290  parameter  =  new G4UIparameter("nx",'d',omitable = true);
291  parameter  -> SetDefaultValue  (1);
292  parameter  -> SetGuidance      ("Component of plane normal.");
293  fpCommandSectionPlane->SetParameter(parameter);
294  parameter  =  new G4UIparameter("ny",'d',omitable = true);
295  parameter  -> SetDefaultValue  (0);
296  parameter  -> SetGuidance      ("Component of plane normal.");
297  fpCommandSectionPlane->SetParameter(parameter);
298  parameter  =  new G4UIparameter("nz",'d',omitable = true);
299  parameter  -> SetDefaultValue  (0);
300  parameter  -> SetGuidance      ("Component of plane normal.");
301  fpCommandSectionPlane->SetParameter(parameter);
302
303  fpCommandStyle = new G4UIcmdWithAString ("/vis/viewer/set/style",this);
304  fpCommandStyle->SetGuidance
305    ("Set style of drawing - w[ireframe] or s[urface].");
306  fpCommandStyle->SetGuidance
307    ("(Hidden line drawing is controlled by \"/vis/viewer/set/hiddenEdge\".)");
308  fpCommandStyle->SetParameterName ("style",omitable = false);
309
310  fpCommandUpThetaPhi = new G4UIcommand
311    ("/vis/viewer/set/upThetaPhi", this);
312  fpCommandUpThetaPhi -> SetGuidance ("Set up vector.");
313  fpCommandUpThetaPhi -> SetGuidance
314    ("Viewer will attempt always to show this direction upwards.");
315  parameter = new G4UIparameter("theta", 'd', omitable = true);
316  parameter -> SetDefaultValue (90.);
317  fpCommandUpThetaPhi -> SetParameter (parameter);
318  parameter = new G4UIparameter("phi", 'd', omitable = true);
319  parameter -> SetDefaultValue (90.);
320  fpCommandUpThetaPhi -> SetParameter (parameter);
321  parameter = new G4UIparameter ("unit", 's', omitable = true);
322  parameter -> SetDefaultValue ("deg");
323  fpCommandUpThetaPhi -> SetParameter (parameter);
324
325  fpCommandUpVector = new G4UIcommand
326    ("/vis/viewer/set/upVector", this);
327  fpCommandUpVector -> SetGuidance ("Set up vector.");
328  fpCommandUpVector -> SetGuidance
329    ("Viewer will attempt always to show this direction upwards.");
330  parameter = new G4UIparameter("x", 'd', omitable = true);
331  parameter -> SetDefaultValue (0.);
332  fpCommandUpVector -> SetParameter (parameter);
333  parameter = new G4UIparameter("y", 'd', omitable = true);
334  parameter -> SetDefaultValue (1.);
335  fpCommandUpVector -> SetParameter (parameter);
336  parameter = new G4UIparameter ("z", 'd', omitable = true);
337  parameter -> SetDefaultValue (0.);
338  fpCommandUpVector -> SetParameter (parameter);
339
340  fpCommandViewpointThetaPhi = new G4UIcommand
341    ("/vis/viewer/set/viewpointThetaPhi", this);
342  fpCommandViewpointThetaPhi -> SetGuidance
343    ("Set direction from target to camera.");
344  fpCommandViewpointThetaPhi -> SetGuidance
345  ("Also changes lightpoint direction if lights are set to move with camera.");
346  parameter = new G4UIparameter("theta", 'd', omitable = true);
347  parameter -> SetDefaultValue (60.);
348  fpCommandViewpointThetaPhi -> SetParameter (parameter);
349  parameter = new G4UIparameter("phi", 'd', omitable = true);
350  parameter -> SetDefaultValue (45.);
351  fpCommandViewpointThetaPhi -> SetParameter (parameter);
352  parameter = new G4UIparameter ("unit", 's', omitable = true);
353  parameter -> SetDefaultValue ("deg");
354  fpCommandViewpointThetaPhi -> SetParameter (parameter);
355
356  fpCommandViewpointVector = new G4UIcommand
357    ("/vis/viewer/set/viewpointVector", this);
358  fpCommandViewpointVector -> SetGuidance
359    ("Set direction from target to camera.");
360  fpCommandViewpointVector -> SetGuidance
361  ("Also changes lightpoint direction if lights are set to move with camera.");
362  parameter = new G4UIparameter("x", 'd', omitable = true);
363  parameter -> SetDefaultValue (1.);
364  fpCommandViewpointVector -> SetParameter (parameter);
365  parameter = new G4UIparameter("y", 'd', omitable = true);
366  parameter -> SetDefaultValue (1.);
367  fpCommandViewpointVector -> SetParameter (parameter);
368  parameter = new G4UIparameter ("z", 'd', omitable = true);
369  parameter -> SetDefaultValue (1.);
370  fpCommandViewpointVector -> SetParameter (parameter);
371}
372
373G4VisCommandsViewerSet::~G4VisCommandsViewerSet() {
374  delete fpCommandAll;
375  delete fpCommandAuxEdge;
376  delete fpCommandAutoRefresh;
377  delete fpCommandBackground;
378  delete fpCommandCulling;
379  delete fpCommandCutawayMode;
380  delete fpCommandEdge;
381  delete fpCommandExplodeFactor;
382  delete fpCommandGlobalLineWidthScale;
383  delete fpCommandGlobalMarkerScale;
384  delete fpCommandHiddenEdge;
385  delete fpCommandHiddenMarker;
386  delete fpCommandLineSegments;
387  delete fpCommandLightsMove;
388  delete fpCommandLightsThetaPhi;
389  delete fpCommandLightsVector;
390  delete fpCommandProjection;
391  delete fpCommandSectionPlane;
392  delete fpCommandStyle;
393  delete fpCommandUpThetaPhi;
394  delete fpCommandUpVector;
395  delete fpCommandViewpointThetaPhi;
396  delete fpCommandViewpointVector;
397}
398
399G4String G4VisCommandsViewerSet::GetCurrentValue(G4UIcommand*) {
400  return "";
401}
402
403void G4VisCommandsViewerSet::SetNewValue
404(G4UIcommand* command,G4String newValue) {
405
406  G4VisManager::Verbosity verbosity = fpVisManager->GetVerbosity();
407
408  G4VViewer* currentViewer = fpVisManager->GetCurrentViewer();
409  if (!currentViewer) {
410    if (verbosity >= G4VisManager::errors) {
411      G4cout <<
412        "ERROR: G4VisCommandsViewerSet::SetNewValue: no current viewer."
413             << G4endl;
414    }
415    return;
416  }
417
418  G4ViewParameters vp = currentViewer->GetViewParameters();
419
420  if (command == fpCommandAll) {
421    G4VViewer* fromViewer = fpVisManager->GetViewer(newValue);
422    if (!fromViewer) {
423      if (verbosity >= G4VisManager::errors) {
424        G4cout <<
425          "ERROR: G4VisCommandsViewerSet::SetNewValue: all:"
426          "\n  unrecognised from-viewer."
427               << G4endl;
428      }
429      return;
430    }
431    if (fromViewer == currentViewer) {
432      if (verbosity >= G4VisManager::warnings) {
433      G4cout <<
434        "WARNING: G4VisCommandsViewerSet::SetNewValue: all:"
435        "\n  from-viewer and current viewer are identical."
436             << G4endl;
437      }
438      return;
439    }
440    // Copy view parameters except for autoRefresh...
441    G4bool currentAutoRefresh =
442      currentViewer->GetViewParameters().IsAutoRefresh();
443    vp = fromViewer->GetViewParameters();
444    vp.SetAutoRefresh(currentAutoRefresh);
445    if (verbosity >= G4VisManager::confirmations) {
446      G4cout << "View parameters of viewer \"" << currentViewer->GetName()
447             << "\"\n  set to those of viewer \"" << fromViewer->GetName()
448             << "\"."
449             << G4endl;
450    }
451  }
452
453  else if (command == fpCommandAutoRefresh) {
454    G4bool autoRefresh = G4UIcommand::ConvertToBool(newValue);
455    vp.SetAutoRefresh(autoRefresh);
456    if (verbosity >= G4VisManager::confirmations) {
457      G4cout << "Views will ";
458      if (!vp.IsAutoRefresh()) G4cout << "not ";
459      G4cout << "be automatically refreshed after a change of view parameters."
460             << G4endl;
461    }
462    currentViewer->SetViewParameters(vp);
463    return;  // I.e., avoid a refresh for this command.
464  }
465
466  else if (command == fpCommandAuxEdge) {
467    vp.SetAuxEdgeVisible(G4UIcommand::ConvertToBool(newValue));
468    if (verbosity >= G4VisManager::confirmations) {
469      G4cout << "Auxiliary edges will ";
470      if (!vp.IsAuxEdgeVisible()) G4cout << "not ";
471      G4cout << "be visible." << G4endl;
472    }
473  }
474
475  else if (command == fpCommandBackground) {
476    G4String redOrString;
477    G4double green, blue, opacity;
478    std::istringstream iss(newValue);
479    iss >> redOrString >> green >> blue >> opacity;
480    G4Colour colour(0.,0.,0.);  // Default black and opaque.
481    const size_t iPos0 = 0;
482    if (std::isalpha(redOrString[iPos0])) {
483      G4Colour::GetColour(redOrString, colour); // Remains default (black) if
484                                                // not found.
485    } else {
486      colour = G4Colour(G4UIcommand::ConvertTo3Vector(newValue));
487    }
488    colour = G4Colour(colour.GetRed(), colour.GetGreen(), colour.GetBlue(), opacity);
489    vp.SetBackgroundColour(colour);
490    if (verbosity >= G4VisManager::confirmations) {
491      G4cout << "Background colour "
492             << vp.GetBackgroundColour()
493             << " requested."
494             << G4endl;
495    }
496  }
497
498  else if (command == fpCommandCulling) {
499    G4String cullingOption, stringFlag, unit;
500    G4double density;
501    std::istringstream is (newValue);
502    is >> cullingOption >> stringFlag >> density >> unit;
503    G4bool boolFlag = G4UIcommand::ConvertToBool(stringFlag);
504    if (cullingOption == "global") {
505      vp.SetCulling(boolFlag);
506      if (verbosity >= G4VisManager::confirmations) {
507        G4cout <<
508          "G4VisCommandsViewerSet::SetNewValue: culling: global culling flag"
509          " set to " << G4UIcommand::ConvertToString(boolFlag) <<
510          ".\n  Does not change specific culling flags."
511               << G4endl;
512      }
513    }
514    else if (cullingOption == "coveredDaughters") {
515      vp.SetCullingCovered(boolFlag);
516      if (verbosity >= G4VisManager::confirmations) {
517        G4cout <<
518          "G4VisCommandsViewerSet::SetNewValue: culling: culling covered"
519          "\n  daughters flag set to "
520               << G4UIcommand::ConvertToString(boolFlag) <<
521          ".  Daughters covered by opaque mothers"
522          "\n  will be culled, i.e., not drawn, if this flag is true."
523          "\n  Note: this is only effective in surface drawing style,"
524          "\n  and then only if the volumes are visible and opaque, and then"
525          "\n  only if no sections or cutaways are in operation."
526               << G4endl;
527      }
528    }
529    else if (cullingOption == "invisible") {
530      vp.SetCullingInvisible(boolFlag);
531      if (verbosity >= G4VisManager::confirmations) {
532        G4cout <<
533          "G4VisCommandsViewerSet::SetNewValue: culling: culling invisible"
534          "\n  flag set to "
535               << boolFlag << G4UIcommand::ConvertToString(boolFlag) <<
536          ".  Volumes marked invisible will be culled,"
537          "\n  i.e., not drawn, if this flag is true."
538               << G4endl;
539      }
540    }
541    else if (cullingOption == "density") {
542      vp.SetDensityCulling(boolFlag);
543      if (boolFlag) {
544        density *= G4UnitDefinition::GetValueOf(unit);
545        vp.SetVisibleDensity(density);
546      }
547      else {
548        density = vp.GetVisibleDensity();
549      }
550      if (verbosity >= G4VisManager::confirmations) {
551        G4cout <<
552          "G4VisCommandsViewerSet::SetNewValue: culling: culling by density"
553          "\n  flag set to " << G4UIcommand::ConvertToString(boolFlag) <<
554          ".  Volumes with density less than " <<
555          G4BestUnit(density,"Volumic Mass") <<
556          "\n  will be culled, i.e., not drawn, if this flag is true."
557               << G4endl;
558      }
559    }
560    else {
561      if (verbosity >= G4VisManager::errors) {
562        G4cout <<
563          "ERROR: G4VisCommandsViewerSet::SetNewValue: culling:"
564          "\n  option not recognised."
565               << G4endl;
566      }
567    }
568  }
569
570  else if (command == fpCommandCutawayMode) {
571    if (newValue == "add" || newValue == "union")
572      vp.SetCutawayMode(G4ViewParameters::cutawayUnion);
573    if (newValue == "multiply" || newValue == "intersection")
574      vp.SetCutawayMode(G4ViewParameters::cutawayIntersection);
575 
576    if (verbosity >= G4VisManager::confirmations) {
577      G4cout << "Cutaway mode set to ";
578      if (vp.GetCutawayMode() == G4ViewParameters::cutawayUnion)
579        G4cout << "cutawayUnion";
580      if (vp.GetCutawayMode() == G4ViewParameters::cutawayIntersection)
581        G4cout << "cutawayIntersection";
582      G4cout << G4endl;
583    }
584  }
585
586  else if (command == fpCommandEdge) {
587    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
588    if (G4UIcommand::ConvertToBool(newValue)) {
589      switch (existingStyle) {
590      case G4ViewParameters::wireframe:
591        break;
592      case G4ViewParameters::hlr:
593        break;
594      case G4ViewParameters::hsr:
595        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
596        break;
597      case G4ViewParameters::hlhsr:
598        break;
599      }
600    }
601    else {
602      switch (existingStyle) {
603      case G4ViewParameters::wireframe:
604        break;
605      case G4ViewParameters::hlr:
606        break;
607      case G4ViewParameters::hsr:
608        break;
609      case G4ViewParameters::hlhsr:
610        vp.SetDrawingStyle(G4ViewParameters::hsr);
611        break;
612      }
613    }
614    if (verbosity >= G4VisManager::confirmations) {
615      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
616             << "\" set to " << vp.GetDrawingStyle()
617             << G4endl;
618    }
619  }
620
621  else if (command == fpCommandExplodeFactor) {
622    G4double explodeFactor, x, y, z;
623    G4String unitString;
624    std::istringstream is (newValue);
625    is >> explodeFactor >> x >> y >> z >> unitString;
626    G4double unit = G4UIcommand::ValueOf(unitString);
627    vp.SetExplodeFactor(explodeFactor);
628    vp.SetExplodeCentre(G4Point3D(x * unit, y * unit, z * unit));
629    if (verbosity >= G4VisManager::confirmations) {
630      G4cout << "Explode factor changed to " << vp.GetExplodeFactor()
631             << " from centre " << vp.GetExplodeCentre()
632             << G4endl;
633    }
634  }
635
636  else if (command == fpCommandGlobalLineWidthScale) {
637    G4double globalLineWidthScale
638      = fpCommandGlobalLineWidthScale->GetNewDoubleValue(newValue);
639    vp.SetGlobalLineWidthScale(globalLineWidthScale);
640    if (verbosity >= G4VisManager::confirmations) {
641      G4cout << "Global Line Width Scale changed to "
642             << vp.GetGlobalLineWidthScale() << G4endl;
643    }
644  }
645
646  else if (command == fpCommandGlobalMarkerScale) {
647    G4double globalMarkerScale
648      = fpCommandGlobalMarkerScale->GetNewDoubleValue(newValue);
649    vp.SetGlobalMarkerScale(globalMarkerScale);
650    if (verbosity >= G4VisManager::confirmations) {
651      G4cout << "Global Marker Scale changed to "
652             << vp.GetGlobalMarkerScale() << G4endl;
653    }
654  }
655
656  else if (command == fpCommandHiddenEdge) {
657    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
658    if (G4UIcommand::ConvertToBool(newValue)) {
659      switch (existingStyle) {
660      case G4ViewParameters::wireframe:
661        vp.SetDrawingStyle(G4ViewParameters::hlr);
662        break;
663      case G4ViewParameters::hlr:
664        break;
665      case G4ViewParameters::hsr:
666        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
667        break;
668      case G4ViewParameters::hlhsr:
669        break;
670      }
671    }
672    else {
673      switch (existingStyle) {
674      case G4ViewParameters::wireframe:
675        break;
676      case G4ViewParameters::hlr:
677        vp.SetDrawingStyle(G4ViewParameters::wireframe);
678        break;
679      case G4ViewParameters::hsr:
680        break;
681      case G4ViewParameters::hlhsr:
682        vp.SetDrawingStyle(G4ViewParameters::hsr);
683        break;
684      }
685    }
686    if (verbosity >= G4VisManager::confirmations) {
687      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
688             << "\" set to " << vp.GetDrawingStyle()
689             << G4endl;
690    }
691  }
692
693  else if (command == fpCommandHiddenMarker) {
694    G4bool hidden = G4UIcommand::ConvertToBool(newValue);
695    if (hidden) vp.SetMarkerHidden();
696    else vp.SetMarkerNotHidden();
697    if (verbosity >= G4VisManager::confirmations) {
698      G4cout << "Markers will ";
699      if (vp.IsMarkerNotHidden()) G4cout << "not ";
700      G4cout << "be hidden under solid objects." << G4endl;
701    }
702  }
703
704  else if (command == fpCommandLightsMove) {
705    G4String s (newValue);
706    if (s.find("cam") != G4String::npos) vp.SetLightsMoveWithCamera(true);
707    else if(s.find("obj") != G4String::npos) vp.SetLightsMoveWithCamera(false);
708    else {
709      if (verbosity >= G4VisManager::errors) {
710        G4cout << "ERROR: \"" << newValue << "\" not recognised."
711        "  Looking for \"cam\" or \"obj\" in string." << G4endl;
712      }
713    }
714    if (verbosity >= G4VisManager::confirmations) {
715      G4cout << "Lights move with ";
716      if (vp.GetLightsMoveWithCamera())
717        G4cout << "camera (object appears to rotate).";
718      else G4cout << "object (the viewer appears to be moving).";
719      G4cout << G4endl;
720    }
721  }
722
723  else if (command == fpCommandLightsThetaPhi) {
724    G4double theta, phi;
725    ConvertToDoublePair(newValue, theta, phi);
726    G4double x = std::sin (theta) * std::cos (phi);
727    G4double y = std::sin (theta) * std::sin (phi);
728    G4double z = std::cos (theta);
729    fLightsVector = G4ThreeVector (x, y, z);
730    vp.SetLightpointDirection(fLightsVector);
731    if (verbosity >= G4VisManager::confirmations) {
732      G4cout << "Lights direction set to "
733             << vp.GetLightpointDirection() << G4endl;
734    }
735  }
736
737  else if (command == fpCommandLightsVector) {
738    fLightsVector = G4UIcommand::ConvertTo3Vector(newValue);
739    vp.SetLightpointDirection(fLightsVector);
740    if (verbosity >= G4VisManager::confirmations) {
741      G4cout << "Lights direction set to "
742             << vp.GetLightpointDirection() << G4endl;
743    }
744  }
745
746  else if (command == fpCommandLineSegments) {
747    G4int nSides = G4UIcommand::ConvertToInt(newValue);
748    nSides = vp.SetNoOfSides(nSides);
749    if (verbosity >= G4VisManager::confirmations) {
750      G4cout <<
751        "Number of line segements per circle in polygon approximation is "
752             << nSides << G4endl;
753    }
754  }
755
756  else if (command == fpCommandProjection) {
757    G4double fieldHalfAngle;
758    const size_t iPos0 = 0;
759    if (newValue[iPos0] == 'o') {  // "orthogonal"
760      fieldHalfAngle = 0.;
761    }
762    else if (newValue[iPos0] == 'p') {  // "perspective"
763      G4String dummy;
764      G4String unit;
765      std::istringstream is (newValue);
766      is >> dummy >> fieldHalfAngle >> unit;
767      fieldHalfAngle *= G4UIcommand::ValueOf(unit);
768      if (fieldHalfAngle > 89.5 * deg || fieldHalfAngle <= 0.0) {
769        if (verbosity >= G4VisManager::errors) {
770          G4cout <<
771            "ERROR: Field half angle should be 0 < angle <= 89.5 degrees.";
772          G4cout << G4endl;
773        }
774        return;
775      }
776    }
777    else {
778      if (verbosity >= G4VisManager::errors) {
779        G4cout << "ERROR: \"" << newValue << "\" not recognised."
780          "  Looking for 'o' or 'p' first character." << G4endl;
781      }
782      return;
783    }
784    vp.SetFieldHalfAngle(fieldHalfAngle);
785    if (verbosity >= G4VisManager::confirmations) {
786      G4cout << "Projection style of viewer \"" << currentViewer->GetName()
787             << "\" set to ";
788      if (fieldHalfAngle == 0.) {
789        G4cout << "orthogonal.";
790      }
791      else {
792        G4cout << "perspective\n  with half angle " << fieldHalfAngle / deg
793               << " degrees.";
794      }
795      G4cout << G4endl;
796    }
797  }
798
799  else if (command == fpCommandSectionPlane) {
800    G4String choice, unit;
801    G4double x, y, z, nx, ny, nz;
802    std::istringstream is (newValue);
803    is >> choice >> x >> y >> z >> unit >> nx >> ny >> nz;
804
805    G4int iSelector = -1;
806    if (choice.compareTo("off",G4String::ignoreCase) == 0 ||
807        !G4UIcommand::ConvertToBool(choice)) iSelector = 0;
808    if (choice.compareTo("on",G4String::ignoreCase) == 0 ||
809        G4UIcommand::ConvertToBool(choice)) iSelector = 1;
810    if (iSelector < 0) {
811      if (verbosity >= G4VisManager::errors) {
812        G4cout << "Choice not recognised (on/true or off/false)." << G4endl;
813        G4cout << "Section drawing is currently: ";
814        if (vp.IsSection ()) G4cout << "on";
815        else                    G4cout << "off";
816        G4cout << ".\nSection plane is currently: "
817               << vp.GetSectionPlane ();
818        G4cout << G4endl;
819      }
820      return;
821    }
822
823    G4double F = 1.;
824    switch (iSelector) {
825    default:
826    case 0:
827      vp.UnsetSectionPlane();
828      break;
829    case 1:
830      F = G4UIcommand::ValueOf(unit);
831      x *= F; y *= F; z *= F;
832      vp.SetSectionPlane(G4Plane3D(G4Normal3D(nx,ny,nz), G4Point3D(x,y,z)));
833      vp.SetViewpointDirection(G4Normal3D(nx,ny,nz));
834      break;
835    }
836
837    if (verbosity >= G4VisManager::confirmations) {
838      G4cout << "Section drawing is now: ";
839      if (vp.IsSection ()) G4cout << "on";
840      else                    G4cout << "off";
841      G4cout << ".\nSection plane is now: "
842             << vp.GetSectionPlane ();
843      G4cout << G4endl;
844    }
845  }
846
847  else if (command == fpCommandStyle) {
848    G4ViewParameters::DrawingStyle existingStyle = vp.GetDrawingStyle();
849    const size_t iPos0 = 0;
850    if (newValue[iPos0] == 'w') {  // "wireframe"
851      switch (existingStyle) {
852      case G4ViewParameters::wireframe:
853        break;
854      case G4ViewParameters::hlr:
855        break;
856      case G4ViewParameters::hsr:
857        vp.SetDrawingStyle(G4ViewParameters::wireframe);
858        break;
859      case G4ViewParameters::hlhsr:
860        vp.SetDrawingStyle(G4ViewParameters::hlr);
861        break;
862      }
863    }
864    else if (newValue[iPos0] == 's') {  // "surface"
865      switch (existingStyle) {
866      case G4ViewParameters::wireframe:
867        vp.SetDrawingStyle(G4ViewParameters::hsr);
868        break;
869      case G4ViewParameters::hlr:
870        vp.SetDrawingStyle(G4ViewParameters::hlhsr);
871        break;
872      case G4ViewParameters::hsr:
873        break;
874      case G4ViewParameters::hlhsr:
875        break;
876      }
877    }
878    else {
879      if (verbosity >= G4VisManager::errors) {
880        G4cout << "ERROR: \"" << newValue << "\" not recognised."
881          "  Looking for 'w' or 's' first character." << G4endl;
882      }
883      return;
884    }
885    if (verbosity >= G4VisManager::confirmations) {
886      G4cout << "Drawing style of viewer \"" << currentViewer->GetName()
887             << "\" set to " << vp.GetDrawingStyle()
888             << G4endl;
889    }
890  }
891
892  else if (command == fpCommandUpThetaPhi) {
893    G4double theta, phi;
894    ConvertToDoublePair(newValue, theta, phi);
895    G4double x = std::sin (theta) * std::cos (phi);
896    G4double y = std::sin (theta) * std::sin (phi);
897    G4double z = std::cos (theta);
898    fUpVector = G4ThreeVector (x, y, z);
899    vp.SetUpVector(fUpVector);
900    if (verbosity >= G4VisManager::confirmations) {
901      G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
902    }
903  }
904
905  else if (command == fpCommandUpVector) {
906    fUpVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
907    vp.SetUpVector(fUpVector);
908    if (verbosity >= G4VisManager::confirmations) {
909      G4cout << "Up direction set to " << vp.GetUpVector() << G4endl;
910    }
911  }
912
913  else if (command == fpCommandViewpointThetaPhi) {
914    G4double theta, phi;
915    ConvertToDoublePair(newValue, theta, phi);
916    G4double x = std::sin (theta) * std::cos (phi);
917    G4double y = std::sin (theta) * std::sin (phi);
918    G4double z = std::cos (theta);
919    fViewpointVector = G4ThreeVector (x, y, z);
920    vp.SetViewAndLights(fViewpointVector);
921    if (verbosity >= G4VisManager::confirmations) {
922      G4cout << "Viewpoint direction set to "
923             << vp.GetViewpointDirection() << G4endl;
924      if (vp.GetLightsMoveWithCamera ()) {
925        G4cout << "Lightpoint direction set to "
926               << vp.GetActualLightpointDirection () << G4endl;
927      }
928    }
929  }
930
931  else if (command == fpCommandViewpointVector) {
932    fViewpointVector = G4UIcommand::ConvertTo3Vector(newValue).unit();
933    vp.SetViewAndLights(fViewpointVector);
934    if (verbosity >= G4VisManager::confirmations) {
935      G4cout << "Viewpoint direction set to "
936             << vp.GetViewpointDirection() << G4endl;
937      if (vp.GetLightsMoveWithCamera ()) {
938        G4cout << "Lightpoint direction set to "
939               << vp.GetActualLightpointDirection () << G4endl;
940      }
941    }
942  }
943
944  else {
945    if (verbosity >= G4VisManager::errors) {
946      G4cout <<
947        "ERROR: G4VisCommandsViewerSet::SetNewValue: unrecognised command."
948             << G4endl;
949    }
950    return;
951  }
952
953  SetViewParameters(currentViewer,vp);
954}
Note: See TracBrowser for help on using the repository browser.