Geant4 Cross Reference

Cross-Referencing   Geant4
Geant4/visualization/management/src/G4ViewParameters.cc

Version: [ ReleaseNotes ] [ 1.0 ] [ 1.1 ] [ 2.0 ] [ 3.0 ] [ 3.1 ] [ 3.2 ] [ 4.0 ] [ 4.0.p1 ] [ 4.0.p2 ] [ 4.1 ] [ 4.1.p1 ] [ 5.0 ] [ 5.0.p1 ] [ 5.1 ] [ 5.1.p1 ] [ 5.2 ] [ 5.2.p1 ] [ 5.2.p2 ] [ 6.0 ] [ 6.0.p1 ] [ 6.1 ] [ 6.2 ] [ 6.2.p1 ] [ 6.2.p2 ] [ 7.0 ] [ 7.0.p1 ] [ 7.1 ] [ 7.1.p1 ] [ 8.0 ] [ 8.0.p1 ] [ 8.1 ] [ 8.1.p1 ] [ 8.1.p2 ] [ 8.2 ] [ 8.2.p1 ] [ 8.3 ] [ 8.3.p1 ] [ 8.3.p2 ] [ 9.0 ] [ 9.0.p1 ] [ 9.0.p2 ] [ 9.1 ] [ 9.1.p1 ] [ 9.1.p2 ] [ 9.1.p3 ] [ 9.2 ] [ 9.2.p1 ] [ 9.2.p2 ] [ 9.2.p3 ] [ 9.2.p4 ] [ 9.3 ] [ 9.3.p1 ] [ 9.3.p2 ] [ 9.4 ] [ 9.4.p1 ] [ 9.4.p2 ] [ 9.4.p3 ] [ 9.4.p4 ] [ 9.5 ] [ 9.5.p1 ] [ 9.5.p2 ] [ 9.6 ] [ 9.6.p1 ] [ 9.6.p2 ] [ 9.6.p3 ] [ 9.6.p4 ] [ 10.0 ] [ 10.0.p1 ] [ 10.0.p2 ] [ 10.0.p3 ] [ 10.0.p4 ] [ 10.1 ] [ 10.1.p1 ] [ 10.1.p2 ] [ 10.1.p3 ] [ 10.2 ] [ 10.2.p1 ] [ 10.2.p2 ] [ 10.2.p3 ] [ 10.3 ] [ 10.3.p1 ] [ 10.3.p2 ] [ 10.3.p3 ] [ 10.4 ] [ 10.4.p1 ] [ 10.4.p2 ] [ 10.4.p3 ] [ 10.5 ] [ 10.5.p1 ] [ 10.6 ] [ 10.6.p1 ] [ 10.6.p2 ] [ 10.6.p3 ] [ 10.7 ] [ 10.7.p1 ] [ 10.7.p2 ] [ 10.7.p3 ] [ 10.7.p4 ] [ 11.0 ] [ 11.0.p1 ] [ 11.0.p2 ] [ 11.0.p3, ] [ 11.0.p4 ] [ 11.1 ] [ 11.1.1 ] [ 11.1.2 ] [ 11.1.3 ] [ 11.2 ] [ 11.2.1 ] [ 11.2.2 ] [ 11.3.0 ]

Diff markup

Differences between /visualization/management/src/G4ViewParameters.cc (Version 11.3.0) and /visualization/management/src/G4ViewParameters.cc (Version 9.4)


  1 //                                                  1 //
  2 // *******************************************      2 // ********************************************************************
  3 // * License and Disclaimer                         3 // * License and Disclaimer                                           *
  4 // *                                                4 // *                                                                  *
  5 // * The  Geant4 software  is  copyright of th      5 // * The  Geant4 software  is  copyright of the Copyright Holders  of *
  6 // * the Geant4 Collaboration.  It is provided      6 // * the Geant4 Collaboration.  It is provided  under  the terms  and *
  7 // * conditions of the Geant4 Software License      7 // * conditions of the Geant4 Software License,  included in the file *
  8 // * LICENSE and available at  http://cern.ch/      8 // * LICENSE and available at  http://cern.ch/geant4/license .  These *
  9 // * include a list of copyright holders.           9 // * include a list of copyright holders.                             *
 10 // *                                               10 // *                                                                  *
 11 // * Neither the authors of this software syst     11 // * Neither the authors of this software system, nor their employing *
 12 // * institutes,nor the agencies providing fin     12 // * institutes,nor the agencies providing financial support for this *
 13 // * work  make  any representation or  warran     13 // * work  make  any representation or  warranty, express or implied, *
 14 // * regarding  this  software system or assum     14 // * regarding  this  software system or assume any liability for its *
 15 // * use.  Please see the license in the file      15 // * use.  Please see the license in the file  LICENSE  and URL above *
 16 // * for the full disclaimer and the limitatio     16 // * for the full disclaimer and the limitation of liability.         *
 17 // *                                               17 // *                                                                  *
 18 // * This  code  implementation is the result      18 // * This  code  implementation is the result of  the  scientific and *
 19 // * technical work of the GEANT4 collaboratio     19 // * technical work of the GEANT4 collaboration.                      *
 20 // * By using,  copying,  modifying or  distri     20 // * By using,  copying,  modifying or  distributing the software (or *
 21 // * any work based  on the software)  you  ag     21 // * any work based  on the software)  you  agree  to acknowledge its *
 22 // * use  in  resulting  scientific  publicati     22 // * use  in  resulting  scientific  publications,  and indicate your *
 23 // * acceptance of all terms of the Geant4 Sof     23 // * acceptance of all terms of the Geant4 Software license.          *
 24 // *******************************************     24 // ********************************************************************
 25 //                                                 25 //
 26 //                                                 26 //
                                                   >>  27 // $Id: G4ViewParameters.cc,v 1.38 2010/11/05 16:00:11 allison Exp $
                                                   >>  28 // GEANT4 tag $Name: geant4-09-04 $
 27 //                                                 29 //
 28 //                                                 30 // 
 29 // John Allison  19th July 1996                    31 // John Allison  19th July 1996
 30 // View parameters and options.                    32 // View parameters and options.
 31                                                    33 
                                                   >>  34 #include <sstream>
                                                   >>  35 
 32 #include "G4ViewParameters.hh"                     36 #include "G4ViewParameters.hh"
 33                                                    37 
 34 #include "G4VisManager.hh"                         38 #include "G4VisManager.hh"
 35 #include "G4VPhysicalVolume.hh"                << 
 36 #include "G4UnitsTable.hh"                         39 #include "G4UnitsTable.hh"
 37 #include "G4SystemOfUnits.hh"                  <<  40 #include "G4ios.hh"
 38 #include "G4Polyhedron.hh"                     << 
 39                                                << 
 40 #include <sstream>                             << 
 41 #include <cmath>                               << 
 42                                                << 
 43 #define G4warn G4cout                          << 
 44                                                    41 
 45 G4ViewParameters::G4ViewParameters ():             42 G4ViewParameters::G4ViewParameters ():
                                                   >>  43   fNoValue(0x0000),
                                                   >>  44   fXValue(0x0001),
                                                   >>  45   fYValue(0x0002),
                                                   >>  46   fWidthValue(0x0004),
                                                   >>  47   fHeightValue(0x0008),
                                                   >>  48   fAllValues(0x000F),
                                                   >>  49   fXNegative(0x0010),
                                                   >>  50   fYNegative(0x0020),
                                                   >>  51   fGeometryMask(0),
 46   fDrawingStyle (wireframe),                       52   fDrawingStyle (wireframe),
 47   fNumberOfCloudPoints(10000),                 << 
 48   fAuxEdgeVisible (false),                         53   fAuxEdgeVisible (false),
                                                   >>  54   fRepStyle (polyhedron),
 49   fCulling (true),                                 55   fCulling (true),
 50   fCullInvisible (true),                           56   fCullInvisible (true),
 51   fDensityCulling (false),                         57   fDensityCulling (false),
 52   fVisibleDensity (0.01 * g / cm3),                58   fVisibleDensity (0.01 * g / cm3),
 53   fCullCovered (false),                            59   fCullCovered (false),
 54   fCBDAlgorithmNumber (0),                     << 
 55   fSection (false),                                60   fSection (false),
 56   fSectionPlane (),                                61   fSectionPlane (),
 57   fCutawayMode (cutawayUnion),                     62   fCutawayMode (cutawayUnion),
 58   fCutawayPlanes (),                               63   fCutawayPlanes (),
 59   fExplodeFactor (1.),                             64   fExplodeFactor (1.),
 60   fNoOfSides (),                               <<  65   fNoOfSides (24),
 61   fViewpointDirection (G4Vector3D (0., 0., 1.)     66   fViewpointDirection (G4Vector3D (0., 0., 1.)),  // On z-axis.
 62   fUpVector (G4Vector3D (0., 1., 0.)),             67   fUpVector (G4Vector3D (0., 1., 0.)),            // y-axis up.
 63   fFieldHalfAngle (0.),                            68   fFieldHalfAngle (0.),                           // Orthogonal projection.
 64   fZoomFactor (1.),                                69   fZoomFactor (1.),
 65   fScaleFactor (G4Vector3D (1., 1., 1.)),          70   fScaleFactor (G4Vector3D (1., 1., 1.)),
 66   fCurrentTargetPoint (),                          71   fCurrentTargetPoint (),
 67   fDolly (0.),                                     72   fDolly (0.),
 68   fLightsMoveWithCamera (false),                   73   fLightsMoveWithCamera (false),
 69   fRelativeLightpointDirection (G4Vector3D (1.     74   fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
 70   fActualLightpointDirection (G4Vector3D (1.,      75   fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
 71   fDefaultVisAttributes (),                        76   fDefaultVisAttributes (),
 72   fDefaultTextVisAttributes (G4Colour (0., 0.,     77   fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
 73   fDefaultMarker (),                               78   fDefaultMarker (),
 74   fGlobalMarkerScale (1.),                         79   fGlobalMarkerScale (1.),
 75   fGlobalLineWidthScale (1.),                      80   fGlobalLineWidthScale (1.),
 76   fMarkerNotHidden (true),                         81   fMarkerNotHidden (true),
 77   fWindowSizeHintX (600),                          82   fWindowSizeHintX (600),
 78   fWindowSizeHintY (600),                          83   fWindowSizeHintY (600),
 79   fWindowLocationHintX(0),                         84   fWindowLocationHintX(0),
 80   fWindowLocationHintY(0),                         85   fWindowLocationHintY(0),
 81   fWindowLocationHintXNegative(true),              86   fWindowLocationHintXNegative(true),
 82   fWindowLocationHintYNegative(false),             87   fWindowLocationHintYNegative(false),
 83   fGeometryMask(0),                            << 
 84   fAutoRefresh (false),                            88   fAutoRefresh (false),
 85   fBackgroundColour (G4Colour(0.,0.,0.)),          89   fBackgroundColour (G4Colour(0.,0.,0.)),         // Black
 86   fPicking (false),                            <<  90   fPicking (false)
 87   fRotationStyle (constrainUpDirection),       << 
 88   fStartTime(-G4VisAttributes::fVeryLongTime), << 
 89   fEndTime(G4VisAttributes::fVeryLongTime),    << 
 90   fFadeFactor(0.),                             << 
 91   fDisplayHeadTime(false),                     << 
 92   fDisplayHeadTimeX(-0.9),                     << 
 93   fDisplayHeadTimeY(-0.9),                     << 
 94   fDisplayHeadTimeSize(24.),                   << 
 95   fDisplayHeadTimeRed(0.),                     << 
 96   fDisplayHeadTimeGreen(1.),                   << 
 97   fDisplayHeadTimeBlue(1.),                    << 
 98   fDisplayLightFront(false),                   << 
 99   fDisplayLightFrontX(0.),                     << 
100   fDisplayLightFrontY(0.),                     << 
101   fDisplayLightFrontZ(0.),                     << 
102   fDisplayLightFrontT(0.),                     << 
103   fDisplayLightFrontRed(0.),                   << 
104   fDisplayLightFrontGreen(1.),                 << 
105   fDisplayLightFrontBlue(0.),                  << 
106   fSpecialMeshRendering(false),                << 
107   fSpecialMeshRenderingOption(meshAsDefault)   << 
108 {                                                  91 {
109   // Pick up default no of sides from G4Polyhe << 
110   // Note that this parameter is variously cal << 
111   //   No of sides                             << 
112   //   NumberOfRotationSteps                   << 
113   //   Line segments per circle                << 
114   // It refers to the approximation of a circl << 
115   // stated number of sides.                   << 
116   fNoOfSides = G4Polyhedron::GetNumberOfRotati << 
117                                                << 
118   fDefaultMarker.SetScreenSize (5.);               92   fDefaultMarker.SetScreenSize (5.);
119   // Markers are 5 pixels "overall" size, i.e.     93   // Markers are 5 pixels "overall" size, i.e., diameter.
120 }                                                  94 }
121                                                    95 
122 G4ViewParameters::~G4ViewParameters () {}          96 G4ViewParameters::~G4ViewParameters () {}
123                                                    97 
124 void G4ViewParameters::MultiplyScaleFactor         98 void G4ViewParameters::MultiplyScaleFactor
125 (const G4Vector3D& scaleFactorMultiplier) {        99 (const G4Vector3D& scaleFactorMultiplier) {
126   fScaleFactor.setX(fScaleFactor.x() * scaleFa    100   fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
127   fScaleFactor.setY(fScaleFactor.y() * scaleFa    101   fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
128   fScaleFactor.setZ(fScaleFactor.z() * scaleFa    102   fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
129 }                                                 103 }
130                                                   104 
131 G4Vector3D& G4ViewParameters::GetActualLightpo    105 G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
132   SetViewAndLights (fViewpointDirection);         106   SetViewAndLights (fViewpointDirection);
133   return fActualLightpointDirection;              107   return fActualLightpointDirection;
134 }                                                 108 }
135                                                   109 
136 // Useful quantities - begin snippet.             110 // Useful quantities - begin snippet.
137 // Here Follow functions to evaluate the above    111 // Here Follow functions to evaluate the above algorithms as a
138 // function of the radius of the Bounding Sphe    112 // function of the radius of the Bounding Sphere of the object being
139 // viewed.  Call them in the order given - for    113 // viewed.  Call them in the order given - for efficiency, later
140 // functions depend on the results of earlier     114 // functions depend on the results of earlier ones (Store the
141 // results of earlier functions in your own te    115 // results of earlier functions in your own temporary variables -
142 // see, for example, G4OpenGLView::SetView ().    116 // see, for example, G4OpenGLView::SetView ().)
143                                                   117 
144 G4double G4ViewParameters::GetCameraDistance (    118 G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
145   G4double cameraDistance;                        119   G4double cameraDistance;
146   if (fFieldHalfAngle == 0.) {                    120   if (fFieldHalfAngle == 0.) {
147     cameraDistance = radius;                      121     cameraDistance = radius;
148   }                                               122   }
149   else {                                          123   else {
150     cameraDistance = radius / std::sin (fField    124     cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
151   }                                               125   }
152   return cameraDistance;                          126   return cameraDistance;
153 }                                                 127 }
154                                                   128 
155 G4double G4ViewParameters::GetNearDistance (G4    129 G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
156               G4double radius) const {            130               G4double radius) const {
157   const G4double small = 1.e-6 * radius;          131   const G4double small = 1.e-6 * radius;
158   G4double nearDistance = cameraDistance - rad    132   G4double nearDistance = cameraDistance - radius;
159   if (nearDistance < small) nearDistance = sma    133   if (nearDistance < small) nearDistance = small;
160   return nearDistance;                            134   return nearDistance;
161 }                                                 135 }
162                                                   136 
163 G4double G4ViewParameters::GetFarDistance (G4d    137 G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
164              G4double nearDistance,               138              G4double nearDistance,
165              G4double radius) const {             139              G4double radius) const {
166   G4double farDistance = cameraDistance + radi    140   G4double farDistance = cameraDistance + radius;
167   if (farDistance < nearDistance) farDistance     141   if (farDistance < nearDistance) farDistance = nearDistance;
168   return farDistance;                             142   return farDistance;
169 }                                                 143 }
170                                                   144 
171 G4double G4ViewParameters::GetFrontHalfHeight     145 G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
172                  G4double radius) const {         146                  G4double radius) const {
173   G4double frontHalfHeight;                       147   G4double frontHalfHeight;
174   if (fFieldHalfAngle == 0.) {                    148   if (fFieldHalfAngle == 0.) {
175     frontHalfHeight = radius / fZoomFactor;       149     frontHalfHeight = radius / fZoomFactor;
176   }                                               150   }
177   else {                                          151   else {
178     frontHalfHeight = nearDistance * std::tan     152     frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
179   }                                               153   }
180   return frontHalfHeight;                         154   return frontHalfHeight;
181 }                                                 155 }
182 // Useful quantities - end snippet.               156 // Useful quantities - end snippet.
183                                                   157 
184 void G4ViewParameters::AddCutawayPlane (const     158 void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
185   if (fCutawayPlanes.size () < 3 ) {              159   if (fCutawayPlanes.size () < 3 ) {
186     fCutawayPlanes.push_back (cutawayPlane);      160     fCutawayPlanes.push_back (cutawayPlane);
187   }                                               161   }
188   else {                                          162   else {
189     G4warn <<                                  << 163     G4cout <<
190       "ERROR: G4ViewParameters::AddCutawayPlan    164       "ERROR: G4ViewParameters::AddCutawayPlane:"
191       "\n  A maximum of 3 cutaway planes suppo    165       "\n  A maximum of 3 cutaway planes supported." << G4endl;
192   }                                               166   }
193 }                                                 167 }
194                                                   168 
195 void G4ViewParameters::ChangeCutawayPlane         169 void G4ViewParameters::ChangeCutawayPlane
196 (size_t index, const G4Plane3D& cutawayPlane)     170 (size_t index, const G4Plane3D& cutawayPlane) {
197   if (index >= fCutawayPlanes.size()) {           171   if (index >= fCutawayPlanes.size()) {
198     G4warn <<                                  << 172     G4cout <<
199       "ERROR: G4ViewParameters::ChangeCutawayP    173       "ERROR: G4ViewParameters::ChangeCutawayPlane:"
200       "\n  Plane " << index << " does not exis    174       "\n  Plane " << index << " does not exist." << G4endl;
201   } else {                                        175   } else {
202     fCutawayPlanes[index] = cutawayPlane;         176     fCutawayPlanes[index] = cutawayPlane;
203   }                                               177   }
204 }                                                 178 }
205                                                   179 
206 void G4ViewParameters::SetVisibleDensity (G4do    180 void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
207   const G4double reasonableMaximum = 10.0 * g     181   const G4double reasonableMaximum = 10.0 * g / cm3;
208   if (visibleDensity < 0) {                       182   if (visibleDensity < 0) {
209     G4warn << "G4ViewParameters::SetVisibleDen << 183     G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
210       "density - ignored." << G4endl;             184       "density - ignored." << G4endl;
211   }                                               185   }
212   else {                                          186   else {
213     if (visibleDensity > reasonableMaximum) {     187     if (visibleDensity > reasonableMaximum) {
214       G4warn << "G4ViewParameters::SetVisibleD << 188       G4cout << "G4ViewParameters::SetVisibleDensity: density > "
215        << G4BestUnit (reasonableMaximum, "Volu    189        << G4BestUnit (reasonableMaximum, "Volumic Mass")
216        << " - did you mean this?"                 190        << " - did you mean this?"
217        << G4endl;                                 191        << G4endl;
218     }                                             192     }
219     fVisibleDensity = visibleDensity;             193     fVisibleDensity = visibleDensity;
220   }                                               194   }
221 }                                                 195 }
222                                                   196 
223 G4int G4ViewParameters::SetNoOfSides (G4int nS    197 G4int G4ViewParameters::SetNoOfSides (G4int nSides) {
224   const G4int nSidesMin = fDefaultVisAttribute << 198   const G4int  nSidesMin = 12;
225   if (nSides < nSidesMin) {                       199   if (nSides < nSidesMin) {
226     nSides = nSidesMin;                           200     nSides = nSidesMin;
227     G4warn << "G4ViewParameters::SetNoOfSides: << 201     G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
228     "\nnumber of sides per circle < " << nSide << 202       "\nnumber of sides per circle < " << nSidesMin
229     << "; forced to " << nSides << G4endl;     << 203    << "; forced to " << nSides << G4endl;
230   }                                               204   }
231   fNoOfSides = nSides;                            205   fNoOfSides = nSides;
232   return fNoOfSides;                              206   return fNoOfSides;
233 }                                                 207 }
234                                                   208 
235 G4int G4ViewParameters::SetNumberOfCloudPoints << 
236   const G4int nPointsMin = 100;                << 
237   if (nPoints < nPointsMin) {                  << 
238     nPoints = nPointsMin;                      << 
239     G4warn << "G4ViewParameters::SetNumberOfCl << 
240     "\nnumber of points per cloud set to minim << 
241     << G4endl;                                 << 
242   }                                            << 
243   fNumberOfCloudPoints = nPoints;              << 
244   return fNumberOfCloudPoints;                 << 
245 }                                              << 
246                                                << 
247 void G4ViewParameters::SetViewAndLights           209 void G4ViewParameters::SetViewAndLights
248 (const G4Vector3D& viewpointDirection) {          210 (const G4Vector3D& viewpointDirection) {
249                                                   211 
250   fViewpointDirection = viewpointDirection;       212   fViewpointDirection = viewpointDirection;
251                                                   213 
252   // If the requested viewpoint direction is p    214   // If the requested viewpoint direction is parallel to the up
253   // vector, the orientation of the view is un    215   // vector, the orientation of the view is undefined...
254   if (fViewpointDirection.unit() * fUpVector.u    216   if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
255     static G4bool firstTime = true;            << 217     G4cout <<
256     if (firstTime) {                           << 
257       firstTime = false;                       << 
258       G4warn <<                                << 
259       "WARNING: Viewpoint direction is very cl    218       "WARNING: Viewpoint direction is very close to the up vector direction."
260       "\n  Change the up vector or \"/vis/view << 219       "\n  Consider setting the up vector to obtain definable behaviour."
261       << G4endl;                               << 220      << G4endl;
262     }                                          << 
263   }                                               221   }
264                                                   222 
265   // Move the lights too if requested...          223   // Move the lights too if requested...
266   if (fLightsMoveWithCamera) {                    224   if (fLightsMoveWithCamera) {
267     G4Vector3D zprime = fViewpointDirection.un    225     G4Vector3D zprime = fViewpointDirection.unit ();
268     G4Vector3D xprime = (fUpVector.cross (zpri    226     G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
269     G4Vector3D yprime = zprime.cross (xprime);    227     G4Vector3D yprime = zprime.cross (xprime);
270     fActualLightpointDirection =                  228     fActualLightpointDirection =
271       fRelativeLightpointDirection.x () * xpri    229       fRelativeLightpointDirection.x () * xprime +
272       fRelativeLightpointDirection.y () * ypri    230       fRelativeLightpointDirection.y () * yprime +
273       fRelativeLightpointDirection.x () * zpri    231       fRelativeLightpointDirection.x () * zprime;     
274   } else {                                        232   } else {
275     fActualLightpointDirection = fRelativeLigh    233     fActualLightpointDirection = fRelativeLightpointDirection;
276   }                                               234   }
277 }                                                 235 }
278                                                   236 
279 void G4ViewParameters::SetLightpointDirection     237 void G4ViewParameters::SetLightpointDirection
280 (const G4Vector3D& lightpointDirection) {         238 (const G4Vector3D& lightpointDirection) {
281   fRelativeLightpointDirection = lightpointDir    239   fRelativeLightpointDirection = lightpointDirection;
282   SetViewAndLights (fViewpointDirection);         240   SetViewAndLights (fViewpointDirection);
283 }                                                 241 }
284                                                   242 
285 void G4ViewParameters::SetPan (G4double right,    243 void G4ViewParameters::SetPan (G4double right, G4double up) {
286   G4Vector3D unitRight = (fUpVector.cross (fVi    244   G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
287   G4Vector3D unitUp    = (fViewpointDirection.    245   G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
288   fCurrentTargetPoint  = right * unitRight + u    246   fCurrentTargetPoint  = right * unitRight + up * unitUp;
289 }                                                 247 }
290                                                   248 
291 void G4ViewParameters::IncrementPan (G4double     249 void G4ViewParameters::IncrementPan (G4double right, G4double up) {
292   IncrementPan (right,up, 0);                     250   IncrementPan (right,up, 0);
293 }                                                 251 }
294                                                   252 
295 void G4ViewParameters::IncrementPan (G4double     253 void G4ViewParameters::IncrementPan (G4double right, G4double up, G4double distance) {
296   G4Vector3D unitRight = (fUpVector.cross (fVi    254   G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
297   G4Vector3D unitUp    = (fViewpointDirection.    255   G4Vector3D unitUp    = (fViewpointDirection.cross (unitRight)).unit();
298   fCurrentTargetPoint += right * unitRight + u    256   fCurrentTargetPoint += right * unitRight + up * unitUp + distance * fViewpointDirection;
299 }                                                 257 }
300                                                   258 
301 void G4ViewParameters::AddVisAttributesModifie << 
302 (const G4ModelingParameters::VisAttributesModi << 
303   // If target exists with same signifier just << 
304   G4bool duplicateTarget = false;              << 
305   auto i = fVisAttributesModifiers.begin();    << 
306   for (; i < fVisAttributesModifiers.end(); ++ << 
307     if (vam.GetPVNameCopyNoPath() == (*i).GetP << 
308         vam.GetVisAttributesSignifier() == (*i << 
309       duplicateTarget = true;                  << 
310       break;                                   << 
311     }                                          << 
312   }                                            << 
313   if (duplicateTarget) (*i).SetVisAttributes(v << 
314   else fVisAttributesModifiers.push_back(vam); << 
315 }                                              << 
316                                                << 
317 G4String G4ViewParameters::CameraAndLightingCo << 
318 (const G4Point3D standardTargetPoint) const    << 
319 {                                              << 
320   std::ostringstream oss;                      << 
321                                                << 
322   oss << "#\n# Camera and lights commands";    << 
323                                                << 
324   oss << "\n/vis/viewer/set/viewpointVector "  << 
325   << fViewpointDirection.x()                   << 
326   << ' ' << fViewpointDirection.y()            << 
327   << ' ' << fViewpointDirection.z();           << 
328                                                << 
329   oss << "\n/vis/viewer/set/upVector "         << 
330   << fUpVector.x()                             << 
331   << ' ' << fUpVector.y()                      << 
332   << ' ' << fUpVector.z();                     << 
333                                                << 
334   oss << "\n/vis/viewer/set/projection ";      << 
335     if (fFieldHalfAngle == 0.) {               << 
336     oss                                        << 
337     << "orthogonal";                           << 
338   } else {                                     << 
339     oss                                        << 
340     << "perspective "                          << 
341     << fFieldHalfAngle/deg                     << 
342     << " deg";                                 << 
343   }                                            << 
344                                                << 
345   oss << "\n/vis/viewer/zoomTo "               << 
346   << fZoomFactor;                              << 
347                                                << 
348   oss << "\n/vis/viewer/scaleTo "              << 
349   << fScaleFactor.x()                          << 
350   << ' ' << fScaleFactor.y()                   << 
351   << ' ' << fScaleFactor.z();                  << 
352                                                << 
353   oss << "\n/vis/viewer/set/targetPoint "      << 
354   << G4BestUnit(standardTargetPoint+fCurrentTa << 
355   << "\n# Note that if you have not set a targ << 
356   << "\n# a target point based on the scene -  << 
357   << "\n# so don't be alarmed by strange coord << 
358                                                << 
359   oss << "\n/vis/viewer/dollyTo "              << 
360   << G4BestUnit(fDolly,"Length");              << 
361                                                << 
362   oss << "\n/vis/viewer/set/lightsMove ";      << 
363   if (fLightsMoveWithCamera) {                 << 
364     oss << "camera";                           << 
365   } else {                                     << 
366     oss << "object";                           << 
367   }                                            << 
368                                                << 
369   oss << "\n/vis/viewer/set/lightsVector "     << 
370   << fRelativeLightpointDirection.x()          << 
371   << ' ' << fRelativeLightpointDirection.y()   << 
372   << ' ' << fRelativeLightpointDirection.z();  << 
373                                                << 
374   oss << "\n/vis/viewer/set/rotationStyle ";   << 
375   if (fRotationStyle == constrainUpDirection)  << 
376     oss << "constrainUpDirection";             << 
377   } else {                                     << 
378     oss << "freeRotation";                     << 
379   }                                            << 
380                                                << 
381   G4Colour c = fBackgroundColour;              << 
382   oss << "\n/vis/viewer/set/background "       << 
383   << c.GetRed()                                << 
384   << ' ' << c.GetGreen()                       << 
385   << ' ' << c.GetBlue()                        << 
386   << ' ' << c.GetAlpha();                      << 
387                                                << 
388   c = fDefaultVisAttributes.GetColour();       << 
389   oss << "\n/vis/viewer/set/defaultColour "    << 
390   << c.GetRed()                                << 
391   << ' ' << c.GetGreen()                       << 
392   << ' ' << c.GetBlue()                        << 
393   << ' ' << c.GetAlpha();                      << 
394                                                << 
395   c = fDefaultTextVisAttributes.GetColour();   << 
396   oss << "\n/vis/viewer/set/defaultTextColour  << 
397   << c.GetRed()                                << 
398   << ' ' << c.GetGreen()                       << 
399   << ' ' << c.GetBlue()                        << 
400   << ' ' << c.GetAlpha();                      << 
401                                                << 
402   oss << std::endl;                            << 
403                                                << 
404   return oss.str();                            << 
405 }                                              << 
406                                                << 
407 G4String G4ViewParameters::DrawingStyleCommand << 
408 {                                              << 
409   std::ostringstream oss;                      << 
410                                                << 
411   oss << "#\n# Drawing style commands";        << 
412                                                << 
413   oss << "\n/vis/viewer/set/style ";           << 
414   switch (fDrawingStyle) {                     << 
415     case wireframe:                            << 
416     case hlr:                                  << 
417       oss << "wireframe";                      << 
418       break;                                   << 
419     case hsr:                                  << 
420     case hlhsr:                                << 
421       oss << "surface";                        << 
422       break;                                   << 
423     case cloud:                                << 
424       oss << "cloud";                          << 
425       break;                                   << 
426   }                                            << 
427                                                << 
428   oss << "\n/vis/viewer/set/hiddenEdge ";      << 
429   if (fDrawingStyle == hlr || fDrawingStyle == << 
430     oss << "true";                             << 
431   } else {                                     << 
432     oss << "false";                            << 
433   }                                            << 
434                                                << 
435   oss << "\n/vis/viewer/set/auxiliaryEdge ";   << 
436   if (fAuxEdgeVisible) {                       << 
437     oss << "true";                             << 
438   } else {                                     << 
439     oss << "false";                            << 
440   }                                            << 
441                                                << 
442   oss << "\n/vis/viewer/set/hiddenMarker ";    << 
443   if (fMarkerNotHidden) {                      << 
444     oss << "false";                            << 
445   } else {                                     << 
446     oss << "true";                             << 
447   }                                            << 
448                                                << 
449   oss << "\n/vis/viewer/set/globalLineWidthSca << 
450   << fGlobalLineWidthScale;                    << 
451                                                << 
452   oss << "\n/vis/viewer/set/globalMarkerScale  << 
453   << fGlobalMarkerScale;                       << 
454                                                << 
455   oss << "\n/vis/viewer/set/numberOfCloudPoint << 
456   << fNumberOfCloudPoints;                     << 
457                                                << 
458   oss << "\n/vis/viewer/set/specialMeshRenderi << 
459   if (fSpecialMeshRendering) {                 << 
460     oss << "true";                             << 
461   } else {                                     << 
462     oss << "false";                            << 
463   }                                            << 
464                                                << 
465   oss << "\n/vis/viewer/set/specialMeshRenderi << 
466   << fSpecialMeshRenderingOption;              << 
467                                                << 
468   oss << "\n/vis/viewer/set/specialMeshVolumes << 
469   for (const auto& volume : fSpecialMeshVolume << 
470     oss << ' ' << volume.GetName() << ' ' << v << 
471   }                                            << 
472                                                << 
473   oss << std::endl;                            << 
474                                                << 
475   return oss.str();                            << 
476 }                                              << 
477                                                << 
478 G4String G4ViewParameters::SceneModifyingComma << 
479 {                                              << 
480   std::ostringstream oss;                      << 
481                                                << 
482   oss << "#\n# Scene-modifying commands";      << 
483                                                << 
484   oss << "\n/vis/viewer/set/culling global ";  << 
485   if (fCulling) {                              << 
486     oss << "true";                             << 
487   } else {                                     << 
488     oss << "false";                            << 
489   }                                            << 
490                                                << 
491   oss << "\n/vis/viewer/set/culling invisible  << 
492   if (fCullInvisible) {                        << 
493     oss << "true";                             << 
494   } else {                                     << 
495     oss << "false";                            << 
496   }                                            << 
497                                                << 
498   oss << "\n/vis/viewer/set/culling density "; << 
499   if (fDensityCulling) {                       << 
500     oss << "true " << fVisibleDensity/(g/cm3)  << 
501   } else {                                     << 
502     oss << "false";                            << 
503   }                                            << 
504                                                << 
505   oss << "\n/vis/viewer/set/culling coveredDau << 
506   if (fCullCovered) {                          << 
507     oss << "true";                             << 
508   } else {                                     << 
509     oss << "false";                            << 
510   }                                            << 
511                                                << 
512   oss << "\n/vis/viewer/colourByDensity "      << 
513   << fCBDAlgorithmNumber << " g/cm3";          << 
514   for (auto p: fCBDParameters) {               << 
515     oss << ' ' << p/(g/cm3);                   << 
516   }                                            << 
517                                                << 
518   oss << "\n/vis/viewer/set/sectionPlane ";    << 
519   if (fSection) {                              << 
520     oss << "on "                               << 
521     << G4BestUnit(fSectionPlane.point(),"Lengt << 
522     << fSectionPlane.normal().x()              << 
523     << ' ' << fSectionPlane.normal().y()       << 
524     << ' ' << fSectionPlane.normal().z();      << 
525   } else {                                     << 
526     oss << "off";                              << 
527   }                                            << 
528                                                << 
529   oss << "\n/vis/viewer/set/cutawayMode ";     << 
530   if (fCutawayMode == cutawayUnion) {          << 
531     oss << "union";                            << 
532   } else {                                     << 
533     oss << "intersection";                     << 
534   }                                            << 
535                                                << 
536   oss << "\n/vis/viewer/clearCutawayPlanes";   << 
537   if (fCutawayPlanes.size()) {                 << 
538     for (size_t i = 0; i < fCutawayPlanes.size << 
539       oss << "\n/vis/viewer/addCutawayPlane "  << 
540       << G4BestUnit(fCutawayPlanes[i].point(), << 
541       << fCutawayPlanes[i].normal().x()        << 
542       << ' ' << fCutawayPlanes[i].normal().y() << 
543       << ' ' << fCutawayPlanes[i].normal().z() << 
544     }                                          << 
545   } else {                                     << 
546     oss << "\n# No cutaway planes defined.";   << 
547   }                                            << 
548                                                << 
549   oss << "\n/vis/viewer/set/explodeFactor "    << 
550   << fExplodeFactor                            << 
551   << ' ' << G4BestUnit(fExplodeCentre,"Length" << 
552                                                << 
553   oss << "\n/vis/viewer/set/lineSegmentsPerCir << 
554   << fNoOfSides;                               << 
555                                                << 
556   oss << std::endl;                            << 
557                                                << 
558   return oss.str();                            << 
559 }                                              << 
560                                                << 
561 G4String G4ViewParameters::TouchableCommands() << 
562 {                                              << 
563   std::ostringstream oss;                      << 
564                                                << 
565   oss << "#\n# Touchable commands";            << 
566                                                << 
567   const std::vector<G4ModelingParameters::VisA << 
568     fVisAttributesModifiers;                   << 
569                                                << 
570   if (vams.empty()) {                          << 
571     oss                                        << 
572     << "\n# None"                              << 
573     << "\n/vis/viewer/clearVisAttributesModifi << 
574     oss << std::endl;                          << 
575     return oss.str();                          << 
576   }                                            << 
577                                                << 
578   oss                                          << 
579   << "\n/vis/viewer/clearVisAttributesModifier << 
580                                                << 
581   G4ModelingParameters::PVNameCopyNoPath lastP << 
582   std::vector<G4ModelingParameters::VisAttribu << 
583     iModifier;                                 << 
584   for (iModifier = vams.begin();               << 
585        iModifier != vams.end();                << 
586        ++iModifier) {                          << 
587     const G4ModelingParameters::PVNameCopyNoPa << 
588       iModifier->GetPVNameCopyNoPath();        << 
589     if (vamPath != lastPath) {                 << 
590       lastPath = vamPath;                      << 
591       oss << "\n/vis/set/touchable";           << 
592       G4ModelingParameters::PVNameCopyNoPathCo << 
593       for (iVAM = vamPath.begin();             << 
594            iVAM != vamPath.end();              << 
595            ++iVAM) {                           << 
596         oss << ' ' << iVAM->GetName() << ' ' < << 
597       }                                        << 
598     }                                          << 
599     const G4VisAttributes& vamVisAtts = iModif << 
600     const G4Colour& c = vamVisAtts.GetColour() << 
601     switch (iModifier->GetVisAttributesSignifi << 
602       case G4ModelingParameters::VASVisibility << 
603         oss << "\n/vis/touchable/set/visibilit << 
604         if (vamVisAtts.IsVisible()) {          << 
605           oss << "true";                       << 
606         } else {                               << 
607           oss << "false";                      << 
608         }                                      << 
609         break;                                 << 
610       case G4ModelingParameters::VASDaughtersI << 
611         oss << "\n/vis/touchable/set/daughters << 
612         if (vamVisAtts.IsDaughtersInvisible()) << 
613           oss << "true";                       << 
614         } else {                               << 
615           oss << "false";                      << 
616         }                                      << 
617         break;                                 << 
618       case G4ModelingParameters::VASColour:    << 
619         oss << "\n/vis/touchable/set/colour "  << 
620         << c.GetRed()                          << 
621         << ' ' << c.GetGreen()                 << 
622         << ' ' << c.GetBlue()                  << 
623         << ' ' << c.GetAlpha();                << 
624         break;                                 << 
625       case G4ModelingParameters::VASLineStyle: << 
626         oss << "\n/vis/touchable/set/lineStyle << 
627         switch (vamVisAtts.GetLineStyle()) {   << 
628           case G4VisAttributes::unbroken:      << 
629             oss << "unbroken";                 << 
630             break;                             << 
631           case G4VisAttributes::dashed:        << 
632             oss << "dashed";                   << 
633             break;                             << 
634           case G4VisAttributes::dotted:        << 
635           oss << "dotted";                     << 
636         }                                      << 
637         break;                                 << 
638       case G4ModelingParameters::VASLineWidth: << 
639         oss << "\n/vis/touchable/set/lineWidth << 
640         << vamVisAtts.GetLineWidth();          << 
641         break;                                 << 
642       case G4ModelingParameters::VASForceWiref << 
643         if (vamVisAtts.IsForceDrawingStyle())  << 
644           if (vamVisAtts.GetForcedDrawingStyle << 
645             oss << "\n/vis/touchable/set/force << 
646             if (vamVisAtts.IsForceDrawingStyle << 
647               oss << "true";                   << 
648             } else {                           << 
649               oss << "false";                  << 
650             }                                  << 
651           }                                    << 
652         }                                      << 
653         break;                                 << 
654       case G4ModelingParameters::VASForceSolid << 
655         if (vamVisAtts.IsForceDrawingStyle())  << 
656           if (vamVisAtts.GetForcedDrawingStyle << 
657             oss << "\n/vis/touchable/set/force << 
658             if (vamVisAtts.IsForceDrawingStyle << 
659               oss << "true";                   << 
660             } else {                           << 
661               oss << "false";                  << 
662             }                                  << 
663           }                                    << 
664         }                                      << 
665         break;                                 << 
666       case G4ModelingParameters::VASForceCloud << 
667         if (vamVisAtts.IsForceDrawingStyle())  << 
668           if (vamVisAtts.GetForcedDrawingStyle << 
669             oss << "\n/vis/touchable/set/force << 
670             if (vamVisAtts.IsForceDrawingStyle << 
671               oss << "true";                   << 
672             } else {                           << 
673               oss << "false";                  << 
674             }                                  << 
675           }                                    << 
676         }                                      << 
677         break;                                 << 
678       case G4ModelingParameters::VASForceAuxEd << 
679         if (vamVisAtts.IsForceAuxEdgeVisible() << 
680           oss << "\n/vis/touchable/set/forceAu << 
681           if (vamVisAtts.IsForcedAuxEdgeVisibl << 
682             oss << "true";                     << 
683           } else {                             << 
684             oss << "false";                    << 
685           }                                    << 
686         }                                      << 
687         break;                                 << 
688       case G4ModelingParameters::VASForceLineS << 
689         oss << "\n/vis/touchable/set/lineSegme << 
690         << vamVisAtts.GetForcedLineSegmentsPer << 
691         break;                                 << 
692       case G4ModelingParameters::VASForceNumbe << 
693         oss << "\n/vis/touchable/set/numberOfC << 
694         << vamVisAtts.GetForcedNumberOfCloudPo << 
695         break;                                 << 
696     }                                          << 
697   }                                            << 
698                                                << 
699   oss << std::endl;                            << 
700                                                << 
701   return oss.str();                            << 
702 }                                              << 
703                                                << 
704 G4String G4ViewParameters::TimeWindowCommands( << 
705 {                                              << 
706   std::ostringstream oss;                      << 
707                                                << 
708   oss <<  "#\n# Time window commands";         << 
709                                                << 
710   oss                                          << 
711   << "\n/vis/viewer/set/timeWindow/startTime " << 
712   << fStartTime/ns << " ns ";                  << 
713                                                << 
714   oss                                          << 
715   << "\n/vis/viewer/set/timeWindow/endTime "   << 
716   << fEndTime/ns << " ns ";                    << 
717                                                << 
718   oss << "\n/vis/viewer/set/timeWindow/fadeFac << 
719   << fFadeFactor;                              << 
720                                                << 
721   oss                                          << 
722   << "\n/vis/viewer/set/timeWindow/displayHead << 
723   if (!fDisplayHeadTime) {                     << 
724     oss << "false";                            << 
725   } else {                                     << 
726     oss                                        << 
727     << "true"                                  << 
728     << ' ' << fDisplayHeadTimeX                << 
729     << ' ' << fDisplayHeadTimeY                << 
730     << ' ' << fDisplayHeadTimeSize             << 
731     << ' ' << fDisplayHeadTimeRed              << 
732     << ' ' << fDisplayHeadTimeGreen            << 
733     << ' ' << fDisplayHeadTimeBlue;            << 
734   }                                            << 
735                                                << 
736   oss                                          << 
737   << "\n/vis/viewer/set/timeWindow/displayLigh << 
738   if (!fDisplayLightFront) {                   << 
739     oss << "false";                            << 
740   } else {                                     << 
741     oss                                        << 
742     << "true"                                  << 
743     << ' ' << fDisplayLightFrontX/mm           << 
744     << ' ' << fDisplayLightFrontY/mm           << 
745     << ' ' << fDisplayLightFrontZ/mm           << 
746     << " mm"                                   << 
747     << ' ' << fDisplayLightFrontT/ns           << 
748     << " ns"                                   << 
749     << ' ' << fDisplayLightFrontRed            << 
750     << ' ' << fDisplayLightFrontGreen          << 
751     << ' ' << fDisplayLightFrontBlue;          << 
752   }                                            << 
753                                                << 
754   oss << std::endl;                            << 
755                                                << 
756   return oss.str();                            << 
757 }                                              << 
758                                                << 
759 void G4ViewParameters::PrintDifferences (const    259 void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
760                                                   260 
761   // Put performance-sensitive parameters firs    261   // Put performance-sensitive parameters first.
762   if (                                            262   if (
763       // This first to optimise spin, etc.        263       // This first to optimise spin, etc.
764       (fViewpointDirection   != v.fViewpointDi    264       (fViewpointDirection   != v.fViewpointDirection)   ||
765                                                   265 
766       // No particular order from here on.        266       // No particular order from here on.
767       (fDrawingStyle         != v.fDrawingStyl    267       (fDrawingStyle         != v.fDrawingStyle)         ||
768       (fNumberOfCloudPoints  != v.fNumberOfClo << 
769       (fAuxEdgeVisible       != v.fAuxEdgeVisi    268       (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
                                                   >> 269       (fRepStyle             != v.fRepStyle)             ||
770       (fCulling              != v.fCulling)       270       (fCulling              != v.fCulling)              ||
771       (fCullInvisible        != v.fCullInvisib    271       (fCullInvisible        != v.fCullInvisible)        ||
772       (fDensityCulling       != v.fDensityCull    272       (fDensityCulling       != v.fDensityCulling)       ||
773       (fVisibleDensity       != v.fVisibleDens    273       (fVisibleDensity       != v.fVisibleDensity)       ||
774       (fCullCovered          != v.fCullCovered    274       (fCullCovered          != v.fCullCovered)          ||
775       (fCBDAlgorithmNumber   != v.fCBDAlgorith << 
776       (fSection              != v.fSection)       275       (fSection              != v.fSection)              ||
777       (fNoOfSides            != v.fNoOfSides)     276       (fNoOfSides            != v.fNoOfSides)            ||
778       (fUpVector             != v.fUpVector)      277       (fUpVector             != v.fUpVector)             ||
779       (fFieldHalfAngle       != v.fFieldHalfAn    278       (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
780       (fZoomFactor           != v.fZoomFactor)    279       (fZoomFactor           != v.fZoomFactor)           ||
781       (fScaleFactor          != v.fScaleFactor    280       (fScaleFactor          != v.fScaleFactor)          ||
782       (fCurrentTargetPoint   != v.fCurrentTarg    281       (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
783       (fDolly                != v.fDolly)         282       (fDolly                != v.fDolly)                ||
784       (fRelativeLightpointDirection != v.fRela    283       (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
785       (fLightsMoveWithCamera != v.fLightsMoveW    284       (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
786       (fDefaultVisAttributes != v.fDefaultVisA    285       (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
787       (fDefaultTextVisAttributes != v.fDefault    286       (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
788       (fDefaultMarker        != v.fDefaultMark    287       (fDefaultMarker        != v.fDefaultMarker)        ||
789       (fGlobalMarkerScale    != v.fGlobalMarke    288       (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
790       (fGlobalLineWidthScale != v.fGlobalLineW    289       (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
791       (fMarkerNotHidden      != v.fMarkerNotHi    290       (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
792       (fWindowSizeHintX      != v.fWindowSizeH    291       (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
793       (fWindowSizeHintY      != v.fWindowSizeH    292       (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
794       (fXGeometryString      != v.fXGeometrySt    293       (fXGeometryString      != v.fXGeometryString)      ||
795       (fGeometryMask         != v.fGeometryMas << 
796       (fAutoRefresh          != v.fAutoRefresh    294       (fAutoRefresh          != v.fAutoRefresh)          ||
797       (fBackgroundColour     != v.fBackgroundC    295       (fBackgroundColour     != v.fBackgroundColour)     || 
798       (fPicking              != v.fPicking)    << 296       (fPicking              != v.fPicking)
799       (fRotationStyle        != v.fRotationSty << 
800       )                                           297       )
801     G4cout << "Difference in 1st batch." << G4    298     G4cout << "Difference in 1st batch." << G4endl;
802                                                   299 
803   if (fCBDAlgorithmNumber > 0) {               << 
804     if (fCBDParameters.size() != v.fCBDParamet << 
805       G4cout << "Difference in number of colou << 
806     } else if (fCBDParameters != v.fCBDParamet << 
807       G4cout << "Difference in values of colou << 
808     }                                          << 
809   }                                            << 
810                                                << 
811   if (fSection) {                                 300   if (fSection) {
812     if (!(fSectionPlane == v.fSectionPlane))      301     if (!(fSectionPlane == v.fSectionPlane))
813       G4cout << "Difference in section planes     302       G4cout << "Difference in section planes batch." << G4endl;
814   }                                               303   }
815                                                   304 
816   if (IsCutaway()) {                              305   if (IsCutaway()) {
817     if (fCutawayPlanes.size () != v.fCutawayPl    306     if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
818       G4cout << "Difference in no of cutaway p    307       G4cout << "Difference in no of cutaway planes." << G4endl;
819     }                                             308     }
820     else {                                        309     else {
821       for (size_t i = 0; i < fCutawayPlanes.si    310       for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
822   if (!(fCutawayPlanes[i] == v.fCutawayPlanes[    311   if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
823     G4cout << "Difference in cutaway plane no.    312     G4cout << "Difference in cutaway plane no. " << i << G4endl;
824       }                                           313       }
825     }                                             314     }
826   }                                               315   }
827                                                   316 
828   if (IsExplode()) {                              317   if (IsExplode()) {
829     if (fExplodeFactor != v.fExplodeFactor)       318     if (fExplodeFactor != v.fExplodeFactor)
830       G4cout << "Difference in explode factor.    319       G4cout << "Difference in explode factor." << G4endl;
831     if (fExplodeCentre != v.fExplodeCentre)       320     if (fExplodeCentre != v.fExplodeCentre)
832       G4cout << "Difference in explode centre.    321       G4cout << "Difference in explode centre." << G4endl;
833   }                                               322   }
834                                                << 
835   if (fVisAttributesModifiers != v.fVisAttribu << 
836     G4cout << "Difference in vis attributes mo << 
837   }                                            << 
838                                                << 
839   if (fStartTime != v.fStartTime ||            << 
840       fEndTime   != v.fEndTime)  {             << 
841     G4cout << "Difference in time window." <<  << 
842   }                                            << 
843                                                << 
844   if (fFadeFactor != v.fFadeFactor) {          << 
845     G4cout << "Difference in time window fade  << 
846   }                                            << 
847                                                << 
848   if (fDisplayHeadTime != v.fDisplayHeadTime)  << 
849     G4cout << "Difference in display head time << 
850   } else {                                     << 
851     if (fDisplayHeadTimeX     != v.fDisplayHea << 
852         fDisplayHeadTimeY     != v.fDisplayHea << 
853         fDisplayHeadTimeSize  != v.fDisplayHea << 
854         fDisplayHeadTimeRed   != v.fDisplayHea << 
855         fDisplayHeadTimeGreen != v.fDisplayHea << 
856         fDisplayHeadTimeBlue  != v.fDisplayHea << 
857       G4cout << "Difference in display head ti << 
858     }                                          << 
859   }                                            << 
860                                                << 
861   if (fDisplayLightFront != v.fDisplayLightFro << 
862     G4cout << "Difference in display light fro << 
863   } else {                                     << 
864     if (fDisplayLightFrontX     != v.fDisplayL << 
865         fDisplayLightFrontY     != v.fDisplayL << 
866         fDisplayLightFrontZ     != v.fDisplayL << 
867         fDisplayLightFrontT     != v.fDisplayL << 
868         fDisplayLightFrontRed   != v.fDisplayL << 
869         fDisplayLightFrontGreen != v.fDisplayL << 
870         fDisplayLightFrontBlue  != v.fDisplayL << 
871       G4cout << "Difference in display light f << 
872     }                                          << 
873   }                                            << 
874 }                                                 323 }
875                                                   324 
876 std::ostream& operator <<                      << 325 std::ostream& operator << (std::ostream& os,
877  (std::ostream& os, G4ViewParameters::DrawingS << 326            const G4ViewParameters::DrawingStyle& style) {
878 {                                              << 
879   switch (style) {                                327   switch (style) {
880     case G4ViewParameters::wireframe:          << 328   case G4ViewParameters::wireframe:
881       os << "wireframe"; break;                << 329     os << "wireframe"; break;
882     case G4ViewParameters::hlr:                << 330   case G4ViewParameters::hlr:
883       os << "hlr - hidden lines removed"; brea << 331     os << "hlr - hidden lines removed"; break;
884     case G4ViewParameters::hsr:                << 332   case G4ViewParameters::hsr:
885       os << "hsr - hidden surfaces removed"; b << 333     os << "hsr - hidden surfaces removed"; break;
886     case G4ViewParameters::hlhsr:              << 334   case G4ViewParameters::hlhsr:
887       os << "hlhsr - hidden line, hidden surfa << 335     os << "hlhsr - hidden line, hidden surface removed"; break;
888     case G4ViewParameters::cloud:              << 336   default: os << "unrecognised"; break;
889       os << "cloud - draw volume as a cloud of << 
890     default: os << "unrecognised"; break;      << 
891   }                                            << 
892   return os;                                   << 
893 }                                              << 
894                                                << 
895 std::ostream& operator <<                      << 
896 (std::ostream& os, G4ViewParameters::SMROption << 
897 {                                              << 
898   switch (option) {                            << 
899     case G4ViewParameters::meshAsDefault:      << 
900       os << "default"; break;                  << 
901     case G4ViewParameters::meshAsDots:         << 
902       os << "dots"; break;                     << 
903     case G4ViewParameters::meshAsSurfaces:     << 
904       os << "surfaces"; break;                 << 
905   }                                               337   }
906   return os;                                      338   return os;
907 }                                                 339 }
908                                                   340 
909 std::ostream& operator << (std::ostream& os, c    341 std::ostream& operator << (std::ostream& os, const G4ViewParameters& v) {
910   os << "View parameters and options:";           342   os << "View parameters and options:";
911                                                   343 
912   os << "\n  Drawing style: " << v.fDrawingSty    344   os << "\n  Drawing style: " << v.fDrawingStyle;
913                                                   345 
914   os << "\n  Number of cloud points: " << v.fN << 
915                                                << 
916   os << "\n  Auxiliary edges: ";                  346   os << "\n  Auxiliary edges: ";
917   if (!v.fAuxEdgeVisible) os << "in";             347   if (!v.fAuxEdgeVisible) os << "in";
918   os << "visible";                                348   os << "visible";
919                                                   349 
                                                   >> 350   os << "\n  Representation style: ";
                                                   >> 351   switch (v.fRepStyle) {
                                                   >> 352   case G4ViewParameters::polyhedron:
                                                   >> 353     os << "polyhedron"; break;
                                                   >> 354   case G4ViewParameters::nurbs:
                                                   >> 355     os << "nurbs"; break;
                                                   >> 356   default: os << "unrecognised"; break;
                                                   >> 357   }
                                                   >> 358 
920   os << "\n  Culling: ";                          359   os << "\n  Culling: ";
921   if (v.fCulling) os << "on";                     360   if (v.fCulling) os << "on";
922   else            os << "off";                    361   else            os << "off";
923                                                   362 
924   os << "\n  Culling invisible objects: ";        363   os << "\n  Culling invisible objects: ";
925   if (v.fCullInvisible) os << "on";               364   if (v.fCullInvisible) os << "on";
926   else                  os << "off";              365   else                  os << "off";
927                                                   366 
928   os << "\n  Density culling: ";                  367   os << "\n  Density culling: ";
929   if (v.fDensityCulling) {                        368   if (v.fDensityCulling) {
930     os << "on - invisible if density less than    369     os << "on - invisible if density less than "
931        << v.fVisibleDensity / (1. * g / cm3) <    370        << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
932   }                                               371   }
933   else os << "off";                               372   else os << "off";
934                                                   373 
935   os << "\n  Culling daughters covered by opaq    374   os << "\n  Culling daughters covered by opaque mothers: ";
936   if (v.fCullCovered) os << "on";                 375   if (v.fCullCovered) os << "on";
937   else                os << "off";                376   else                os << "off";
938                                                   377 
939   os << "\n  Colour by density: ";             << 
940   if (v.fCBDAlgorithmNumber <= 0) {            << 
941     os << "inactive";                          << 
942   } else {                                     << 
943     os << "Algorithm " << v.fCBDAlgorithmNumbe << 
944     for (auto p: v.fCBDParameters) {           << 
945       os << ' ' << G4BestUnit(p,"Volumic Mass" << 
946     }                                          << 
947   }                                            << 
948                                                << 
949   os << "\n  Section flag: ";                     378   os << "\n  Section flag: ";
950   if (v.fSection) os << "true, section/cut pla    379   if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
951   else            os << "false";                  380   else            os << "false";
952                                                   381 
953   if (v.IsCutaway()) {                            382   if (v.IsCutaway()) {
954     os << "\n  Cutaway planes: ";                 383     os << "\n  Cutaway planes: ";
955     for (size_t i = 0; i < v.fCutawayPlanes.si    384     for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
956       os << ' ' << v.fCutawayPlanes[i];           385       os << ' ' << v.fCutawayPlanes[i];
957     }                                             386     }
958   }                                               387   }
959   else {                                          388   else {
960     os << "\n  No cutaway planes";                389     os << "\n  No cutaway planes";
961   }                                               390   }
962                                                   391 
963   os << "\n  Explode factor: " << v.fExplodeFa    392   os << "\n  Explode factor: " << v.fExplodeFactor
964      << " about centre: " << v.fExplodeCentre;    393      << " about centre: " << v.fExplodeCentre;
965                                                   394 
966   os << "\n  No. of sides used in circle polyg    395   os << "\n  No. of sides used in circle polygon approximation: "
967      << v.fNoOfSides;                             396      << v.fNoOfSides;
968                                                   397 
969   os << "\n  Viewpoint direction:  " << v.fVie    398   os << "\n  Viewpoint direction:  " << v.fViewpointDirection;
970                                                   399 
971   os << "\n  Up vector:            " << v.fUpV    400   os << "\n  Up vector:            " << v.fUpVector;
972                                                   401 
973   os << "\n  Field half angle:     " << v.fFie    402   os << "\n  Field half angle:     " << v.fFieldHalfAngle;
974                                                   403 
975   os << "\n  Zoom factor:          " << v.fZoo    404   os << "\n  Zoom factor:          " << v.fZoomFactor;
976                                                   405 
977   os << "\n  Scale factor:         " << v.fSca    406   os << "\n  Scale factor:         " << v.fScaleFactor;
978                                                   407 
979   os << "\n  Current target point: " << v.fCur    408   os << "\n  Current target point: " << v.fCurrentTargetPoint;
980                                                   409 
981   os << "\n  Dolly distance:       " << v.fDol    410   os << "\n  Dolly distance:       " << v.fDolly;
982                                                   411 
983   os << "\n  Light ";                             412   os << "\n  Light ";
984   if (v.fLightsMoveWithCamera) os << "moves";     413   if (v.fLightsMoveWithCamera) os << "moves";
985   else                         os << "does not    414   else                         os << "does not move";
986   os << " with camera";                           415   os << " with camera";
987                                                   416 
988   os << "\n  Relative lightpoint direction: "     417   os << "\n  Relative lightpoint direction: "
989      << v.fRelativeLightpointDirection;           418      << v.fRelativeLightpointDirection;
990                                                   419 
991   os << "\n  Actual lightpoint direction: "       420   os << "\n  Actual lightpoint direction: "
992      << v.fActualLightpointDirection;             421      << v.fActualLightpointDirection;
993                                                   422 
994   os << "\n  Derived parameters for standard v    423   os << "\n  Derived parameters for standard view of object of unit radius:";
995   G4ViewParameters tempVP = v;                    424   G4ViewParameters tempVP = v;
996   tempVP.fDolly = 0.;                             425   tempVP.fDolly = 0.;
997   tempVP.fZoomFactor = 1.;                        426   tempVP.fZoomFactor = 1.;
998   const G4double radius = 1.;                     427   const G4double radius = 1.;
999   const G4double cameraDistance = tempVP.GetCa    428   const G4double cameraDistance = tempVP.GetCameraDistance (radius);
1000   const G4double nearDistance =                  429   const G4double nearDistance =
1001     tempVP.GetNearDistance (cameraDistance, r    430     tempVP.GetNearDistance (cameraDistance, radius);
1002   const G4double farDistance =                   431   const G4double farDistance =
1003     tempVP.GetFarDistance  (cameraDistance, n    432     tempVP.GetFarDistance  (cameraDistance, nearDistance, radius);
1004   const G4double right  = tempVP.GetFrontHalf    433   const G4double right  = tempVP.GetFrontHalfHeight (nearDistance, radius);
1005   os << "\n    Camera distance:   " << camera    434   os << "\n    Camera distance:   " << cameraDistance;
1006   os << "\n    Near distance:     " << nearDi    435   os << "\n    Near distance:     " << nearDistance;
1007   os << "\n    Far distance:      " << farDis    436   os << "\n    Far distance:      " << farDistance;
1008   os << "\n    Front half height: " << right;    437   os << "\n    Front half height: " << right;
1009                                                  438 
1010   os << "\n  Default VisAttributes:\n  " << v    439   os << "\n  Default VisAttributes:\n  " << v.fDefaultVisAttributes;
1011                                                  440 
1012   os << "\n  Default TextVisAttributes:\n  "     441   os << "\n  Default TextVisAttributes:\n  " << v.fDefaultTextVisAttributes;
1013                                                  442 
1014   os << "\n  Default marker:\n    " << v.fDef << 443   os << "\n  Default marker: " << v.fDefaultMarker;
1015                                                  444 
1016   os << "\n  Global marker scale: " << v.fGlo    445   os << "\n  Global marker scale: " << v.fGlobalMarkerScale;
1017                                                  446 
1018   os << "\n  Global lineWidth scale: " << v.f    447   os << "\n  Global lineWidth scale: " << v.fGlobalLineWidthScale;
1019                                                  448 
1020   os << "\n  Marker ";                           449   os << "\n  Marker ";
1021   if (v.fMarkerNotHidden) os << "not ";          450   if (v.fMarkerNotHidden) os << "not ";
1022   os << "hidden by surfaces.";                   451   os << "hidden by surfaces.";
1023                                                  452 
1024   os << "\n  Window size hint: "                 453   os << "\n  Window size hint: "
1025      << v.fWindowSizeHintX << 'x'<< v.fWindow    454      << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
1026                                                  455 
1027   os << "\n  X geometry string: " << v.fXGeom    456   os << "\n  X geometry string: " << v.fXGeometryString;
1028   os << "\n  X geometry mask: "               << 
1029      << std::showbase << std::hex << v.fGeome << 
1030      << std::noshowbase << std::dec;          << 
1031                                                  457 
1032   os << "\n  Auto refresh: ";                    458   os << "\n  Auto refresh: ";
1033   if (v.fAutoRefresh) os << "true";              459   if (v.fAutoRefresh) os << "true";
1034   else os << "false";                            460   else os << "false";
1035                                                  461 
1036   os << "\n  Background colour: " << v.fBackg    462   os << "\n  Background colour: " << v.fBackgroundColour;
1037                                                  463 
1038   os << "\n  Picking requested: ";               464   os << "\n  Picking requested: ";
1039   if (v.fPicking) os << "true";                  465   if (v.fPicking) os << "true";
1040   else os << "false";                            466   else os << "false";
1041                                                  467 
1042   os << "\n  Rotation style: ";               << 
1043   switch (v.fRotationStyle) {                 << 
1044   case G4ViewParameters::constrainUpDirection << 
1045     os << "constrainUpDirection (conventional << 
1046   case G4ViewParameters::freeRotation:        << 
1047     os << "freeRotation (Google-like rotation << 
1048   default: os << "unrecognised"; break;       << 
1049   }                                           << 
1050                                               << 
1051   os << "\nVis attributes modifiers: ";       << 
1052   const std::vector<G4ModelingParameters::Vis << 
1053     v.fVisAttributesModifiers;                << 
1054   if (vams.empty()) {                         << 
1055     os << "None";                             << 
1056   } else {                                    << 
1057     os << vams;                               << 
1058   }                                           << 
1059                                               << 
1060   os << "\nTime window parameters:"           << 
1061   << "\n  Start time:  " << v.fStartTime/ns < << 
1062   << "\n  End time:    " << v.fEndTime/ns <<  << 
1063   << "\n  Fade factor: " << v.fFadeFactor;    << 
1064   if (!v.fDisplayHeadTime) {                  << 
1065     os << "\n  Head time display not requeste << 
1066   } else {                                    << 
1067     os                                        << 
1068     << "\n  Head time position: "             << 
1069     << v.fDisplayHeadTimeX << ' ' << v.fDispl << 
1070     << "\n  Head time size:     " << v.fDispl << 
1071     << "\n  Head time colour:   " << v.fDispl << 
1072     << ' ' << v.fDisplayHeadTimeGreen << ' '  << 
1073   }                                           << 
1074   if (!v.fDisplayLightFront) {                << 
1075     os << "\n  Light front display not reques << 
1076   } else {                                    << 
1077     os                                        << 
1078     << "\n  Light front position: "           << 
1079     << v.fDisplayLightFrontX/mm << ' ' << v.f << 
1080     << ' ' << v.fDisplayLightFrontZ/mm << " m << 
1081     << "\n  Light front time:     " << v.fDis << 
1082     << "\n  Light front colour:   " << v.fDis << 
1083     << ' ' << v.fDisplayLightFrontGreen << '  << 
1084   }                                           << 
1085                                               << 
1086   os << "\nSpecial Mesh Rendering";           << 
1087   if (v.fSpecialMeshRendering) {              << 
1088     os << " requested with option \"" << v.fS << 
1089     os << "\" for ";                          << 
1090     if (v.fSpecialMeshVolumes.empty()) {      << 
1091       os << "any mesh";                       << 
1092     } else {                                  << 
1093       os << "selected meshes";                << 
1094       for (const auto& vol: v.fSpecialMeshVol << 
1095   os << "\n    " << vol.GetName() << ':' << v << 
1096       }                                       << 
1097     }                                         << 
1098   } else os << ": off";                       << 
1099   return os;                                     468   return os;
1100 }                                                469 }
1101                                                  470 
1102 G4bool G4ViewParameters::operator != (const G    471 G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
1103                                                  472 
1104   // Put performance-sensitive parameters fir    473   // Put performance-sensitive parameters first.
1105   if (                                           474   if (
1106       // This first to optimise spin, etc.       475       // This first to optimise spin, etc.
1107       (fViewpointDirection   != v.fViewpointD    476       (fViewpointDirection   != v.fViewpointDirection)   ||
1108                                                  477 
1109       // No particular order from here on.       478       // No particular order from here on.
1110       (fDrawingStyle         != v.fDrawingSty    479       (fDrawingStyle         != v.fDrawingStyle)         ||
1111       (fNumberOfCloudPoints  != v.fNumberOfCl << 
1112       (fAuxEdgeVisible       != v.fAuxEdgeVis    480       (fAuxEdgeVisible       != v.fAuxEdgeVisible)       ||
                                                   >> 481       (fRepStyle             != v.fRepStyle)             ||
1113       (fCulling              != v.fCulling)      482       (fCulling              != v.fCulling)              ||
1114       (fCullInvisible        != v.fCullInvisi    483       (fCullInvisible        != v.fCullInvisible)        ||
1115       (fDensityCulling       != v.fDensityCul    484       (fDensityCulling       != v.fDensityCulling)       ||
1116       (fCullCovered          != v.fCullCovere    485       (fCullCovered          != v.fCullCovered)          ||
1117       (fCBDAlgorithmNumber   != v.fCBDAlgorit << 
1118       (fSection              != v.fSection)      486       (fSection              != v.fSection)              ||
1119       (IsCutaway()           != v.IsCutaway()    487       (IsCutaway()           != v.IsCutaway())           ||
1120       (IsExplode()           != v.IsExplode()    488       (IsExplode()           != v.IsExplode())           ||
1121       (fNoOfSides            != v.fNoOfSides)    489       (fNoOfSides            != v.fNoOfSides)            ||
1122       (fUpVector             != v.fUpVector)     490       (fUpVector             != v.fUpVector)             ||
1123       (fFieldHalfAngle       != v.fFieldHalfA    491       (fFieldHalfAngle       != v.fFieldHalfAngle)       ||
1124       (fZoomFactor           != v.fZoomFactor    492       (fZoomFactor           != v.fZoomFactor)           ||
1125       (fScaleFactor          != v.fScaleFacto    493       (fScaleFactor          != v.fScaleFactor)          ||
1126       (fCurrentTargetPoint   != v.fCurrentTar    494       (fCurrentTargetPoint   != v.fCurrentTargetPoint)   ||
1127       (fDolly                != v.fDolly)        495       (fDolly                != v.fDolly)                ||
1128       (fRelativeLightpointDirection != v.fRel    496       (fRelativeLightpointDirection != v.fRelativeLightpointDirection)  ||
1129       (fLightsMoveWithCamera != v.fLightsMove    497       (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
1130       (fDefaultVisAttributes != v.fDefaultVis    498       (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
1131       (fDefaultTextVisAttributes != v.fDefaul    499       (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
1132       (fDefaultMarker        != v.fDefaultMar    500       (fDefaultMarker        != v.fDefaultMarker)        ||
1133       (fGlobalMarkerScale    != v.fGlobalMark    501       (fGlobalMarkerScale    != v.fGlobalMarkerScale)    ||
1134       (fGlobalLineWidthScale != v.fGlobalLine    502       (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
1135       (fMarkerNotHidden      != v.fMarkerNotH    503       (fMarkerNotHidden      != v.fMarkerNotHidden)      ||
1136       (fWindowSizeHintX      != v.fWindowSize    504       (fWindowSizeHintX      != v.fWindowSizeHintX)      ||
1137       (fWindowSizeHintY      != v.fWindowSize    505       (fWindowSizeHintY      != v.fWindowSizeHintY)      ||
1138       (fXGeometryString      != v.fXGeometryS    506       (fXGeometryString      != v.fXGeometryString)      ||
1139       (fGeometryMask         != v.fGeometryMa << 
1140       (fAutoRefresh          != v.fAutoRefres    507       (fAutoRefresh          != v.fAutoRefresh)          ||
1141       (fBackgroundColour     != v.fBackground    508       (fBackgroundColour     != v.fBackgroundColour)     ||
1142       (fPicking              != v.fPicking)   << 509       (fPicking              != v.fPicking)
1143       (fRotationStyle        != v.fRotationSt << 
1144       (fSpecialMeshRendering != v.fSpecialMes << 
1145       (fSpecialMeshRenderingOption != v.fSpec << 
1146       )                                          510       )
1147     return true;                                 511     return true;
1148                                                  512 
1149   if (fDensityCulling &&                         513   if (fDensityCulling &&
1150       (fVisibleDensity != v.fVisibleDensity))    514       (fVisibleDensity != v.fVisibleDensity)) return true;
1151                                                  515 
1152   if (fCBDAlgorithmNumber > 0) {              << 
1153     if (fCBDParameters.size() != v.fCBDParame << 
1154     else if (fCBDParameters != v.fCBDParamete << 
1155   }                                           << 
1156                                               << 
1157   if (fSection &&                                516   if (fSection &&
1158       (!(fSectionPlane == v.fSectionPlane)))     517       (!(fSectionPlane == v.fSectionPlane))) return true;
1159                                                  518 
1160   if (IsCutaway()) {                             519   if (IsCutaway()) {
1161     if (fCutawayPlanes.size () != v.fCutawayP    520     if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
1162       return true;                               521       return true;
1163     else {                                       522     else {
1164       for (size_t i = 0; i < fCutawayPlanes.s    523       for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
1165   if (!(fCutawayPlanes[i] == v.fCutawayPlanes    524   if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
1166       }                                          525       }
1167     }                                            526     }
1168   }                                              527   }
1169                                                  528 
1170   if (IsExplode() &&                             529   if (IsExplode() &&
1171       ((fExplodeFactor != v.fExplodeFactor) |    530       ((fExplodeFactor != v.fExplodeFactor) ||
1172        (fExplodeCentre != v.fExplodeCentre)))    531        (fExplodeCentre != v.fExplodeCentre))) return true;
1173                                                  532 
1174   if (fVisAttributesModifiers != v.fVisAttrib << 533   return false;
1175                                               << 534 }
1176   if (fStartTime  != v.fStartTime ||          << 
1177       fEndTime    != v.fEndTime   ||          << 
1178       fFadeFactor != v.fFadeFactor) return tr << 
1179                                               << 
1180   if (fDisplayHeadTime != v.fDisplayHeadTime) << 
1181   if (fDisplayHeadTime) {                     << 
1182     if (fDisplayHeadTimeX     != v.fDisplayHe << 
1183         fDisplayHeadTimeY     != v.fDisplayHe << 
1184         fDisplayHeadTimeSize  != v.fDisplayHe << 
1185         fDisplayHeadTimeRed   != v.fDisplayHe << 
1186         fDisplayHeadTimeGreen != v.fDisplayHe << 
1187         fDisplayHeadTimeBlue  != v.fDisplayHe << 
1188       return true;                            << 
1189     }                                         << 
1190   }                                           << 
1191                                                  535 
1192   if (fDisplayLightFront != v.fDisplayLightFr << 
1193   if (fDisplayLightFront) {                   << 
1194     if (fDisplayLightFrontX     != v.fDisplay << 
1195         fDisplayLightFrontY     != v.fDisplay << 
1196         fDisplayLightFrontZ     != v.fDisplay << 
1197         fDisplayLightFrontT     != v.fDisplay << 
1198         fDisplayLightFrontRed   != v.fDisplay << 
1199         fDisplayLightFrontGreen != v.fDisplay << 
1200         fDisplayLightFrontBlue  != v.fDisplay << 
1201       return true;                            << 
1202     }                                         << 
1203   }                                           << 
1204                                                  536 
1205   if (fSpecialMeshRendering) {                << 537 void G4ViewParameters::SetXGeometryString (const G4String& geomStringArg) {
1206     if (fSpecialMeshVolumes != v.fSpecialMesh << 
1207       return true;;                           << 
1208   }                                           << 
1209                                                  538 
1210   return false;                               << 
1211 }                                             << 
1212                                                  539 
1213 void G4ViewParameters::SetXGeometryString (co << 540   G4int x,y = 0;
1214 {                                             << 541   unsigned int w,h = 0;
                                                   >> 542   G4String geomString = geomStringArg;
                                                   >> 543   // Parse windowSizeHintString for backwards compatibility...
1215   const G4String delimiters("xX+-");             544   const G4String delimiters("xX+-");
1216   G4String::size_type i = geomString.find_fir    545   G4String::size_type i = geomString.find_first_of(delimiters);
1217   if (i == G4String::npos) {                  << 546   if (i == G4String::npos) {  // Does not contain "xX+-".  Assume single number
1218     // Does not contain "xX+-".               << 
1219     // Is it a single number?                 << 
1220     std::istringstream iss(geomString);          547     std::istringstream iss(geomString);
1221     G4int size;                                  548     G4int size;
1222     iss >> size;                                 549     iss >> size;
1223     if (iss) {                                << 550     if (!iss) {
1224       // It is a number                       << 551       size = 600;
1225       fWindowSizeHintX = size;                << 552       G4cout << "Unrecognised windowSizeHint string: \""
1226       fWindowSizeHintY = size;                << 553        << geomString
                                                   >> 554        << "\".  Asuuming " << size << G4endl;
1227     }                                            555     }
1228     // Accept other or all defaults (in G4Vie << 
1229     // Reconstruct a geometry string coherent << 
1230     char signX, signY;                        << 
1231     if (fWindowLocationHintXNegative) signX = << 
1232     if (fWindowLocationHintYNegative) signY = << 
1233     std::ostringstream oss;                      556     std::ostringstream oss;
1234     oss << fWindowSizeHintX << 'x' << fWindow << 557     oss << size << 'x' << size;
1235     << signX << fWindowLocationHintX << signY << 558     geomString = oss.str();
1236     fXGeometryString = oss.str();             << 
1237     return;                                   << 
1238   }                                              559   }
1239                                               << 560  
1240   // Assume it's a parseable X geometry strin << 
1241   G4int x = 0, y = 0;                         << 
1242   unsigned int w = 0, h = 0;                  << 
1243   fGeometryMask = ParseGeometry( geomString,     561   fGeometryMask = ParseGeometry( geomString, &x, &y, &w, &h );
1244                                                  562 
1245   // Handle special case :                       563   // Handle special case :
1246   if ((fGeometryMask & fYValue) == 0)            564   if ((fGeometryMask & fYValue) == 0)
1247     {  // Using default                          565     {  // Using default
1248       y =  fWindowLocationHintY;                 566       y =  fWindowLocationHintY;
1249     }                                            567     }
1250   if ((fGeometryMask & fXValue) == 0)            568   if ((fGeometryMask & fXValue) == 0)
1251     {  // Using default                          569     {  // Using default
1252       x =  fWindowLocationHintX;                 570       x =  fWindowLocationHintX;
1253     }                                            571     }
1254                                                  572 
1255   // Check errors                                573   // Check errors
1256   // if there is no Width and Height             574   // if there is no Width and Height
1257   if ( ((fGeometryMask & fHeightValue) == 0 )    575   if ( ((fGeometryMask & fHeightValue) == 0 ) &&
1258        ((fGeometryMask & fWidthValue)  == 0 )    576        ((fGeometryMask & fWidthValue)  == 0 )) {
1259     h = fWindowSizeHintY;                        577     h = fWindowSizeHintY;
1260     w = fWindowSizeHintX;                        578     w = fWindowSizeHintX;
1261   } else  if ((fGeometryMask & fHeightValue)     579   } else  if ((fGeometryMask & fHeightValue) == 0 ) {
1262                                                  580 
1263     // if there is only Width. Special case t    581     // if there is only Width. Special case to be backward compatible
1264     // We set Width and Height the same to ob    582     // We set Width and Height the same to obtain a square windows.
1265                                                  583     
1266     G4warn << "Unrecognised geometry string \ << 584     G4cout << "Unrecognised geometry string \""
1267            << geomString                         585            << geomString
1268            << "\".  No Height found. Using Wi    586            << "\".  No Height found. Using Width value instead"
1269            << G4endl;                            587            << G4endl;
1270     h = w;                                       588     h = w;
1271   }                                              589   }
1272   if ( ((fGeometryMask & fXValue) == 0 ) ||      590   if ( ((fGeometryMask & fXValue) == 0 ) ||
1273        ((fGeometryMask & fYValue)  == 0 )) {     591        ((fGeometryMask & fYValue)  == 0 )) {
1274     //Using defaults                             592     //Using defaults
1275     x = fWindowLocationHintX;                    593     x = fWindowLocationHintX;
1276     y = fWindowLocationHintY;                    594     y = fWindowLocationHintY;
1277   }                                              595   }
1278   // Set the string                              596   // Set the string
1279   fXGeometryString = geomString;                 597   fXGeometryString = geomString;
1280                                                  598   
1281   // Set values                                  599   // Set values
1282   fWindowSizeHintX = w;                          600   fWindowSizeHintX = w;
1283   fWindowSizeHintY = h;                          601   fWindowSizeHintY = h;
1284   fWindowLocationHintX = x;                      602   fWindowLocationHintX = x;
1285   fWindowLocationHintY = y;                      603   fWindowLocationHintY = y;
1286                                                  604 
1287   if ( ((fGeometryMask & fXValue)) &&            605   if ( ((fGeometryMask & fXValue)) &&
1288        ((fGeometryMask & fYValue))) {            606        ((fGeometryMask & fYValue))) {
1289                                                  607 
1290     if ( (fGeometryMask & fXNegative) ) {        608     if ( (fGeometryMask & fXNegative) ) {
1291       fWindowLocationHintXNegative = true;       609       fWindowLocationHintXNegative = true;
1292     } else {                                     610     } else {
1293       fWindowLocationHintXNegative = false;      611       fWindowLocationHintXNegative = false;
1294     }                                            612     }
1295     if ( (fGeometryMask & fYNegative) ) {        613     if ( (fGeometryMask & fYNegative) ) {
1296     fWindowLocationHintYNegative = true;         614     fWindowLocationHintYNegative = true;
1297     } else {                                     615     } else {
1298       fWindowLocationHintYNegative = false;      616       fWindowLocationHintYNegative = false;
1299     }                                            617     }
1300   }                                              618   }
1301 }                                                619 }
1302                                                  620 
1303 G4int G4ViewParameters::GetWindowAbsoluteLoca    621 G4int G4ViewParameters::GetWindowAbsoluteLocationHintX (G4int sizeX ) const {
1304   if ( fWindowLocationHintXNegative ) {          622   if ( fWindowLocationHintXNegative ) {
1305     return  sizeX  + fWindowLocationHintX - f    623     return  sizeX  + fWindowLocationHintX - fWindowSizeHintX;
1306   }                                              624   }
1307   return fWindowLocationHintX;                   625   return fWindowLocationHintX;
1308 }                                                626 }
1309                                                  627 
1310 G4int G4ViewParameters::GetWindowAbsoluteLoca    628 G4int G4ViewParameters::GetWindowAbsoluteLocationHintY (G4int sizeY ) const {
1311   if (  fWindowLocationHintYNegative ) {         629   if (  fWindowLocationHintYNegative ) {
1312     return  sizeY  + fWindowLocationHintY - f    630     return  sizeY  + fWindowLocationHintY - fWindowSizeHintY;
1313   }                                              631   }
1314   return fWindowLocationHintY;                   632   return fWindowLocationHintY;
1315 }                                                633 }
1316                                                  634 
1317 /* Keep from :                                   635 /* Keep from :
1318  * ftp://ftp.trolltech.com/qt/source/qt-embed    636  * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
1319  *                                               637  *
1320  *    ParseGeometry parses strings of the for    638  *    ParseGeometry parses strings of the form
1321  *   "=<width>x<height>{+-}<xoffset>{+-}<yoff    639  *   "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
1322  *   width, height, xoffset, and yoffset are     640  *   width, height, xoffset, and yoffset are unsigned integers.
1323  *   Example:  "=80x24+300-49"                   641  *   Example:  "=80x24+300-49"
1324  *   The equal sign is optional.                 642  *   The equal sign is optional.
1325  *   It returns a bitmask that indicates whic    643  *   It returns a bitmask that indicates which of the four values
1326  *   were actually found in the string. For e    644  *   were actually found in the string. For each value found,
1327  *   the corresponding argument is updated;      645  *   the corresponding argument is updated;  for each value
1328  *   not found, the corresponding argument is    646  *   not found, the corresponding argument is left unchanged.
1329  */                                              647  */
1330                                                  648 
1331 int G4ViewParameters::ParseGeometry (            649 int G4ViewParameters::ParseGeometry (
1332  const char *string,                             650  const char *string,
1333  G4int *x,                                       651  G4int *x,
1334  G4int *y,                                       652  G4int *y,
1335  unsigned int *width,                            653  unsigned int *width,
1336  unsigned int *height)                           654  unsigned int *height)
1337 {                                                655 {
1338                                                  656 
1339   G4int mask = fNoValue;                         657   G4int mask = fNoValue;
1340   char *strind;                               << 658   register char *strind;
1341   unsigned int tempWidth  = 0;                   659   unsigned int tempWidth  = 0;
1342   unsigned int tempHeight = 0;                   660   unsigned int tempHeight = 0;
1343   G4int tempX = 0;                               661   G4int tempX = 0;
1344   G4int tempY = 0;                               662   G4int tempY = 0;
1345   char *nextCharacter;                           663   char *nextCharacter;
1346   if ( (string == NULL) || (*string == '\0'))    664   if ( (string == NULL) || (*string == '\0')) {
1347     return(mask);                                665     return(mask);
1348   }                                              666   }
1349   if (*string == '=')                            667   if (*string == '=')
1350     string++;  /* ignore possible '=' at beg     668     string++;  /* ignore possible '=' at beg of geometry spec */
1351   strind = (char *)string;                       669   strind = (char *)string;
1352   if (*strind != '+' && *strind != '-' && *st    670   if (*strind != '+' && *strind != '-' && *strind != 'x') {
1353     tempWidth = ReadInteger(strind, &nextChar    671     tempWidth = ReadInteger(strind, &nextCharacter);
1354     if (strind == nextCharacter)                 672     if (strind == nextCharacter)
1355       return (0);                                673       return (0);
1356     strind = nextCharacter;                      674     strind = nextCharacter;
1357     mask |= fWidthValue;                         675     mask |= fWidthValue;
1358   }                                              676   }
1359   if (*strind == 'x' || *strind == 'X') {        677   if (*strind == 'x' || *strind == 'X') {
1360     strind++;                                    678     strind++;
1361     tempHeight = ReadInteger(strind, &nextCha    679     tempHeight = ReadInteger(strind, &nextCharacter);
1362     if (strind == nextCharacter)                 680     if (strind == nextCharacter)
1363       return (0);                                681       return (0);
1364     strind = nextCharacter;                      682     strind = nextCharacter;
1365     mask |= fHeightValue;                        683     mask |= fHeightValue;
1366   }                                              684   }
1367                                                  685 
1368   if ((*strind == '+') || (*strind == '-')) {    686   if ((*strind == '+') || (*strind == '-')) {
1369     if (*strind == '-') {                        687     if (*strind == '-') {
1370       strind++;                                  688       strind++;
1371       tempX = -ReadInteger(strind, &nextChara    689       tempX = -ReadInteger(strind, &nextCharacter);
1372       if (strind == nextCharacter)               690       if (strind == nextCharacter)
1373         return (0);                              691         return (0);
1374       strind = nextCharacter;                    692       strind = nextCharacter;
1375       mask |= fXNegative;                        693       mask |= fXNegative;
1376                                                  694 
1377     }                                            695     }
1378     else                                         696     else
1379       { strind++;                                697       { strind++;
1380         tempX = ReadInteger(strind, &nextChar    698         tempX = ReadInteger(strind, &nextCharacter);
1381         if (strind == nextCharacter)             699         if (strind == nextCharacter)
1382           return(0);                             700           return(0);
1383         strind = nextCharacter;                  701         strind = nextCharacter;
1384       }                                          702       }
1385     mask |= fXValue;                             703     mask |= fXValue;
1386     if ((*strind == '+') || (*strind == '-'))    704     if ((*strind == '+') || (*strind == '-')) {
1387       if (*strind == '-') {                      705       if (*strind == '-') {
1388         strind++;                                706         strind++;
1389         tempY = -ReadInteger(strind, &nextCha    707         tempY = -ReadInteger(strind, &nextCharacter);
1390         if (strind == nextCharacter)             708         if (strind == nextCharacter)
1391           return(0);                             709           return(0);
1392         strind = nextCharacter;                  710         strind = nextCharacter;
1393         mask |= fYNegative;                      711         mask |= fYNegative;
1394       }                                          712       }
1395       else                                       713       else
1396         {                                        714         {
1397           strind++;                              715           strind++;
1398           tempY = ReadInteger(strind, &nextCh    716           tempY = ReadInteger(strind, &nextCharacter);
1399           if (strind == nextCharacter)           717           if (strind == nextCharacter)
1400             return(0);                           718             return(0);
1401           strind = nextCharacter;                719           strind = nextCharacter;
1402         }                                        720         }
1403       mask |= fYValue;                           721       mask |= fYValue;
1404     }                                            722     }
1405   }                                              723   }
1406   /* If strind isn't at the end of the string    724   /* If strind isn't at the end of the string the it's an invalid
1407      geometry specification. */                  725      geometry specification. */
1408   if (*strind != '\0') return (0);               726   if (*strind != '\0') return (0);
1409   if (mask & fXValue)                            727   if (mask & fXValue)
1410     *x = tempX;                                  728     *x = tempX;
1411   if (mask & fYValue)                            729   if (mask & fYValue)
1412     *y = tempY;                                  730     *y = tempY;
1413   if (mask & fWidthValue)                        731   if (mask & fWidthValue)
1414     *width = tempWidth;                          732     *width = tempWidth;
1415   if (mask & fHeightValue)                       733   if (mask & fHeightValue)
1416     *height = tempHeight;                        734     *height = tempHeight;
1417   return (mask);                                 735   return (mask);
1418 }                                                736 }
1419                                                  737 
1420 /* Keep from :                                   738 /* Keep from :
1421  * ftp://ftp.trolltech.com/qt/source/qt-embed    739  * ftp://ftp.trolltech.com/qt/source/qt-embedded-free-3.0.6.tar.gz/qt-embedded-free-3.0.6/src/kernel/qapplication_qws.cpp
1422  *                                               740  *
1423  */                                              741  */
1424 G4int G4ViewParameters::ReadInteger(char *str    742 G4int G4ViewParameters::ReadInteger(char *string, char **NextString)
1425 {                                                743 {
1426     G4int Result = 0;                         << 744     register G4int Result = 0;
1427     G4int Sign = 1;                              745     G4int Sign = 1;
1428                                                  746 
1429     if (*string == '+')                          747     if (*string == '+')
1430   string++;                                      748   string++;
1431     else if (*string == '-')                     749     else if (*string == '-')
1432     {                                            750     {
1433   string++;                                      751   string++;
1434   Sign = -1;                                     752   Sign = -1;
1435     }                                            753     }
1436     for (; (*string >= '0') && (*string <= '9    754     for (; (*string >= '0') && (*string <= '9'); string++)
1437     {                                            755     {
1438   Result = (Result * 10) + (*string - '0');      756   Result = (Result * 10) + (*string - '0');
1439     }                                            757     }
1440     *NextString = string;                        758     *NextString = string;
1441     if (Sign >= 0)                               759     if (Sign >= 0)
1442   return (Result);                               760   return (Result);
1443     else                                         761     else
1444   return (-Result);                              762   return (-Result);
1445 }                                                763 }
1446                                               << 764    
1447 G4ViewParameters* G4ViewParameters::CatmullRo << 
1448 (const std::vector<G4ViewParameters>& views,  << 
1449  G4int nInterpolationPoints)  // No of interp << 
1450 {                                             << 
1451   // Returns a null pointer when no more to b << 
1452   // do {                                     << 
1453   //   G4ViewParameters* vp =                 << 
1454   //   G4ViewParameters::CatmullRomCubicSplin << 
1455   //   if (!vp) break;                        << 
1456   //     ...                                  << 
1457   // } while (true);                          << 
1458                                               << 
1459   // See https://en.wikipedia.org/wiki/Cubic_ << 
1460                                               << 
1461   // Assumes equal intervals                  << 
1462                                               << 
1463   if (views.size() < 2) {                     << 
1464     G4Exception                               << 
1465     ("G4ViewParameters::CatmullRomCubicSpline << 
1466      "visman0301", JustWarning,               << 
1467      "There must be at least two views.");    << 
1468     return 0;                                 << 
1469   }                                           << 
1470                                               << 
1471   if (nInterpolationPoints < 1) {             << 
1472     G4Exception                               << 
1473     ("G4ViewParameters::CatmullRomCubicSpline << 
1474      "visman0302", JustWarning,               << 
1475      "Number of interpolation points cannot b << 
1476     return 0;                                 << 
1477   }                                           << 
1478                                               << 
1479   const size_t nIntervals = views.size() - 1; << 
1480   const G4double dt = 1./nInterpolationPoints << 
1481                                               << 
1482   static G4ViewParameters holdingValues;      << 
1483   static G4double t = 0.;  // 0. <= t <= 1.   << 
1484   static G4int iInterpolationPoint = 0;       << 
1485   static size_t iInterval = 0;                << 
1486                                               << 
1487 //  G4cout << "Interval " << iInterval << ",  << 
1488                                               << 
1489   // Hermite polynomials.                     << 
1490   const G4double h00 = 2.*t*t*t - 3.*t*t +1;  << 
1491   const G4double h10 = t*t*t -2.*t*t + t;     << 
1492   const G4double h01 = -2.*t*t*t + 3.*t*t;    << 
1493   const G4double h11 = t*t*t - t*t;           << 
1494                                               << 
1495   // Aliases (to simplify code)               << 
1496   const size_t& n = nIntervals;               << 
1497   size_t& i = iInterval;                      << 
1498   const std::vector<G4ViewParameters>& v = vi << 
1499                                               << 
1500   // The Catmull-Rom cubic spline prescriptio << 
1501   // Slope at first way point is v[1] - v[0]. << 
1502   // Slope at last way point is v[n] - v[n-1] << 
1503   // Otherwise slope at way point i is 0.5*(v << 
1504   // Result = h00*v[i] + h10*m[i] + h01*v[i+1 << 
1505   // where m[i] amd m[i+1] are the slopes at  << 
1506   // of the interval for the particular value << 
1507   // If (n == 1), linear interpolation result << 
1508   // If (n == 2), quadratic interpolation res << 
1509                                               << 
1510   // Working variables                        << 
1511   G4double mi, mi1, real, x, y, z;            << 
1512                                               << 
1513   // First, a crude interpolation of all para << 
1514   // smooth interpolation of those for which  << 
1515   holdingValues = t < 0.5? v[i]: v[i+1];      << 
1516                                               << 
1517   // Catmull-Rom cubic spline interpolation   << 
1518 #define INTERPOLATE(param) \                  << 
1519 /* This works out the interpolated param in i << 
1520 /* Assumes n >= 1 */ \                        << 
1521 if (i == 0) { \                               << 
1522 /* First interval */ \                        << 
1523 mi = v[1].param - v[0].param; \               << 
1524 /* If there is only one interval, make start  << 
1525 /* (This results in a linear interpolation) * << 
1526 if (n == 1) mi1 = mi; \                       << 
1527 /* else the end slope of the interval takes a << 
1528 else mi1 = 0.5 * (v[2].param - v[0].param); \ << 
1529 } else if (i >= n - 1) { \                    << 
1530 /* Similarly for last interval */ \           << 
1531 mi1 = v[i+1].param - v[i].param; \            << 
1532 /* If there is only one interval, make start  << 
1533 if (n == 1) mi = mi1; \                       << 
1534 /* else the start slope of the interval takes << 
1535 else mi = 0.5 * (v[i+1].param - v[i-1].param) << 
1536 } else { \                                    << 
1537 /* Full Catmull-Rom slopes use previous AND n << 
1538 mi  = 0.5 * (v[i+1].param - v[i-1].param); \  << 
1539 mi1 = 0.5 * (v[i+2].param - v[i  ].param); \  << 
1540 } \                                           << 
1541 real = h00 * v[i].param + h10 * mi + h01 * v[ << 
1542                                               << 
1543 #define INTERPOLATELOG(param) \               << 
1544 if (i == 0) { \                               << 
1545 mi = std::log(v[1].param) - std::log(v[0].par << 
1546 if (n == 1) mi1 = mi; \                       << 
1547 else mi1 = 0.5 * (std::log(v[2].param) - std: << 
1548 } else if (i >= n - 1) { \                    << 
1549 mi1 = std::log(v[i+1].param) - std::log(v[i]. << 
1550 if (n == 1) mi = mi1; \                       << 
1551 else mi = 0.5 * (std::log(v[i+1].param) - std << 
1552 } else { \                                    << 
1553 mi  = 0.5 * (std::log(v[i+1].param) - std::lo << 
1554 mi1 = 0.5 * (std::log(v[i+2].param) - std::lo << 
1555 } \                                           << 
1556 real = std::exp(h00 * std::log(v[i].param) +  << 
1557                                               << 
1558   // Real parameters                          << 
1559   INTERPOLATE(fVisibleDensity);               << 
1560   if (real < 0.) real = 0.;                   << 
1561   holdingValues.fVisibleDensity = real;       << 
1562   INTERPOLATELOG(fExplodeFactor);             << 
1563   holdingValues.fExplodeFactor = real;        << 
1564   INTERPOLATE(fFieldHalfAngle);               << 
1565   if (real < 0.) real = 0.;                   << 
1566   holdingValues.fFieldHalfAngle = real;       << 
1567   INTERPOLATELOG(fZoomFactor);                << 
1568   holdingValues.fZoomFactor = real;           << 
1569   INTERPOLATE(fDolly);                        << 
1570   holdingValues.fDolly = real;                << 
1571   INTERPOLATE(fGlobalMarkerScale);            << 
1572   if (real < 0.) real = 0.;                   << 
1573   holdingValues.fGlobalMarkerScale = real;    << 
1574   INTERPOLATE(fGlobalLineWidthScale);         << 
1575   if (real < 0.) real = 0.;                   << 
1576   holdingValues.fGlobalLineWidthScale = real; << 
1577                                               << 
1578   // Unit vectors                             << 
1579 #define INTERPOLATEUNITVECTOR(vector) \       << 
1580 INTERPOLATE(vector.x()); x = real; \          << 
1581 INTERPOLATE(vector.y()); y = real; \          << 
1582 INTERPOLATE(vector.z()); z = real;            << 
1583   INTERPOLATEUNITVECTOR(fViewpointDirection); << 
1584   holdingValues.fViewpointDirection           << 
1585   INTERPOLATEUNITVECTOR(fUpVector);           << 
1586   holdingValues.fUpVector                     << 
1587   INTERPOLATEUNITVECTOR(fRelativeLightpointDi << 
1588   holdingValues.fRelativeLightpointDirection  << 
1589   INTERPOLATEUNITVECTOR(fActualLightpointDire << 
1590   holdingValues.fActualLightpointDirection    << 
1591                                               << 
1592   // Un-normalised vectors                    << 
1593 #define INTERPOLATEVECTOR(vector) \           << 
1594 INTERPOLATE(vector.x()); x = real; \          << 
1595 INTERPOLATE(vector.y()); y = real; \          << 
1596 INTERPOLATE(vector.z()); z = real;            << 
1597   INTERPOLATEVECTOR(fScaleFactor);            << 
1598   holdingValues.fScaleFactor = G4Vector3D(x,y << 
1599                                               << 
1600   // Points                                   << 
1601 #define INTERPOLATEPOINT(point) \             << 
1602 INTERPOLATE(point.x()); x = real; \           << 
1603 INTERPOLATE(point.y()); y = real; \           << 
1604 INTERPOLATE(point.z()); z = real;             << 
1605   INTERPOLATEPOINT(fExplodeCentre);           << 
1606   holdingValues.fExplodeCentre      = G4Point << 
1607   INTERPOLATEPOINT(fCurrentTargetPoint);      << 
1608   holdingValues.fCurrentTargetPoint = G4Point << 
1609                                               << 
1610   // Colour                                   << 
1611   G4double red, green, blue, alpha;           << 
1612 #define INTERPOLATECOLOUR(colour) \           << 
1613 INTERPOLATE(colour.GetRed());   red   = real; << 
1614 INTERPOLATE(colour.GetGreen()); green = real; << 
1615 INTERPOLATE(colour.GetBlue());  blue  = real; << 
1616 INTERPOLATE(colour.GetAlpha()); alpha = real; << 
1617   INTERPOLATECOLOUR(fBackgroundColour);       << 
1618   // Components are clamped to 0. <= componen << 
1619   holdingValues.fBackgroundColour = G4Colour( << 
1620                                               << 
1621   // For some parameters we need to check som << 
1622   G4bool continuous;                          << 
1623 #define CONTINUITY(quantity) \                << 
1624   continuous = false; \                       << 
1625   /* This follows the logic of the INTERPOLAT << 
1626   if (i == 0) { \                             << 
1627     if (v[1].quantity == v[0].quantity) { \   << 
1628        if (n == 1) continuous = true; \       << 
1629        else if (v[2].quantity == v[0].quantit << 
1630        continuous = true; \                   << 
1631     } \                                       << 
1632   } else if (i >= n - 1) { \                  << 
1633     if (v[i+1].quantity == v[i].quantity) { \ << 
1634       if (n == 1) continuous = true; \        << 
1635       else if (v[i+1].quantity == v[i-1].quan << 
1636       continuous = true; \                    << 
1637     } \                                       << 
1638   } else { \                                  << 
1639     if (v[i-1].quantity == v[i].quantity && \ << 
1640         v[i+1].quantity == v[i].quantity && \ << 
1641         v[i+2].quantity == v[i].quantity) \   << 
1642     continuous = true; \                      << 
1643   }                                           << 
1644                                               << 
1645   G4double a, b, c, d;                        << 
1646 #define INTERPOLATEPLANE(plane) \             << 
1647 INTERPOLATE(plane.a()); a = real; \           << 
1648 INTERPOLATE(plane.b()); b = real; \           << 
1649 INTERPOLATE(plane.c()); c = real; \           << 
1650 INTERPOLATE(plane.d()); d = real;             << 
1651                                               << 
1652   // Section plane                            << 
1653   CONTINUITY(fSection);                       << 
1654   if (continuous) {                           << 
1655     INTERPOLATEPLANE(fSectionPlane);          << 
1656     holdingValues.fSectionPlane = G4Plane3D(a << 
1657   }                                           << 
1658                                               << 
1659   // Cutaway planes                           << 
1660   if (v[i].fCutawayPlanes.size()) {           << 
1661     CONTINUITY(fCutawayPlanes.size());        << 
1662     if (continuous) {                         << 
1663       for (size_t j = 0; j < v[i].fCutawayPla << 
1664         INTERPOLATEPLANE(fCutawayPlanes[j]);  << 
1665         holdingValues.fCutawayPlanes[j] = G4P << 
1666       }                                       << 
1667     }                                         << 
1668   }                                           << 
1669                                               << 
1670   // Vis attributes modifiers                 << 
1671   // Really, we are only interested in colour << 
1672   // the "crude" interpolation that is guaran << 
1673   static G4VisAttributes workingVA;           << 
1674   if  (v[i].fVisAttributesModifiers.size()) { << 
1675     CONTINUITY(fVisAttributesModifiers.size() << 
1676     if (continuous) {                         << 
1677       for (size_t j = 0; j < v[i].fVisAttribu << 
1678         CONTINUITY(fVisAttributesModifiers[j] << 
1679         if (continuous) {                     << 
1680           CONTINUITY(fVisAttributesModifiers[ << 
1681           if (continuous) {                   << 
1682             if (v[i].fVisAttributesModifiers[ << 
1683                 G4ModelingParameters::VASColo << 
1684               INTERPOLATECOLOUR(fVisAttribute << 
1685               workingVA = v[i].fVisAttributes << 
1686               workingVA.SetColour(G4Colour(re << 
1687               holdingValues.fVisAttributesMod << 
1688             }                                 << 
1689           }                                   << 
1690         }                                     << 
1691       }                                       << 
1692     }                                         << 
1693   }                                           << 
1694                                               << 
1695   // Time window parameters (for showing part << 
1696   // Only two parameters are interpolated. Th << 
1697   // once and for all by the user for a given << 
1698   // if not, they will be interpolated by the << 
1699   INTERPOLATE(fStartTime)                     << 
1700   holdingValues.fStartTime = real;            << 
1701   INTERPOLATE(fEndTime)                       << 
1702   holdingValues.fEndTime = real;              << 
1703                                               << 
1704   // Increment counters                       << 
1705   iInterpolationPoint++;                      << 
1706   t += dt;                                    << 
1707   if (iInterpolationPoint > nInterpolationPoi << 
1708     iInterpolationPoint = 1;  // Ready for ne << 
1709     t = dt;                                   << 
1710     iInterval++;                              << 
1711   }                                           << 
1712   if (iInterval >= nIntervals) {              << 
1713     iInterpolationPoint = 0;  // Ready for a  << 
1714     t = 0.;                                   << 
1715     iInterval = 0;                            << 
1716     return 0;                                 << 
1717   }                                           << 
1718                                               << 
1719   return &holdingValues;                      << 
1720 }                                             << 
1721                                                  765