| Geant4 Cross Reference |
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$
27 // 28 //
28 // 29 //
29 // John Allison 19th July 1996 30 // John Allison 19th July 1996
30 // View parameters and options. 31 // View parameters and options.
31 32
>> 33 #include <sstream>
>> 34
32 #include "G4ViewParameters.hh" 35 #include "G4ViewParameters.hh"
33 36
34 #include "G4VisManager.hh" 37 #include "G4VisManager.hh"
35 #include "G4VPhysicalVolume.hh" <<
36 #include "G4UnitsTable.hh" 38 #include "G4UnitsTable.hh"
37 #include "G4SystemOfUnits.hh" 39 #include "G4SystemOfUnits.hh"
38 #include "G4Polyhedron.hh" << 40 #include "G4ios.hh"
39 <<
40 #include <sstream> <<
41 #include <cmath> <<
42 <<
43 #define G4warn G4cout <<
44 41
45 G4ViewParameters::G4ViewParameters (): 42 G4ViewParameters::G4ViewParameters ():
46 fDrawingStyle (wireframe), 43 fDrawingStyle (wireframe),
47 fNumberOfCloudPoints(10000), <<
48 fAuxEdgeVisible (false), 44 fAuxEdgeVisible (false),
>> 45 fRepStyle (polyhedron),
49 fCulling (true), 46 fCulling (true),
50 fCullInvisible (true), 47 fCullInvisible (true),
51 fDensityCulling (false), 48 fDensityCulling (false),
52 fVisibleDensity (0.01 * g / cm3), 49 fVisibleDensity (0.01 * g / cm3),
53 fCullCovered (false), 50 fCullCovered (false),
54 fCBDAlgorithmNumber (0), <<
55 fSection (false), 51 fSection (false),
56 fSectionPlane (), 52 fSectionPlane (),
57 fCutawayMode (cutawayUnion), 53 fCutawayMode (cutawayUnion),
58 fCutawayPlanes (), 54 fCutawayPlanes (),
59 fExplodeFactor (1.), 55 fExplodeFactor (1.),
60 fNoOfSides (), << 56 fNoOfSides (24),
61 fViewpointDirection (G4Vector3D (0., 0., 1.) 57 fViewpointDirection (G4Vector3D (0., 0., 1.)), // On z-axis.
62 fUpVector (G4Vector3D (0., 1., 0.)), 58 fUpVector (G4Vector3D (0., 1., 0.)), // y-axis up.
63 fFieldHalfAngle (0.), 59 fFieldHalfAngle (0.), // Orthogonal projection.
64 fZoomFactor (1.), 60 fZoomFactor (1.),
65 fScaleFactor (G4Vector3D (1., 1., 1.)), 61 fScaleFactor (G4Vector3D (1., 1., 1.)),
66 fCurrentTargetPoint (), 62 fCurrentTargetPoint (),
67 fDolly (0.), 63 fDolly (0.),
68 fLightsMoveWithCamera (false), 64 fLightsMoveWithCamera (false),
69 fRelativeLightpointDirection (G4Vector3D (1. 65 fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
70 fActualLightpointDirection (G4Vector3D (1., 66 fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
71 fDefaultVisAttributes (), 67 fDefaultVisAttributes (),
72 fDefaultTextVisAttributes (G4Colour (0., 0., 68 fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
73 fDefaultMarker (), 69 fDefaultMarker (),
74 fGlobalMarkerScale (1.), 70 fGlobalMarkerScale (1.),
75 fGlobalLineWidthScale (1.), 71 fGlobalLineWidthScale (1.),
76 fMarkerNotHidden (true), 72 fMarkerNotHidden (true),
77 fWindowSizeHintX (600), 73 fWindowSizeHintX (600),
78 fWindowSizeHintY (600), 74 fWindowSizeHintY (600),
79 fWindowLocationHintX(0), 75 fWindowLocationHintX(0),
80 fWindowLocationHintY(0), 76 fWindowLocationHintY(0),
81 fWindowLocationHintXNegative(true), 77 fWindowLocationHintXNegative(true),
82 fWindowLocationHintYNegative(false), 78 fWindowLocationHintYNegative(false),
83 fGeometryMask(0), 79 fGeometryMask(0),
84 fAutoRefresh (false), 80 fAutoRefresh (false),
85 fBackgroundColour (G4Colour(0.,0.,0.)), 81 fBackgroundColour (G4Colour(0.,0.,0.)), // Black
86 fPicking (false), 82 fPicking (false),
87 fRotationStyle (constrainUpDirection), << 83 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 { 84 {
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.); 85 fDefaultMarker.SetScreenSize (5.);
119 // Markers are 5 pixels "overall" size, i.e. 86 // Markers are 5 pixels "overall" size, i.e., diameter.
120 } 87 }
121 88
122 G4ViewParameters::~G4ViewParameters () {} 89 G4ViewParameters::~G4ViewParameters () {}
123 90
124 void G4ViewParameters::MultiplyScaleFactor 91 void G4ViewParameters::MultiplyScaleFactor
125 (const G4Vector3D& scaleFactorMultiplier) { 92 (const G4Vector3D& scaleFactorMultiplier) {
126 fScaleFactor.setX(fScaleFactor.x() * scaleFa 93 fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
127 fScaleFactor.setY(fScaleFactor.y() * scaleFa 94 fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
128 fScaleFactor.setZ(fScaleFactor.z() * scaleFa 95 fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
129 } 96 }
130 97
131 G4Vector3D& G4ViewParameters::GetActualLightpo 98 G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
132 SetViewAndLights (fViewpointDirection); 99 SetViewAndLights (fViewpointDirection);
133 return fActualLightpointDirection; 100 return fActualLightpointDirection;
134 } 101 }
135 102
136 // Useful quantities - begin snippet. 103 // Useful quantities - begin snippet.
137 // Here Follow functions to evaluate the above 104 // Here Follow functions to evaluate the above algorithms as a
138 // function of the radius of the Bounding Sphe 105 // function of the radius of the Bounding Sphere of the object being
139 // viewed. Call them in the order given - for 106 // viewed. Call them in the order given - for efficiency, later
140 // functions depend on the results of earlier 107 // functions depend on the results of earlier ones (Store the
141 // results of earlier functions in your own te 108 // results of earlier functions in your own temporary variables -
142 // see, for example, G4OpenGLView::SetView (). 109 // see, for example, G4OpenGLView::SetView ().)
143 110
144 G4double G4ViewParameters::GetCameraDistance ( 111 G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
145 G4double cameraDistance; 112 G4double cameraDistance;
146 if (fFieldHalfAngle == 0.) { 113 if (fFieldHalfAngle == 0.) {
147 cameraDistance = radius; 114 cameraDistance = radius;
148 } 115 }
149 else { 116 else {
150 cameraDistance = radius / std::sin (fField 117 cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
151 } 118 }
152 return cameraDistance; 119 return cameraDistance;
153 } 120 }
154 121
155 G4double G4ViewParameters::GetNearDistance (G4 122 G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
156 G4double radius) const { 123 G4double radius) const {
157 const G4double small = 1.e-6 * radius; 124 const G4double small = 1.e-6 * radius;
158 G4double nearDistance = cameraDistance - rad 125 G4double nearDistance = cameraDistance - radius;
159 if (nearDistance < small) nearDistance = sma 126 if (nearDistance < small) nearDistance = small;
160 return nearDistance; 127 return nearDistance;
161 } 128 }
162 129
163 G4double G4ViewParameters::GetFarDistance (G4d 130 G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
164 G4double nearDistance, 131 G4double nearDistance,
165 G4double radius) const { 132 G4double radius) const {
166 G4double farDistance = cameraDistance + radi 133 G4double farDistance = cameraDistance + radius;
167 if (farDistance < nearDistance) farDistance 134 if (farDistance < nearDistance) farDistance = nearDistance;
168 return farDistance; 135 return farDistance;
169 } 136 }
170 137
171 G4double G4ViewParameters::GetFrontHalfHeight 138 G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
172 G4double radius) const { 139 G4double radius) const {
173 G4double frontHalfHeight; 140 G4double frontHalfHeight;
174 if (fFieldHalfAngle == 0.) { 141 if (fFieldHalfAngle == 0.) {
175 frontHalfHeight = radius / fZoomFactor; 142 frontHalfHeight = radius / fZoomFactor;
176 } 143 }
177 else { 144 else {
178 frontHalfHeight = nearDistance * std::tan 145 frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
179 } 146 }
180 return frontHalfHeight; 147 return frontHalfHeight;
181 } 148 }
182 // Useful quantities - end snippet. 149 // Useful quantities - end snippet.
183 150
184 void G4ViewParameters::AddCutawayPlane (const 151 void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
185 if (fCutawayPlanes.size () < 3 ) { 152 if (fCutawayPlanes.size () < 3 ) {
186 fCutawayPlanes.push_back (cutawayPlane); 153 fCutawayPlanes.push_back (cutawayPlane);
187 } 154 }
188 else { 155 else {
189 G4warn << << 156 G4cout <<
190 "ERROR: G4ViewParameters::AddCutawayPlan 157 "ERROR: G4ViewParameters::AddCutawayPlane:"
191 "\n A maximum of 3 cutaway planes suppo 158 "\n A maximum of 3 cutaway planes supported." << G4endl;
192 } 159 }
193 } 160 }
194 161
195 void G4ViewParameters::ChangeCutawayPlane 162 void G4ViewParameters::ChangeCutawayPlane
196 (size_t index, const G4Plane3D& cutawayPlane) 163 (size_t index, const G4Plane3D& cutawayPlane) {
197 if (index >= fCutawayPlanes.size()) { 164 if (index >= fCutawayPlanes.size()) {
198 G4warn << << 165 G4cout <<
199 "ERROR: G4ViewParameters::ChangeCutawayP 166 "ERROR: G4ViewParameters::ChangeCutawayPlane:"
200 "\n Plane " << index << " does not exis 167 "\n Plane " << index << " does not exist." << G4endl;
201 } else { 168 } else {
202 fCutawayPlanes[index] = cutawayPlane; 169 fCutawayPlanes[index] = cutawayPlane;
203 } 170 }
204 } 171 }
205 172
206 void G4ViewParameters::SetVisibleDensity (G4do 173 void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
207 const G4double reasonableMaximum = 10.0 * g 174 const G4double reasonableMaximum = 10.0 * g / cm3;
208 if (visibleDensity < 0) { 175 if (visibleDensity < 0) {
209 G4warn << "G4ViewParameters::SetVisibleDen << 176 G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
210 "density - ignored." << G4endl; 177 "density - ignored." << G4endl;
211 } 178 }
212 else { 179 else {
213 if (visibleDensity > reasonableMaximum) { 180 if (visibleDensity > reasonableMaximum) {
214 G4warn << "G4ViewParameters::SetVisibleD << 181 G4cout << "G4ViewParameters::SetVisibleDensity: density > "
215 << G4BestUnit (reasonableMaximum, "Volu 182 << G4BestUnit (reasonableMaximum, "Volumic Mass")
216 << " - did you mean this?" 183 << " - did you mean this?"
217 << G4endl; 184 << G4endl;
218 } 185 }
219 fVisibleDensity = visibleDensity; 186 fVisibleDensity = visibleDensity;
220 } 187 }
221 } 188 }
222 189
223 G4int G4ViewParameters::SetNoOfSides (G4int nS 190 G4int G4ViewParameters::SetNoOfSides (G4int nSides) {
224 const G4int nSidesMin = fDefaultVisAttribute << 191 const G4int nSidesMin = 12;
225 if (nSides < nSidesMin) { 192 if (nSides < nSidesMin) {
226 nSides = nSidesMin; 193 nSides = nSidesMin;
227 G4warn << "G4ViewParameters::SetNoOfSides: << 194 G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
228 "\nnumber of sides per circle < " << nSide << 195 "\nnumber of sides per circle < " << nSidesMin
229 << "; forced to " << nSides << G4endl; << 196 << "; forced to " << nSides << G4endl;
230 } 197 }
231 fNoOfSides = nSides; 198 fNoOfSides = nSides;
232 return fNoOfSides; 199 return fNoOfSides;
233 } 200 }
234 201
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 202 void G4ViewParameters::SetViewAndLights
248 (const G4Vector3D& viewpointDirection) { 203 (const G4Vector3D& viewpointDirection) {
249 204
250 fViewpointDirection = viewpointDirection; 205 fViewpointDirection = viewpointDirection;
251 206
252 // If the requested viewpoint direction is p 207 // If the requested viewpoint direction is parallel to the up
253 // vector, the orientation of the view is un 208 // vector, the orientation of the view is undefined...
254 if (fViewpointDirection.unit() * fUpVector.u 209 if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
255 static G4bool firstTime = true; << 210 G4cout <<
256 if (firstTime) { <<
257 firstTime = false; <<
258 G4warn << <<
259 "WARNING: Viewpoint direction is very cl 211 "WARNING: Viewpoint direction is very close to the up vector direction."
260 "\n Change the up vector or \"/vis/view << 212 "\n Consider setting the up vector to obtain definable behaviour."
261 << G4endl; << 213 << G4endl;
262 } <<
263 } 214 }
264 215
265 // Move the lights too if requested... 216 // Move the lights too if requested...
266 if (fLightsMoveWithCamera) { 217 if (fLightsMoveWithCamera) {
267 G4Vector3D zprime = fViewpointDirection.un 218 G4Vector3D zprime = fViewpointDirection.unit ();
268 G4Vector3D xprime = (fUpVector.cross (zpri 219 G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
269 G4Vector3D yprime = zprime.cross (xprime); 220 G4Vector3D yprime = zprime.cross (xprime);
270 fActualLightpointDirection = 221 fActualLightpointDirection =
271 fRelativeLightpointDirection.x () * xpri 222 fRelativeLightpointDirection.x () * xprime +
272 fRelativeLightpointDirection.y () * ypri 223 fRelativeLightpointDirection.y () * yprime +
273 fRelativeLightpointDirection.x () * zpri 224 fRelativeLightpointDirection.x () * zprime;
274 } else { 225 } else {
275 fActualLightpointDirection = fRelativeLigh 226 fActualLightpointDirection = fRelativeLightpointDirection;
276 } 227 }
277 } 228 }
278 229
279 void G4ViewParameters::SetLightpointDirection 230 void G4ViewParameters::SetLightpointDirection
280 (const G4Vector3D& lightpointDirection) { 231 (const G4Vector3D& lightpointDirection) {
281 fRelativeLightpointDirection = lightpointDir 232 fRelativeLightpointDirection = lightpointDirection;
282 SetViewAndLights (fViewpointDirection); 233 SetViewAndLights (fViewpointDirection);
283 } 234 }
284 235
285 void G4ViewParameters::SetPan (G4double right, 236 void G4ViewParameters::SetPan (G4double right, G4double up) {
286 G4Vector3D unitRight = (fUpVector.cross (fVi 237 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
287 G4Vector3D unitUp = (fViewpointDirection. 238 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
288 fCurrentTargetPoint = right * unitRight + u 239 fCurrentTargetPoint = right * unitRight + up * unitUp;
289 } 240 }
290 241
291 void G4ViewParameters::IncrementPan (G4double 242 void G4ViewParameters::IncrementPan (G4double right, G4double up) {
292 IncrementPan (right,up, 0); 243 IncrementPan (right,up, 0);
293 } 244 }
294 245
295 void G4ViewParameters::IncrementPan (G4double 246 void G4ViewParameters::IncrementPan (G4double right, G4double up, G4double distance) {
296 G4Vector3D unitRight = (fUpVector.cross (fVi 247 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
297 G4Vector3D unitUp = (fViewpointDirection. 248 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
298 fCurrentTargetPoint += right * unitRight + u 249 fCurrentTargetPoint += right * unitRight + up * unitUp + distance * fViewpointDirection;
299 } 250 }
300 251
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 252 G4String G4ViewParameters::CameraAndLightingCommands
318 (const G4Point3D standardTargetPoint) const 253 (const G4Point3D standardTargetPoint) const
319 { 254 {
320 std::ostringstream oss; 255 std::ostringstream oss;
321 256
322 oss << "#\n# Camera and lights commands"; 257 oss << "#\n# Camera and lights commands";
323 258
324 oss << "\n/vis/viewer/set/viewpointVector " 259 oss << "\n/vis/viewer/set/viewpointVector "
325 << fViewpointDirection.x() 260 << fViewpointDirection.x()
326 << ' ' << fViewpointDirection.y() 261 << ' ' << fViewpointDirection.y()
327 << ' ' << fViewpointDirection.z(); 262 << ' ' << fViewpointDirection.z();
328 263
329 oss << "\n/vis/viewer/set/upVector " 264 oss << "\n/vis/viewer/set/upVector "
330 << fUpVector.x() 265 << fUpVector.x()
331 << ' ' << fUpVector.y() 266 << ' ' << fUpVector.y()
332 << ' ' << fUpVector.z(); 267 << ' ' << fUpVector.z();
333 268
334 oss << "\n/vis/viewer/set/projection "; 269 oss << "\n/vis/viewer/set/projection ";
335 if (fFieldHalfAngle == 0.) { 270 if (fFieldHalfAngle == 0.) {
336 oss 271 oss
337 << "orthogonal"; 272 << "orthogonal";
338 } else { 273 } else {
339 oss 274 oss
340 << "perspective " 275 << "perspective "
341 << fFieldHalfAngle/deg 276 << fFieldHalfAngle/deg
342 << " deg"; 277 << " deg";
343 } 278 }
344 279
345 oss << "\n/vis/viewer/zoomTo " 280 oss << "\n/vis/viewer/zoomTo "
346 << fZoomFactor; 281 << fZoomFactor;
347 282
348 oss << "\n/vis/viewer/scaleTo " 283 oss << "\n/vis/viewer/scaleTo "
349 << fScaleFactor.x() 284 << fScaleFactor.x()
350 << ' ' << fScaleFactor.y() 285 << ' ' << fScaleFactor.y()
351 << ' ' << fScaleFactor.z(); 286 << ' ' << fScaleFactor.z();
352 287
353 oss << "\n/vis/viewer/set/targetPoint " 288 oss << "\n/vis/viewer/set/targetPoint "
354 << G4BestUnit(standardTargetPoint+fCurrentTa 289 << G4BestUnit(standardTargetPoint+fCurrentTargetPoint,"Length")
355 << "\n# Note that if you have not set a targ 290 << "\n# Note that if you have not set a target point, the vis system sets"
356 << "\n# a target point based on the scene - 291 << "\n# a target point based on the scene - plus any panning and dollying -"
357 << "\n# so don't be alarmed by strange coord 292 << "\n# so don't be alarmed by strange coordinates here.";
358 293
359 oss << "\n/vis/viewer/dollyTo " 294 oss << "\n/vis/viewer/dollyTo "
360 << G4BestUnit(fDolly,"Length"); 295 << G4BestUnit(fDolly,"Length");
361 296
362 oss << "\n/vis/viewer/set/lightsMove "; 297 oss << "\n/vis/viewer/set/lightsMove ";
363 if (fLightsMoveWithCamera) { 298 if (fLightsMoveWithCamera) {
364 oss << "camera"; 299 oss << "camera";
365 } else { 300 } else {
366 oss << "object"; 301 oss << "object";
367 } 302 }
368 303
369 oss << "\n/vis/viewer/set/lightsVector " 304 oss << "\n/vis/viewer/set/lightsVector "
370 << fRelativeLightpointDirection.x() 305 << fRelativeLightpointDirection.x()
371 << ' ' << fRelativeLightpointDirection.y() 306 << ' ' << fRelativeLightpointDirection.y()
372 << ' ' << fRelativeLightpointDirection.z(); 307 << ' ' << fRelativeLightpointDirection.z();
373 308
374 oss << "\n/vis/viewer/set/rotationStyle "; 309 oss << "\n/vis/viewer/set/rotationStyle ";
375 if (fRotationStyle == constrainUpDirection) 310 if (fRotationStyle == constrainUpDirection) {
376 oss << "constrainUpDirection"; 311 oss << "constrainUpDirection";
377 } else { 312 } else {
378 oss << "freeRotation"; 313 oss << "freeRotation";
379 } 314 }
380 315
381 G4Colour c = fBackgroundColour; 316 G4Colour c = fBackgroundColour;
382 oss << "\n/vis/viewer/set/background " 317 oss << "\n/vis/viewer/set/background "
383 << c.GetRed() 318 << c.GetRed()
384 << ' ' << c.GetGreen() 319 << ' ' << c.GetGreen()
385 << ' ' << c.GetBlue() 320 << ' ' << c.GetBlue()
386 << ' ' << c.GetAlpha(); 321 << ' ' << c.GetAlpha();
387 322
388 c = fDefaultVisAttributes.GetColour(); 323 c = fDefaultVisAttributes.GetColour();
389 oss << "\n/vis/viewer/set/defaultColour " 324 oss << "\n/vis/viewer/set/defaultColour "
390 << c.GetRed() 325 << c.GetRed()
391 << ' ' << c.GetGreen() 326 << ' ' << c.GetGreen()
392 << ' ' << c.GetBlue() 327 << ' ' << c.GetBlue()
393 << ' ' << c.GetAlpha(); 328 << ' ' << c.GetAlpha();
394 329
395 c = fDefaultTextVisAttributes.GetColour(); 330 c = fDefaultTextVisAttributes.GetColour();
396 oss << "\n/vis/viewer/set/defaultTextColour 331 oss << "\n/vis/viewer/set/defaultTextColour "
397 << c.GetRed() 332 << c.GetRed()
398 << ' ' << c.GetGreen() 333 << ' ' << c.GetGreen()
399 << ' ' << c.GetBlue() 334 << ' ' << c.GetBlue()
400 << ' ' << c.GetAlpha(); 335 << ' ' << c.GetAlpha();
401 336
402 oss << std::endl; 337 oss << std::endl;
403 338
404 return oss.str(); 339 return oss.str();
405 } 340 }
406 341
407 G4String G4ViewParameters::DrawingStyleCommand 342 G4String G4ViewParameters::DrawingStyleCommands() const
408 { 343 {
409 std::ostringstream oss; 344 std::ostringstream oss;
410 345
411 oss << "#\n# Drawing style commands"; 346 oss << "#\n# Drawing style commands";
412 347
413 oss << "\n/vis/viewer/set/style "; 348 oss << "\n/vis/viewer/set/style ";
414 switch (fDrawingStyle) { << 349 if (fDrawingStyle == wireframe || fDrawingStyle == hlr) {
415 case wireframe: << 350 oss << "wireframe";
416 case hlr: << 351 } else {
417 oss << "wireframe"; << 352 oss << "surface";
418 break; <<
419 case hsr: <<
420 case hlhsr: <<
421 oss << "surface"; <<
422 break; <<
423 case cloud: <<
424 oss << "cloud"; <<
425 break; <<
426 } 353 }
427 << 354
428 oss << "\n/vis/viewer/set/hiddenEdge "; 355 oss << "\n/vis/viewer/set/hiddenEdge ";
429 if (fDrawingStyle == hlr || fDrawingStyle == 356 if (fDrawingStyle == hlr || fDrawingStyle == hlhsr) {
430 oss << "true"; 357 oss << "true";
431 } else { 358 } else {
432 oss << "false"; 359 oss << "false";
433 } 360 }
434 361
435 oss << "\n/vis/viewer/set/auxiliaryEdge "; 362 oss << "\n/vis/viewer/set/auxiliaryEdge ";
436 if (fAuxEdgeVisible) { 363 if (fAuxEdgeVisible) {
437 oss << "true"; 364 oss << "true";
438 } else { 365 } else {
439 oss << "false"; 366 oss << "false";
440 } 367 }
441 368
442 oss << "\n/vis/viewer/set/hiddenMarker "; 369 oss << "\n/vis/viewer/set/hiddenMarker ";
443 if (fMarkerNotHidden) { 370 if (fMarkerNotHidden) {
444 oss << "false"; 371 oss << "false";
445 } else { 372 } else {
446 oss << "true"; 373 oss << "true";
447 } 374 }
448 375
449 oss << "\n/vis/viewer/set/globalLineWidthSca 376 oss << "\n/vis/viewer/set/globalLineWidthScale "
450 << fGlobalLineWidthScale; 377 << fGlobalLineWidthScale;
451 378
452 oss << "\n/vis/viewer/set/globalMarkerScale 379 oss << "\n/vis/viewer/set/globalMarkerScale "
453 << fGlobalMarkerScale; 380 << fGlobalMarkerScale;
454 << 381
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; 382 oss << std::endl;
474 383
475 return oss.str(); 384 return oss.str();
476 } 385 }
477 386
478 G4String G4ViewParameters::SceneModifyingComma 387 G4String G4ViewParameters::SceneModifyingCommands() const
479 { 388 {
480 std::ostringstream oss; 389 std::ostringstream oss;
481 390
482 oss << "#\n# Scene-modifying commands"; 391 oss << "#\n# Scene-modifying commands";
483 392
484 oss << "\n/vis/viewer/set/culling global "; 393 oss << "\n/vis/viewer/set/culling global ";
485 if (fCulling) { 394 if (fCulling) {
486 oss << "true"; 395 oss << "true";
487 } else { 396 } else {
488 oss << "false"; 397 oss << "false";
489 } 398 }
490 399
491 oss << "\n/vis/viewer/set/culling invisible 400 oss << "\n/vis/viewer/set/culling invisible ";
492 if (fCullInvisible) { 401 if (fCullInvisible) {
493 oss << "true"; 402 oss << "true";
494 } else { 403 } else {
495 oss << "false"; 404 oss << "false";
496 } 405 }
497 406
498 oss << "\n/vis/viewer/set/culling density "; 407 oss << "\n/vis/viewer/set/culling density ";
499 if (fDensityCulling) { 408 if (fDensityCulling) {
500 oss << "true " << fVisibleDensity/(g/cm3) 409 oss << "true " << fVisibleDensity/(g/cm3) << " g/cm3";
501 } else { 410 } else {
502 oss << "false"; 411 oss << "false";
503 } 412 }
504 413
505 oss << "\n/vis/viewer/set/culling coveredDau 414 oss << "\n/vis/viewer/set/culling coveredDaughters ";
506 if (fCullCovered) { 415 if (fCullCovered) {
507 oss << "true"; 416 oss << "true";
508 } else { 417 } else {
509 oss << "false"; 418 oss << "false";
510 } 419 }
511 << 420
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 "; 421 oss << "\n/vis/viewer/set/sectionPlane ";
519 if (fSection) { 422 if (fSection) {
520 oss << "on " 423 oss << "on "
521 << G4BestUnit(fSectionPlane.point(),"Lengt 424 << G4BestUnit(fSectionPlane.point(),"Length")
522 << fSectionPlane.normal().x() 425 << fSectionPlane.normal().x()
523 << ' ' << fSectionPlane.normal().y() 426 << ' ' << fSectionPlane.normal().y()
524 << ' ' << fSectionPlane.normal().z(); 427 << ' ' << fSectionPlane.normal().z();
525 } else { 428 } else {
526 oss << "off"; 429 oss << "off";
527 } 430 }
528 431
529 oss << "\n/vis/viewer/set/cutawayMode "; 432 oss << "\n/vis/viewer/set/cutawayMode ";
530 if (fCutawayMode == cutawayUnion) { 433 if (fCutawayMode == cutawayUnion) {
531 oss << "union"; 434 oss << "union";
532 } else { 435 } else {
533 oss << "intersection"; 436 oss << "intersection";
534 } 437 }
535 438
536 oss << "\n/vis/viewer/clearCutawayPlanes"; 439 oss << "\n/vis/viewer/clearCutawayPlanes";
537 if (fCutawayPlanes.size()) { 440 if (fCutawayPlanes.size()) {
538 for (size_t i = 0; i < fCutawayPlanes.size 441 for (size_t i = 0; i < fCutawayPlanes.size(); i++) {
539 oss << "\n/vis/viewer/addCutawayPlane " 442 oss << "\n/vis/viewer/addCutawayPlane "
540 << G4BestUnit(fCutawayPlanes[i].point(), 443 << G4BestUnit(fCutawayPlanes[i].point(),"Length")
541 << fCutawayPlanes[i].normal().x() 444 << fCutawayPlanes[i].normal().x()
542 << ' ' << fCutawayPlanes[i].normal().y() 445 << ' ' << fCutawayPlanes[i].normal().y()
543 << ' ' << fCutawayPlanes[i].normal().z() 446 << ' ' << fCutawayPlanes[i].normal().z();
544 } 447 }
545 } else { 448 } else {
546 oss << "\n# No cutaway planes defined."; 449 oss << "\n# No cutaway planes defined.";
547 } 450 }
548 451
549 oss << "\n/vis/viewer/set/explodeFactor " 452 oss << "\n/vis/viewer/set/explodeFactor "
550 << fExplodeFactor 453 << fExplodeFactor
551 << ' ' << G4BestUnit(fExplodeCentre,"Length" 454 << ' ' << G4BestUnit(fExplodeCentre,"Length");
552 455
553 oss << "\n/vis/viewer/set/lineSegmentsPerCir 456 oss << "\n/vis/viewer/set/lineSegmentsPerCircle "
554 << fNoOfSides; 457 << fNoOfSides;
555 458
556 oss << std::endl; 459 oss << std::endl;
557 460
558 return oss.str(); 461 return oss.str();
559 } 462 }
560 463
561 G4String G4ViewParameters::TouchableCommands() 464 G4String G4ViewParameters::TouchableCommands() const
562 { 465 {
563 std::ostringstream oss; 466 std::ostringstream oss;
564 467
565 oss << "#\n# Touchable commands"; 468 oss << "#\n# Touchable commands";
566 << 469
567 const std::vector<G4ModelingParameters::VisA 470 const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
568 fVisAttributesModifiers; 471 fVisAttributesModifiers;
569 472
570 if (vams.empty()) { 473 if (vams.empty()) {
571 oss << 474 oss << "\n# None";
572 << "\n# None" <<
573 << "\n/vis/viewer/clearVisAttributesModifi <<
574 oss << std::endl; 475 oss << std::endl;
575 return oss.str(); 476 return oss.str();
576 } 477 }
577 << 478
578 oss <<
579 << "\n/vis/viewer/clearVisAttributesModifier <<
580 <<
581 G4ModelingParameters::PVNameCopyNoPath lastP <<
582 std::vector<G4ModelingParameters::VisAttribu 479 std::vector<G4ModelingParameters::VisAttributesModifier>::const_iterator
583 iModifier; 480 iModifier;
584 for (iModifier = vams.begin(); 481 for (iModifier = vams.begin();
585 iModifier != vams.end(); 482 iModifier != vams.end();
586 ++iModifier) { 483 ++iModifier) {
>> 484 oss << "\n/vis/set/touchable";
587 const G4ModelingParameters::PVNameCopyNoPa 485 const G4ModelingParameters::PVNameCopyNoPath& vamPath =
588 iModifier->GetPVNameCopyNoPath(); 486 iModifier->GetPVNameCopyNoPath();
589 if (vamPath != lastPath) { << 487 G4ModelingParameters::PVNameCopyNoPathConstIterator iVAM;
590 lastPath = vamPath; << 488 for (iVAM = vamPath.begin();
591 oss << "\n/vis/set/touchable"; << 489 iVAM != vamPath.end();
592 G4ModelingParameters::PVNameCopyNoPathCo << 490 ++iVAM) {
593 for (iVAM = vamPath.begin(); << 491 oss << ' ' << iVAM->GetName() << ' ' << iVAM->GetCopyNo();
594 iVAM != vamPath.end(); <<
595 ++iVAM) { <<
596 oss << ' ' << iVAM->GetName() << ' ' < <<
597 } <<
598 } 492 }
599 const G4VisAttributes& vamVisAtts = iModif 493 const G4VisAttributes& vamVisAtts = iModifier->GetVisAttributes();
600 const G4Colour& c = vamVisAtts.GetColour() 494 const G4Colour& c = vamVisAtts.GetColour();
601 switch (iModifier->GetVisAttributesSignifi 495 switch (iModifier->GetVisAttributesSignifier()) {
602 case G4ModelingParameters::VASVisibility 496 case G4ModelingParameters::VASVisibility:
603 oss << "\n/vis/touchable/set/visibilit 497 oss << "\n/vis/touchable/set/visibility ";
604 if (vamVisAtts.IsVisible()) { 498 if (vamVisAtts.IsVisible()) {
605 oss << "true"; 499 oss << "true";
606 } else { 500 } else {
607 oss << "false"; 501 oss << "false";
608 } 502 }
609 break; 503 break;
610 case G4ModelingParameters::VASDaughtersI 504 case G4ModelingParameters::VASDaughtersInvisible:
611 oss << "\n/vis/touchable/set/daughters 505 oss << "\n/vis/touchable/set/daughtersInvisible ";
612 if (vamVisAtts.IsDaughtersInvisible()) 506 if (vamVisAtts.IsDaughtersInvisible()) {
613 oss << "true"; 507 oss << "true";
614 } else { 508 } else {
615 oss << "false"; 509 oss << "false";
616 } 510 }
617 break; 511 break;
618 case G4ModelingParameters::VASColour: 512 case G4ModelingParameters::VASColour:
619 oss << "\n/vis/touchable/set/colour " 513 oss << "\n/vis/touchable/set/colour "
620 << c.GetRed() 514 << c.GetRed()
621 << ' ' << c.GetGreen() 515 << ' ' << c.GetGreen()
622 << ' ' << c.GetBlue() 516 << ' ' << c.GetBlue()
623 << ' ' << c.GetAlpha(); 517 << ' ' << c.GetAlpha();
624 break; 518 break;
625 case G4ModelingParameters::VASLineStyle: 519 case G4ModelingParameters::VASLineStyle:
626 oss << "\n/vis/touchable/set/lineStyle 520 oss << "\n/vis/touchable/set/lineStyle ";
627 switch (vamVisAtts.GetLineStyle()) { 521 switch (vamVisAtts.GetLineStyle()) {
628 case G4VisAttributes::unbroken: 522 case G4VisAttributes::unbroken:
629 oss << "unbroken"; 523 oss << "unbroken";
630 break; 524 break;
631 case G4VisAttributes::dashed: 525 case G4VisAttributes::dashed:
632 oss << "dashed"; 526 oss << "dashed";
633 break; 527 break;
634 case G4VisAttributes::dotted: 528 case G4VisAttributes::dotted:
635 oss << "dotted"; 529 oss << "dotted";
636 } 530 }
637 break; 531 break;
638 case G4ModelingParameters::VASLineWidth: 532 case G4ModelingParameters::VASLineWidth:
639 oss << "\n/vis/touchable/set/lineWidth 533 oss << "\n/vis/touchable/set/lineWidth "
640 << vamVisAtts.GetLineWidth(); 534 << vamVisAtts.GetLineWidth();
641 break; 535 break;
642 case G4ModelingParameters::VASForceWiref 536 case G4ModelingParameters::VASForceWireframe:
643 if (vamVisAtts.IsForceDrawingStyle()) << 537 if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::wireframe) {
644 if (vamVisAtts.GetForcedDrawingStyle << 538 oss << "\n/vis/touchable/set/forceWireframe ";
645 oss << "\n/vis/touchable/set/force << 539 if (vamVisAtts.IsForceDrawingStyle()) {
646 if (vamVisAtts.IsForceDrawingStyle << 540 oss << "true";
647 oss << "true"; << 541 } else {
648 } else { << 542 oss << "false";
649 oss << "false"; <<
650 } <<
651 } 543 }
652 } 544 }
653 break; 545 break;
654 case G4ModelingParameters::VASForceSolid 546 case G4ModelingParameters::VASForceSolid:
655 if (vamVisAtts.IsForceDrawingStyle()) << 547 if (vamVisAtts.GetForcedDrawingStyle() == G4VisAttributes::solid) {
656 if (vamVisAtts.GetForcedDrawingStyle << 548 oss << "\n/vis/touchable/set/forceSolid ";
657 oss << "\n/vis/touchable/set/force << 549 if (vamVisAtts.IsForceDrawingStyle()) {
658 if (vamVisAtts.IsForceDrawingStyle << 550 oss << "true";
659 oss << "true"; << 551 } else {
660 } else { << 552 oss << "false";
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 } 553 }
676 } 554 }
677 break; 555 break;
678 case G4ModelingParameters::VASForceAuxEd 556 case G4ModelingParameters::VASForceAuxEdgeVisible:
>> 557 oss << "\n/vis/touchable/set/forceAuxEdgeVisible ";
679 if (vamVisAtts.IsForceAuxEdgeVisible() 558 if (vamVisAtts.IsForceAuxEdgeVisible()) {
680 oss << "\n/vis/touchable/set/forceAu << 559 oss << "true";
681 if (vamVisAtts.IsForcedAuxEdgeVisibl << 560 } else {
682 oss << "true"; << 561 oss << "false";
683 } else { <<
684 oss << "false"; <<
685 } <<
686 } 562 }
687 break; 563 break;
688 case G4ModelingParameters::VASForceLineS 564 case G4ModelingParameters::VASForceLineSegmentsPerCircle:
689 oss << "\n/vis/touchable/set/lineSegme 565 oss << "\n/vis/touchable/set/lineSegmentsPerCircle "
690 << vamVisAtts.GetForcedLineSegmentsPer 566 << vamVisAtts.GetForcedLineSegmentsPerCircle();
691 break; 567 break;
692 case G4ModelingParameters::VASForceNumbe <<
693 oss << "\n/vis/touchable/set/numberOfC <<
694 << vamVisAtts.GetForcedNumberOfCloudPo <<
695 break; <<
696 } 568 }
697 } 569 }
698 570
699 oss << std::endl; 571 oss << std::endl;
700 572
701 return oss.str(); 573 return oss.str();
702 } 574 }
703 575
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 576 void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
760 577
761 // Put performance-sensitive parameters firs 578 // Put performance-sensitive parameters first.
762 if ( 579 if (
763 // This first to optimise spin, etc. 580 // This first to optimise spin, etc.
764 (fViewpointDirection != v.fViewpointDi 581 (fViewpointDirection != v.fViewpointDirection) ||
765 582
766 // No particular order from here on. 583 // No particular order from here on.
767 (fDrawingStyle != v.fDrawingStyl 584 (fDrawingStyle != v.fDrawingStyle) ||
768 (fNumberOfCloudPoints != v.fNumberOfClo <<
769 (fAuxEdgeVisible != v.fAuxEdgeVisi 585 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
>> 586 (fRepStyle != v.fRepStyle) ||
770 (fCulling != v.fCulling) 587 (fCulling != v.fCulling) ||
771 (fCullInvisible != v.fCullInvisib 588 (fCullInvisible != v.fCullInvisible) ||
772 (fDensityCulling != v.fDensityCull 589 (fDensityCulling != v.fDensityCulling) ||
773 (fVisibleDensity != v.fVisibleDens 590 (fVisibleDensity != v.fVisibleDensity) ||
774 (fCullCovered != v.fCullCovered 591 (fCullCovered != v.fCullCovered) ||
775 (fCBDAlgorithmNumber != v.fCBDAlgorith <<
776 (fSection != v.fSection) 592 (fSection != v.fSection) ||
777 (fNoOfSides != v.fNoOfSides) 593 (fNoOfSides != v.fNoOfSides) ||
778 (fUpVector != v.fUpVector) 594 (fUpVector != v.fUpVector) ||
779 (fFieldHalfAngle != v.fFieldHalfAn 595 (fFieldHalfAngle != v.fFieldHalfAngle) ||
780 (fZoomFactor != v.fZoomFactor) 596 (fZoomFactor != v.fZoomFactor) ||
781 (fScaleFactor != v.fScaleFactor 597 (fScaleFactor != v.fScaleFactor) ||
782 (fCurrentTargetPoint != v.fCurrentTarg 598 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
783 (fDolly != v.fDolly) 599 (fDolly != v.fDolly) ||
784 (fRelativeLightpointDirection != v.fRela 600 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
785 (fLightsMoveWithCamera != v.fLightsMoveW 601 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
786 (fDefaultVisAttributes != v.fDefaultVisA 602 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
787 (fDefaultTextVisAttributes != v.fDefault 603 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
788 (fDefaultMarker != v.fDefaultMark 604 (fDefaultMarker != v.fDefaultMarker) ||
789 (fGlobalMarkerScale != v.fGlobalMarke 605 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
790 (fGlobalLineWidthScale != v.fGlobalLineW 606 (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
791 (fMarkerNotHidden != v.fMarkerNotHi 607 (fMarkerNotHidden != v.fMarkerNotHidden) ||
792 (fWindowSizeHintX != v.fWindowSizeH 608 (fWindowSizeHintX != v.fWindowSizeHintX) ||
793 (fWindowSizeHintY != v.fWindowSizeH 609 (fWindowSizeHintY != v.fWindowSizeHintY) ||
794 (fXGeometryString != v.fXGeometrySt 610 (fXGeometryString != v.fXGeometryString) ||
795 (fGeometryMask != v.fGeometryMas 611 (fGeometryMask != v.fGeometryMask) ||
796 (fAutoRefresh != v.fAutoRefresh 612 (fAutoRefresh != v.fAutoRefresh) ||
797 (fBackgroundColour != v.fBackgroundC 613 (fBackgroundColour != v.fBackgroundColour) ||
798 (fPicking != v.fPicking) 614 (fPicking != v.fPicking) ||
799 (fRotationStyle != v.fRotationSty 615 (fRotationStyle != v.fRotationStyle)
800 ) 616 )
801 G4cout << "Difference in 1st batch." << G4 617 G4cout << "Difference in 1st batch." << G4endl;
802 618
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) { 619 if (fSection) {
812 if (!(fSectionPlane == v.fSectionPlane)) 620 if (!(fSectionPlane == v.fSectionPlane))
813 G4cout << "Difference in section planes 621 G4cout << "Difference in section planes batch." << G4endl;
814 } 622 }
815 623
816 if (IsCutaway()) { 624 if (IsCutaway()) {
817 if (fCutawayPlanes.size () != v.fCutawayPl 625 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
818 G4cout << "Difference in no of cutaway p 626 G4cout << "Difference in no of cutaway planes." << G4endl;
819 } 627 }
820 else { 628 else {
821 for (size_t i = 0; i < fCutawayPlanes.si 629 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
822 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[ 630 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
823 G4cout << "Difference in cutaway plane no. 631 G4cout << "Difference in cutaway plane no. " << i << G4endl;
824 } 632 }
825 } 633 }
826 } 634 }
827 635
828 if (IsExplode()) { 636 if (IsExplode()) {
829 if (fExplodeFactor != v.fExplodeFactor) 637 if (fExplodeFactor != v.fExplodeFactor)
830 G4cout << "Difference in explode factor. 638 G4cout << "Difference in explode factor." << G4endl;
831 if (fExplodeCentre != v.fExplodeCentre) 639 if (fExplodeCentre != v.fExplodeCentre)
832 G4cout << "Difference in explode centre. 640 G4cout << "Difference in explode centre." << G4endl;
833 } 641 }
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 } 642 }
875 643
876 std::ostream& operator << << 644 std::ostream& operator << (std::ostream& os,
877 (std::ostream& os, G4ViewParameters::DrawingS << 645 const G4ViewParameters::DrawingStyle& style) {
878 { <<
879 switch (style) { 646 switch (style) {
880 case G4ViewParameters::wireframe: << 647 case G4ViewParameters::wireframe:
881 os << "wireframe"; break; << 648 os << "wireframe"; break;
882 case G4ViewParameters::hlr: << 649 case G4ViewParameters::hlr:
883 os << "hlr - hidden lines removed"; brea << 650 os << "hlr - hidden lines removed"; break;
884 case G4ViewParameters::hsr: << 651 case G4ViewParameters::hsr:
885 os << "hsr - hidden surfaces removed"; b << 652 os << "hsr - hidden surfaces removed"; break;
886 case G4ViewParameters::hlhsr: << 653 case G4ViewParameters::hlhsr:
887 os << "hlhsr - hidden line, hidden surfa << 654 os << "hlhsr - hidden line, hidden surface removed"; break;
888 case G4ViewParameters::cloud: << 655 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 } 656 }
906 return os; 657 return os;
907 } 658 }
908 659
909 std::ostream& operator << (std::ostream& os, c 660 std::ostream& operator << (std::ostream& os, const G4ViewParameters& v) {
910 os << "View parameters and options:"; 661 os << "View parameters and options:";
911 662
912 os << "\n Drawing style: " << v.fDrawingSty << 663 os << "\n Drawing style: ";
913 << 664 switch (v.fDrawingStyle) {
914 os << "\n Number of cloud points: " << v.fN << 665 case G4ViewParameters::wireframe:
>> 666 os << "edges, wireframe"; break;
>> 667 case G4ViewParameters::hlr:
>> 668 os << "edges, hidden line removal"; break;
>> 669 case G4ViewParameters::hsr:
>> 670 os << "surfaces, hidden surface removal"; break;
>> 671 case G4ViewParameters::hlhsr:
>> 672 os << "surfaces and edges, hidden line and surface removal"; break;
>> 673 default: os << "unrecognised"; break;
>> 674 }
915 675
916 os << "\n Auxiliary edges: "; 676 os << "\n Auxiliary edges: ";
917 if (!v.fAuxEdgeVisible) os << "in"; 677 if (!v.fAuxEdgeVisible) os << "in";
918 os << "visible"; 678 os << "visible";
919 679
>> 680 os << "\n Representation style: ";
>> 681 switch (v.fRepStyle) {
>> 682 case G4ViewParameters::polyhedron:
>> 683 os << "polyhedron"; break;
>> 684 case G4ViewParameters::nurbs:
>> 685 os << "nurbs"; break;
>> 686 default: os << "unrecognised"; break;
>> 687 }
>> 688
920 os << "\n Culling: "; 689 os << "\n Culling: ";
921 if (v.fCulling) os << "on"; 690 if (v.fCulling) os << "on";
922 else os << "off"; 691 else os << "off";
923 692
924 os << "\n Culling invisible objects: "; 693 os << "\n Culling invisible objects: ";
925 if (v.fCullInvisible) os << "on"; 694 if (v.fCullInvisible) os << "on";
926 else os << "off"; 695 else os << "off";
927 696
928 os << "\n Density culling: "; 697 os << "\n Density culling: ";
929 if (v.fDensityCulling) { 698 if (v.fDensityCulling) {
930 os << "on - invisible if density less than 699 os << "on - invisible if density less than "
931 << v.fVisibleDensity / (1. * g / cm3) < 700 << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
932 } 701 }
933 else os << "off"; 702 else os << "off";
934 703
935 os << "\n Culling daughters covered by opaq 704 os << "\n Culling daughters covered by opaque mothers: ";
936 if (v.fCullCovered) os << "on"; 705 if (v.fCullCovered) os << "on";
937 else os << "off"; 706 else os << "off";
938 707
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: "; 708 os << "\n Section flag: ";
950 if (v.fSection) os << "true, section/cut pla 709 if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
951 else os << "false"; 710 else os << "false";
952 711
953 if (v.IsCutaway()) { 712 if (v.IsCutaway()) {
954 os << "\n Cutaway planes: "; 713 os << "\n Cutaway planes: ";
955 for (size_t i = 0; i < v.fCutawayPlanes.si 714 for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
956 os << ' ' << v.fCutawayPlanes[i]; 715 os << ' ' << v.fCutawayPlanes[i];
957 } 716 }
958 } 717 }
959 else { 718 else {
960 os << "\n No cutaway planes"; 719 os << "\n No cutaway planes";
961 } 720 }
962 721
963 os << "\n Explode factor: " << v.fExplodeFa 722 os << "\n Explode factor: " << v.fExplodeFactor
964 << " about centre: " << v.fExplodeCentre; 723 << " about centre: " << v.fExplodeCentre;
965 724
966 os << "\n No. of sides used in circle polyg 725 os << "\n No. of sides used in circle polygon approximation: "
967 << v.fNoOfSides; 726 << v.fNoOfSides;
968 727
969 os << "\n Viewpoint direction: " << v.fVie 728 os << "\n Viewpoint direction: " << v.fViewpointDirection;
970 729
971 os << "\n Up vector: " << v.fUpV 730 os << "\n Up vector: " << v.fUpVector;
972 731
973 os << "\n Field half angle: " << v.fFie 732 os << "\n Field half angle: " << v.fFieldHalfAngle;
974 733
975 os << "\n Zoom factor: " << v.fZoo 734 os << "\n Zoom factor: " << v.fZoomFactor;
976 735
977 os << "\n Scale factor: " << v.fSca 736 os << "\n Scale factor: " << v.fScaleFactor;
978 737
979 os << "\n Current target point: " << v.fCur 738 os << "\n Current target point: " << v.fCurrentTargetPoint;
980 739
981 os << "\n Dolly distance: " << v.fDol 740 os << "\n Dolly distance: " << v.fDolly;
982 741
983 os << "\n Light "; 742 os << "\n Light ";
984 if (v.fLightsMoveWithCamera) os << "moves"; 743 if (v.fLightsMoveWithCamera) os << "moves";
985 else os << "does not 744 else os << "does not move";
986 os << " with camera"; 745 os << " with camera";
987 746
988 os << "\n Relative lightpoint direction: " 747 os << "\n Relative lightpoint direction: "
989 << v.fRelativeLightpointDirection; 748 << v.fRelativeLightpointDirection;
990 749
991 os << "\n Actual lightpoint direction: " 750 os << "\n Actual lightpoint direction: "
992 << v.fActualLightpointDirection; 751 << v.fActualLightpointDirection;
993 752
994 os << "\n Derived parameters for standard v 753 os << "\n Derived parameters for standard view of object of unit radius:";
995 G4ViewParameters tempVP = v; 754 G4ViewParameters tempVP = v;
996 tempVP.fDolly = 0.; 755 tempVP.fDolly = 0.;
997 tempVP.fZoomFactor = 1.; 756 tempVP.fZoomFactor = 1.;
998 const G4double radius = 1.; 757 const G4double radius = 1.;
999 const G4double cameraDistance = tempVP.GetCa 758 const G4double cameraDistance = tempVP.GetCameraDistance (radius);
1000 const G4double nearDistance = 759 const G4double nearDistance =
1001 tempVP.GetNearDistance (cameraDistance, r 760 tempVP.GetNearDistance (cameraDistance, radius);
1002 const G4double farDistance = 761 const G4double farDistance =
1003 tempVP.GetFarDistance (cameraDistance, n 762 tempVP.GetFarDistance (cameraDistance, nearDistance, radius);
1004 const G4double right = tempVP.GetFrontHalf 763 const G4double right = tempVP.GetFrontHalfHeight (nearDistance, radius);
1005 os << "\n Camera distance: " << camera 764 os << "\n Camera distance: " << cameraDistance;
1006 os << "\n Near distance: " << nearDi 765 os << "\n Near distance: " << nearDistance;
1007 os << "\n Far distance: " << farDis 766 os << "\n Far distance: " << farDistance;
1008 os << "\n Front half height: " << right; 767 os << "\n Front half height: " << right;
1009 768
1010 os << "\n Default VisAttributes:\n " << v 769 os << "\n Default VisAttributes:\n " << v.fDefaultVisAttributes;
1011 770
1012 os << "\n Default TextVisAttributes:\n " 771 os << "\n Default TextVisAttributes:\n " << v.fDefaultTextVisAttributes;
1013 772
1014 os << "\n Default marker:\n " << v.fDef << 773 os << "\n Default marker: " << v.fDefaultMarker;
1015 774
1016 os << "\n Global marker scale: " << v.fGlo 775 os << "\n Global marker scale: " << v.fGlobalMarkerScale;
1017 776
1018 os << "\n Global lineWidth scale: " << v.f 777 os << "\n Global lineWidth scale: " << v.fGlobalLineWidthScale;
1019 778
1020 os << "\n Marker "; 779 os << "\n Marker ";
1021 if (v.fMarkerNotHidden) os << "not "; 780 if (v.fMarkerNotHidden) os << "not ";
1022 os << "hidden by surfaces."; 781 os << "hidden by surfaces.";
1023 782
1024 os << "\n Window size hint: " 783 os << "\n Window size hint: "
1025 << v.fWindowSizeHintX << 'x'<< v.fWindow 784 << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
1026 785
1027 os << "\n X geometry string: " << v.fXGeom 786 os << "\n X geometry string: " << v.fXGeometryString;
1028 os << "\n X geometry mask: " 787 os << "\n X geometry mask: "
1029 << std::showbase << std::hex << v.fGeome 788 << std::showbase << std::hex << v.fGeometryMask
1030 << std::noshowbase << std::dec; 789 << std::noshowbase << std::dec;
1031 790
1032 os << "\n Auto refresh: "; 791 os << "\n Auto refresh: ";
1033 if (v.fAutoRefresh) os << "true"; 792 if (v.fAutoRefresh) os << "true";
1034 else os << "false"; 793 else os << "false";
1035 794
1036 os << "\n Background colour: " << v.fBackg 795 os << "\n Background colour: " << v.fBackgroundColour;
1037 796
1038 os << "\n Picking requested: "; 797 os << "\n Picking requested: ";
1039 if (v.fPicking) os << "true"; 798 if (v.fPicking) os << "true";
1040 else os << "false"; 799 else os << "false";
1041 800
1042 os << "\n Rotation style: "; 801 os << "\n Rotation style: ";
1043 switch (v.fRotationStyle) { 802 switch (v.fRotationStyle) {
1044 case G4ViewParameters::constrainUpDirection 803 case G4ViewParameters::constrainUpDirection:
1045 os << "constrainUpDirection (conventional 804 os << "constrainUpDirection (conventional HEP view)"; break;
1046 case G4ViewParameters::freeRotation: 805 case G4ViewParameters::freeRotation:
1047 os << "freeRotation (Google-like rotation 806 os << "freeRotation (Google-like rotation, using mouse-grab)"; break;
1048 default: os << "unrecognised"; break; 807 default: os << "unrecognised"; break;
1049 } 808 }
1050 809
1051 os << "\nVis attributes modifiers: "; << 810 os << "\n Vis attributes modifiers: ";
1052 const std::vector<G4ModelingParameters::Vis 811 const std::vector<G4ModelingParameters::VisAttributesModifier>& vams =
1053 v.fVisAttributesModifiers; 812 v.fVisAttributesModifiers;
1054 if (vams.empty()) { 813 if (vams.empty()) {
1055 os << "None"; 814 os << "None";
1056 } else { 815 } else {
1057 os << vams; 816 os << vams;
1058 } 817 }
1059 818
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; 819 return os;
1100 } 820 }
1101 821
1102 G4bool G4ViewParameters::operator != (const G 822 G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
1103 823
1104 // Put performance-sensitive parameters fir 824 // Put performance-sensitive parameters first.
1105 if ( 825 if (
1106 // This first to optimise spin, etc. 826 // This first to optimise spin, etc.
1107 (fViewpointDirection != v.fViewpointD 827 (fViewpointDirection != v.fViewpointDirection) ||
1108 828
1109 // No particular order from here on. 829 // No particular order from here on.
1110 (fDrawingStyle != v.fDrawingSty 830 (fDrawingStyle != v.fDrawingStyle) ||
1111 (fNumberOfCloudPoints != v.fNumberOfCl <<
1112 (fAuxEdgeVisible != v.fAuxEdgeVis 831 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
>> 832 (fRepStyle != v.fRepStyle) ||
1113 (fCulling != v.fCulling) 833 (fCulling != v.fCulling) ||
1114 (fCullInvisible != v.fCullInvisi 834 (fCullInvisible != v.fCullInvisible) ||
1115 (fDensityCulling != v.fDensityCul 835 (fDensityCulling != v.fDensityCulling) ||
1116 (fCullCovered != v.fCullCovere 836 (fCullCovered != v.fCullCovered) ||
1117 (fCBDAlgorithmNumber != v.fCBDAlgorit <<
1118 (fSection != v.fSection) 837 (fSection != v.fSection) ||
1119 (IsCutaway() != v.IsCutaway() 838 (IsCutaway() != v.IsCutaway()) ||
1120 (IsExplode() != v.IsExplode() 839 (IsExplode() != v.IsExplode()) ||
1121 (fNoOfSides != v.fNoOfSides) 840 (fNoOfSides != v.fNoOfSides) ||
1122 (fUpVector != v.fUpVector) 841 (fUpVector != v.fUpVector) ||
1123 (fFieldHalfAngle != v.fFieldHalfA 842 (fFieldHalfAngle != v.fFieldHalfAngle) ||
1124 (fZoomFactor != v.fZoomFactor 843 (fZoomFactor != v.fZoomFactor) ||
1125 (fScaleFactor != v.fScaleFacto 844 (fScaleFactor != v.fScaleFactor) ||
1126 (fCurrentTargetPoint != v.fCurrentTar 845 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
1127 (fDolly != v.fDolly) 846 (fDolly != v.fDolly) ||
1128 (fRelativeLightpointDirection != v.fRel 847 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
1129 (fLightsMoveWithCamera != v.fLightsMove 848 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
1130 (fDefaultVisAttributes != v.fDefaultVis 849 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
1131 (fDefaultTextVisAttributes != v.fDefaul 850 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
1132 (fDefaultMarker != v.fDefaultMar 851 (fDefaultMarker != v.fDefaultMarker) ||
1133 (fGlobalMarkerScale != v.fGlobalMark 852 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
1134 (fGlobalLineWidthScale != v.fGlobalLine 853 (fGlobalLineWidthScale != v.fGlobalLineWidthScale) ||
1135 (fMarkerNotHidden != v.fMarkerNotH 854 (fMarkerNotHidden != v.fMarkerNotHidden) ||
1136 (fWindowSizeHintX != v.fWindowSize 855 (fWindowSizeHintX != v.fWindowSizeHintX) ||
1137 (fWindowSizeHintY != v.fWindowSize 856 (fWindowSizeHintY != v.fWindowSizeHintY) ||
1138 (fXGeometryString != v.fXGeometryS 857 (fXGeometryString != v.fXGeometryString) ||
1139 (fGeometryMask != v.fGeometryMa 858 (fGeometryMask != v.fGeometryMask) ||
1140 (fAutoRefresh != v.fAutoRefres 859 (fAutoRefresh != v.fAutoRefresh) ||
1141 (fBackgroundColour != v.fBackground 860 (fBackgroundColour != v.fBackgroundColour) ||
1142 (fPicking != v.fPicking) 861 (fPicking != v.fPicking) ||
1143 (fRotationStyle != v.fRotationSt << 862 (fRotationStyle != v.fRotationStyle)
1144 (fSpecialMeshRendering != v.fSpecialMes <<
1145 (fSpecialMeshRenderingOption != v.fSpec <<
1146 ) 863 )
1147 return true; 864 return true;
1148 865
1149 if (fDensityCulling && 866 if (fDensityCulling &&
1150 (fVisibleDensity != v.fVisibleDensity)) 867 (fVisibleDensity != v.fVisibleDensity)) return true;
1151 868
1152 if (fCBDAlgorithmNumber > 0) { <<
1153 if (fCBDParameters.size() != v.fCBDParame <<
1154 else if (fCBDParameters != v.fCBDParamete <<
1155 } <<
1156 <<
1157 if (fSection && 869 if (fSection &&
1158 (!(fSectionPlane == v.fSectionPlane))) 870 (!(fSectionPlane == v.fSectionPlane))) return true;
1159 871
1160 if (IsCutaway()) { 872 if (IsCutaway()) {
1161 if (fCutawayPlanes.size () != v.fCutawayP 873 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
1162 return true; 874 return true;
1163 else { 875 else {
1164 for (size_t i = 0; i < fCutawayPlanes.s 876 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
1165 if (!(fCutawayPlanes[i] == v.fCutawayPlanes 877 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
1166 } 878 }
1167 } 879 }
1168 } 880 }
1169 881
1170 if (IsExplode() && 882 if (IsExplode() &&
1171 ((fExplodeFactor != v.fExplodeFactor) | 883 ((fExplodeFactor != v.fExplodeFactor) ||
1172 (fExplodeCentre != v.fExplodeCentre))) 884 (fExplodeCentre != v.fExplodeCentre))) return true;
1173 885
1174 if (fVisAttributesModifiers != v.fVisAttrib << 886 if (G4ModelingParameters::VAMSNotEqual
>> 887 (fVisAttributesModifiers, v.fVisAttributesModifiers))
>> 888 return true;
1175 889
1176 if (fStartTime != v.fStartTime || << 890 return false;
1177 fEndTime != v.fEndTime || << 891 }
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 892
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 893
1205 if (fSpecialMeshRendering) { << 894 void G4ViewParameters::SetXGeometryString (const G4String& geomStringArg) {
1206 if (fSpecialMeshVolumes != v.fSpecialMesh <<
1207 return true;; <<
1208 } <<
1209 895
1210 return false; <<
1211 } <<
1212 896
1213 void G4ViewParameters::SetXGeometryString (co << 897 G4int x,y = 0;
1214 { << 898 unsigned int w,h = 0;
>> 899 G4String geomString = geomStringArg;
>> 900 // Parse windowSizeHintString for backwards compatibility...
1215 const G4String delimiters("xX+-"); 901 const G4String delimiters("xX+-");
1216 G4String::size_type i = geomString.find_fir 902 G4String::size_type i = geomString.find_first_of(delimiters);
1217 if (i == G4String::npos) { << 903 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); 904 std::istringstream iss(geomString);
1221 G4int size; 905 G4int size;
1222 iss >> size; 906 iss >> size;
1223 if (iss) { << 907 if (!iss) {
1224 // It is a number << 908 size = 600;
1225 fWindowSizeHintX = size; << 909 G4cout << "Unrecognised windowSizeHint string: \""
1226 fWindowSizeHintY = size; << 910 << geomString
>> 911 << "\". Asuuming " << size << G4endl;
1227 } 912 }
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; 913 std::ostringstream oss;
1234 oss << fWindowSizeHintX << 'x' << fWindow << 914 oss << size << 'x' << size;
1235 << signX << fWindowLocationHintX << signY << 915 geomString = oss.str();
1236 fXGeometryString = oss.str(); <<
1237 return; <<
1238 } 916 }
1239 << 917
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, 918 fGeometryMask = ParseGeometry( geomString, &x, &y, &w, &h );
1244 919
1245 // Handle special case : 920 // Handle special case :
1246 if ((fGeometryMask & fYValue) == 0) 921 if ((fGeometryMask & fYValue) == 0)
1247 { // Using default 922 { // Using default
1248 y = fWindowLocationHintY; 923 y = fWindowLocationHintY;
1249 } 924 }
1250 if ((fGeometryMask & fXValue) == 0) 925 if ((fGeometryMask & fXValue) == 0)
1251 { // Using default 926 { // Using default
1252 x = fWindowLocationHintX; 927 x = fWindowLocationHintX;
1253 } 928 }
1254 929
1255 // Check errors 930 // Check errors
1256 // if there is no Width and Height 931 // if there is no Width and Height
1257 if ( ((fGeometryMask & fHeightValue) == 0 ) 932 if ( ((fGeometryMask & fHeightValue) == 0 ) &&
1258 ((fGeometryMask & fWidthValue) == 0 ) 933 ((fGeometryMask & fWidthValue) == 0 )) {
1259 h = fWindowSizeHintY; 934 h = fWindowSizeHintY;
1260 w = fWindowSizeHintX; 935 w = fWindowSizeHintX;
1261 } else if ((fGeometryMask & fHeightValue) 936 } else if ((fGeometryMask & fHeightValue) == 0 ) {
1262 937
1263 // if there is only Width. Special case t 938 // if there is only Width. Special case to be backward compatible
1264 // We set Width and Height the same to ob 939 // We set Width and Height the same to obtain a square windows.
1265 940
1266 G4warn << "Unrecognised geometry string \ << 941 G4cout << "Unrecognised geometry string \""
1267 << geomString 942 << geomString
1268 << "\". No Height found. Using Wi 943 << "\". No Height found. Using Width value instead"
1269 << G4endl; 944 << G4endl;
1270 h = w; 945 h = w;
1271 } 946 }
1272 if ( ((fGeometryMask & fXValue) == 0 ) || 947 if ( ((fGeometryMask & fXValue) == 0 ) ||
1273 ((fGeometryMask & fYValue) == 0 )) { 948 ((fGeometryMask & fYValue) == 0 )) {
1274 //Using defaults 949 //Using defaults
1275 x = fWindowLocationHintX; 950 x = fWindowLocationHintX;
1276 y = fWindowLocationHintY; 951 y = fWindowLocationHintY;
1277 } 952 }
1278 // Set the string 953 // Set the string
1279 fXGeometryString = geomString; 954 fXGeometryString = geomString;
1280 955
1281 // Set values 956 // Set values
1282 fWindowSizeHintX = w; 957 fWindowSizeHintX = w;
1283 fWindowSizeHintY = h; 958 fWindowSizeHintY = h;
1284 fWindowLocationHintX = x; 959 fWindowLocationHintX = x;
1285 fWindowLocationHintY = y; 960 fWindowLocationHintY = y;
1286 961
1287 if ( ((fGeometryMask & fXValue)) && 962 if ( ((fGeometryMask & fXValue)) &&
1288 ((fGeometryMask & fYValue))) { 963 ((fGeometryMask & fYValue))) {
1289 964
1290 if ( (fGeometryMask & fXNegative) ) { 965 if ( (fGeometryMask & fXNegative) ) {
1291 fWindowLocationHintXNegative = true; 966 fWindowLocationHintXNegative = true;
1292 } else { 967 } else {
1293 fWindowLocationHintXNegative = false; 968 fWindowLocationHintXNegative = false;
1294 } 969 }
1295 if ( (fGeometryMask & fYNegative) ) { 970 if ( (fGeometryMask & fYNegative) ) {
1296 fWindowLocationHintYNegative = true; 971 fWindowLocationHintYNegative = true;
1297 } else { 972 } else {
1298 fWindowLocationHintYNegative = false; 973 fWindowLocationHintYNegative = false;
1299 } 974 }
1300 } 975 }
1301 } 976 }
1302 977
1303 G4int G4ViewParameters::GetWindowAbsoluteLoca 978 G4int G4ViewParameters::GetWindowAbsoluteLocationHintX (G4int sizeX ) const {
1304 if ( fWindowLocationHintXNegative ) { 979 if ( fWindowLocationHintXNegative ) {
1305 return sizeX + fWindowLocationHintX - f 980 return sizeX + fWindowLocationHintX - fWindowSizeHintX;
1306 } 981 }
1307 return fWindowLocationHintX; 982 return fWindowLocationHintX;
1308 } 983 }
1309 984
1310 G4int G4ViewParameters::GetWindowAbsoluteLoca 985 G4int G4ViewParameters::GetWindowAbsoluteLocationHintY (G4int sizeY ) const {
1311 if ( fWindowLocationHintYNegative ) { 986 if ( fWindowLocationHintYNegative ) {
1312 return sizeY + fWindowLocationHintY - f 987 return sizeY + fWindowLocationHintY - fWindowSizeHintY;
1313 } 988 }
1314 return fWindowLocationHintY; 989 return fWindowLocationHintY;
1315 } 990 }
1316 991
1317 /* Keep from : 992 /* Keep from :
1318 * ftp://ftp.trolltech.com/qt/source/qt-embed 993 * 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 * 994 *
1320 * ParseGeometry parses strings of the for 995 * ParseGeometry parses strings of the form
1321 * "=<width>x<height>{+-}<xoffset>{+-}<yoff 996 * "=<width>x<height>{+-}<xoffset>{+-}<yoffset>", where
1322 * width, height, xoffset, and yoffset are 997 * width, height, xoffset, and yoffset are unsigned integers.
1323 * Example: "=80x24+300-49" 998 * Example: "=80x24+300-49"
1324 * The equal sign is optional. 999 * The equal sign is optional.
1325 * It returns a bitmask that indicates whic 1000 * It returns a bitmask that indicates which of the four values
1326 * were actually found in the string. For e 1001 * were actually found in the string. For each value found,
1327 * the corresponding argument is updated; 1002 * the corresponding argument is updated; for each value
1328 * not found, the corresponding argument is 1003 * not found, the corresponding argument is left unchanged.
1329 */ 1004 */
1330 1005
1331 int G4ViewParameters::ParseGeometry ( 1006 int G4ViewParameters::ParseGeometry (
1332 const char *string, 1007 const char *string,
1333 G4int *x, 1008 G4int *x,
1334 G4int *y, 1009 G4int *y,
1335 unsigned int *width, 1010 unsigned int *width,
1336 unsigned int *height) 1011 unsigned int *height)
1337 { 1012 {
1338 1013
1339 G4int mask = fNoValue; 1014 G4int mask = fNoValue;
1340 char *strind; << 1015 register char *strind;
1341 unsigned int tempWidth = 0; 1016 unsigned int tempWidth = 0;
1342 unsigned int tempHeight = 0; 1017 unsigned int tempHeight = 0;
1343 G4int tempX = 0; 1018 G4int tempX = 0;
1344 G4int tempY = 0; 1019 G4int tempY = 0;
1345 char *nextCharacter; 1020 char *nextCharacter;
1346 if ( (string == NULL) || (*string == '\0')) 1021 if ( (string == NULL) || (*string == '\0')) {
1347 return(mask); 1022 return(mask);
1348 } 1023 }
1349 if (*string == '=') 1024 if (*string == '=')
1350 string++; /* ignore possible '=' at beg 1025 string++; /* ignore possible '=' at beg of geometry spec */
1351 strind = (char *)string; 1026 strind = (char *)string;
1352 if (*strind != '+' && *strind != '-' && *st 1027 if (*strind != '+' && *strind != '-' && *strind != 'x') {
1353 tempWidth = ReadInteger(strind, &nextChar 1028 tempWidth = ReadInteger(strind, &nextCharacter);
1354 if (strind == nextCharacter) 1029 if (strind == nextCharacter)
1355 return (0); 1030 return (0);
1356 strind = nextCharacter; 1031 strind = nextCharacter;
1357 mask |= fWidthValue; 1032 mask |= fWidthValue;
1358 } 1033 }
1359 if (*strind == 'x' || *strind == 'X') { 1034 if (*strind == 'x' || *strind == 'X') {
1360 strind++; 1035 strind++;
1361 tempHeight = ReadInteger(strind, &nextCha 1036 tempHeight = ReadInteger(strind, &nextCharacter);
1362 if (strind == nextCharacter) 1037 if (strind == nextCharacter)
1363 return (0); 1038 return (0);
1364 strind = nextCharacter; 1039 strind = nextCharacter;
1365 mask |= fHeightValue; 1040 mask |= fHeightValue;
1366 } 1041 }
1367 1042
1368 if ((*strind == '+') || (*strind == '-')) { 1043 if ((*strind == '+') || (*strind == '-')) {
1369 if (*strind == '-') { 1044 if (*strind == '-') {
1370 strind++; 1045 strind++;
1371 tempX = -ReadInteger(strind, &nextChara 1046 tempX = -ReadInteger(strind, &nextCharacter);
1372 if (strind == nextCharacter) 1047 if (strind == nextCharacter)
1373 return (0); 1048 return (0);
1374 strind = nextCharacter; 1049 strind = nextCharacter;
1375 mask |= fXNegative; 1050 mask |= fXNegative;
1376 1051
1377 } 1052 }
1378 else 1053 else
1379 { strind++; 1054 { strind++;
1380 tempX = ReadInteger(strind, &nextChar 1055 tempX = ReadInteger(strind, &nextCharacter);
1381 if (strind == nextCharacter) 1056 if (strind == nextCharacter)
1382 return(0); 1057 return(0);
1383 strind = nextCharacter; 1058 strind = nextCharacter;
1384 } 1059 }
1385 mask |= fXValue; 1060 mask |= fXValue;
1386 if ((*strind == '+') || (*strind == '-')) 1061 if ((*strind == '+') || (*strind == '-')) {
1387 if (*strind == '-') { 1062 if (*strind == '-') {
1388 strind++; 1063 strind++;
1389 tempY = -ReadInteger(strind, &nextCha 1064 tempY = -ReadInteger(strind, &nextCharacter);
1390 if (strind == nextCharacter) 1065 if (strind == nextCharacter)
1391 return(0); 1066 return(0);
1392 strind = nextCharacter; 1067 strind = nextCharacter;
1393 mask |= fYNegative; 1068 mask |= fYNegative;
1394 } 1069 }
1395 else 1070 else
1396 { 1071 {
1397 strind++; 1072 strind++;
1398 tempY = ReadInteger(strind, &nextCh 1073 tempY = ReadInteger(strind, &nextCharacter);
1399 if (strind == nextCharacter) 1074 if (strind == nextCharacter)
1400 return(0); 1075 return(0);
1401 strind = nextCharacter; 1076 strind = nextCharacter;
1402 } 1077 }
1403 mask |= fYValue; 1078 mask |= fYValue;
1404 } 1079 }
1405 } 1080 }
1406 /* If strind isn't at the end of the string 1081 /* If strind isn't at the end of the string the it's an invalid
1407 geometry specification. */ 1082 geometry specification. */
1408 if (*strind != '\0') return (0); 1083 if (*strind != '\0') return (0);
1409 if (mask & fXValue) 1084 if (mask & fXValue)
1410 *x = tempX; 1085 *x = tempX;
1411 if (mask & fYValue) 1086 if (mask & fYValue)
1412 *y = tempY; 1087 *y = tempY;
1413 if (mask & fWidthValue) 1088 if (mask & fWidthValue)
1414 *width = tempWidth; 1089 *width = tempWidth;
1415 if (mask & fHeightValue) 1090 if (mask & fHeightValue)
1416 *height = tempHeight; 1091 *height = tempHeight;
1417 return (mask); 1092 return (mask);
1418 } 1093 }
1419 1094
1420 /* Keep from : 1095 /* Keep from :
1421 * ftp://ftp.trolltech.com/qt/source/qt-embed 1096 * 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 * 1097 *
1423 */ 1098 */
1424 G4int G4ViewParameters::ReadInteger(char *str 1099 G4int G4ViewParameters::ReadInteger(char *string, char **NextString)
1425 { 1100 {
1426 G4int Result = 0; << 1101 register G4int Result = 0;
1427 G4int Sign = 1; 1102 G4int Sign = 1;
1428 1103
1429 if (*string == '+') 1104 if (*string == '+')
1430 string++; 1105 string++;
1431 else if (*string == '-') 1106 else if (*string == '-')
1432 { 1107 {
1433 string++; 1108 string++;
1434 Sign = -1; 1109 Sign = -1;
1435 } 1110 }
1436 for (; (*string >= '0') && (*string <= '9 1111 for (; (*string >= '0') && (*string <= '9'); string++)
1437 { 1112 {
1438 Result = (Result * 10) + (*string - '0'); 1113 Result = (Result * 10) + (*string - '0');
1439 } 1114 }
1440 *NextString = string; 1115 *NextString = string;
1441 if (Sign >= 0) 1116 if (Sign >= 0)
1442 return (Result); 1117 return (Result);
1443 else 1118 else
1444 return (-Result); 1119 return (-Result);
1445 } <<
1446 <<
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 } 1120 }
1721 1121