| Geant4 Cross Reference |
>> 1 // This code implementation is the intellectual property of
>> 2 // the GEANT4 collaboration.
1 // 3 //
2 // ******************************************* << 4 // By copying, distributing or modifying the Program (or any work
3 // * License and Disclaimer << 5 // based on the Program) you indicate your acceptance of this statement,
4 // * << 6 // and all its terms.
5 // * The Geant4 software is copyright of th <<
6 // * the Geant4 Collaboration. It is provided <<
7 // * conditions of the Geant4 Software License <<
8 // * LICENSE and available at http://cern.ch/ <<
9 // * include a list of copyright holders. <<
10 // * <<
11 // * Neither the authors of this software syst <<
12 // * institutes,nor the agencies providing fin <<
13 // * work make any representation or warran <<
14 // * regarding this software system or assum <<
15 // * use. Please see the license in the file <<
16 // * for the full disclaimer and the limitatio <<
17 // * <<
18 // * This code implementation is the result <<
19 // * technical work of the GEANT4 collaboratio <<
20 // * By using, copying, modifying or distri <<
21 // * any work based on the software) you ag <<
22 // * use in resulting scientific publicati <<
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* <<
25 // <<
26 // 7 //
>> 8 // $Id: G4ViewParameters.cc,v 1.5 1999/12/15 14:54:25 gunter Exp $
>> 9 // GEANT4 tag $Name: geant4-01-01 $
27 // 10 //
28 // 11 //
29 // John Allison 19th July 1996 12 // John Allison 19th July 1996
30 // View parameters and options. 13 // View parameters and options.
31 14
32 #include "G4ViewParameters.hh" 15 #include "G4ViewParameters.hh"
33 16
34 #include "G4VisManager.hh" 17 #include "G4VisManager.hh"
35 #include "G4VPhysicalVolume.hh" << 18 #include "G4ios.hh"
36 #include "G4UnitsTable.hh" <<
37 #include "G4SystemOfUnits.hh" <<
38 #include "G4Polyhedron.hh" <<
39 <<
40 #include <sstream> <<
41 #include <cmath> <<
42 <<
43 #define G4warn G4cout <<
44 19
45 G4ViewParameters::G4ViewParameters (): 20 G4ViewParameters::G4ViewParameters ():
46 fDrawingStyle (wireframe), 21 fDrawingStyle (wireframe),
47 fNumberOfCloudPoints(10000), << 22 fRepStyle (polyhedron),
48 fAuxEdgeVisible (false), <<
49 fCulling (true), 23 fCulling (true),
50 fCullInvisible (true), 24 fCullInvisible (true),
51 fDensityCulling (false), 25 fDensityCulling (false),
52 fVisibleDensity (0.01 * g / cm3), 26 fVisibleDensity (0.01 * g / cm3),
53 fCullCovered (false), 27 fCullCovered (false),
54 fCBDAlgorithmNumber (0), <<
55 fSection (false), 28 fSection (false),
56 fSectionPlane (), << 29 fCutaway (false),
57 fCutawayMode (cutawayUnion), << 30 fExplode (false),
58 fCutawayPlanes (), <<
59 fExplodeFactor (1.), 31 fExplodeFactor (1.),
60 fNoOfSides (), << 32 fNoOfSides (24),
61 fViewpointDirection (G4Vector3D (0., 0., 1.) 33 fViewpointDirection (G4Vector3D (0., 0., 1.)), // On z-axis.
62 fUpVector (G4Vector3D (0., 1., 0.)), 34 fUpVector (G4Vector3D (0., 1., 0.)), // y-axis up.
63 fFieldHalfAngle (0.), 35 fFieldHalfAngle (0.), // Orthogonal projection.
64 fZoomFactor (1.), 36 fZoomFactor (1.),
65 fScaleFactor (G4Vector3D (1., 1., 1.)), <<
66 fCurrentTargetPoint (), <<
67 fDolly (0.), 37 fDolly (0.),
68 fLightsMoveWithCamera (false), <<
69 fRelativeLightpointDirection (G4Vector3D (1. 38 fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
70 fActualLightpointDirection (G4Vector3D (1., 39 fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
71 fDefaultVisAttributes (), << 40 fLightsMoveWithCamera (false),
>> 41 fViewGeom (true),
>> 42 fViewHits (true),
>> 43 fViewDigis (true),
72 fDefaultTextVisAttributes (G4Colour (0., 0., 44 fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
73 fDefaultMarker (), <<
74 fGlobalMarkerScale (1.), 45 fGlobalMarkerScale (1.),
75 fGlobalLineWidthScale (1.), <<
76 fMarkerNotHidden (true), 46 fMarkerNotHidden (true),
77 fWindowSizeHintX (600), 47 fWindowSizeHintX (600),
78 fWindowSizeHintY (600), << 48 fWindowSizeHintY (600)
79 fWindowLocationHintX(0), << 49 // Note: all other parameters use default constructors.
80 fWindowLocationHintY(0), <<
81 fWindowLocationHintXNegative(true), <<
82 fWindowLocationHintYNegative(false), <<
83 fGeometryMask(0), <<
84 fAutoRefresh (false), <<
85 fBackgroundColour (G4Colour(0.,0.,0.)), <<
86 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 { 50 {
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.); 51 fDefaultMarker.SetScreenSize (5.);
119 // Markers are 5 pixels "overall" size, i.e. << 52 // Markers are 5 pixels radius, 10 pixels diameter.
120 } 53 }
121 54
122 G4ViewParameters::~G4ViewParameters () {} << 55 G4ViewParameters::~G4ViewParameters () {
123 << 56 // Clear cutaway planes? Rogue Wave probably destroys OK.
124 void G4ViewParameters::MultiplyScaleFactor <<
125 (const G4Vector3D& scaleFactorMultiplier) { <<
126 fScaleFactor.setX(fScaleFactor.x() * scaleFa <<
127 fScaleFactor.setY(fScaleFactor.y() * scaleFa <<
128 fScaleFactor.setZ(fScaleFactor.z() * scaleFa <<
129 } 57 }
130 58
131 G4Vector3D& G4ViewParameters::GetActualLightpo 59 G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
132 SetViewAndLights (fViewpointDirection); 60 SetViewAndLights (fViewpointDirection);
133 return fActualLightpointDirection; 61 return fActualLightpointDirection;
134 } 62 }
135 63
136 // Useful quantities - begin snippet. 64 // Useful quantities - begin snippet.
137 // Here Follow functions to evaluate the above 65 // Here Follow functions to evaluate the above algorithms as a
138 // function of the radius of the Bounding Sphe 66 // function of the radius of the Bounding Sphere of the object being
139 // viewed. Call them in the order given - for 67 // viewed. Call them in the order given - for efficiency, later
140 // functions depend on the results of earlier 68 // functions depend on the results of earlier ones (Store the
141 // results of earlier functions in your own te 69 // results of earlier functions in your own temporary variables -
142 // see, for example, G4OpenGLView::SetView (). 70 // see, for example, G4OpenGLView::SetView ().)
143 71
144 G4double G4ViewParameters::GetCameraDistance ( 72 G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
145 G4double cameraDistance; 73 G4double cameraDistance;
146 if (fFieldHalfAngle == 0.) { 74 if (fFieldHalfAngle == 0.) {
147 cameraDistance = radius; 75 cameraDistance = radius;
148 } 76 }
149 else { 77 else {
150 cameraDistance = radius / std::sin (fField << 78 cameraDistance = radius / sin (fFieldHalfAngle) - fDolly;
151 } 79 }
152 return cameraDistance; 80 return cameraDistance;
153 } 81 }
154 82
155 G4double G4ViewParameters::GetNearDistance (G4 83 G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
156 G4double radius) const { 84 G4double radius) const {
157 const G4double small = 1.e-6 * radius; 85 const G4double small = 1.e-6 * radius;
158 G4double nearDistance = cameraDistance - rad 86 G4double nearDistance = cameraDistance - radius;
159 if (nearDistance < small) nearDistance = sma 87 if (nearDistance < small) nearDistance = small;
160 return nearDistance; 88 return nearDistance;
161 } 89 }
162 90
163 G4double G4ViewParameters::GetFarDistance (G4d 91 G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
164 G4double nearDistance, 92 G4double nearDistance,
165 G4double radius) const { 93 G4double radius) const {
166 G4double farDistance = cameraDistance + radi 94 G4double farDistance = cameraDistance + radius;
167 if (farDistance < nearDistance) farDistance 95 if (farDistance < nearDistance) farDistance = nearDistance;
168 return farDistance; 96 return farDistance;
169 } 97 }
170 98
171 G4double G4ViewParameters::GetFrontHalfHeight 99 G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
172 G4double radius) const { 100 G4double radius) const {
173 G4double frontHalfHeight; 101 G4double frontHalfHeight;
174 if (fFieldHalfAngle == 0.) { 102 if (fFieldHalfAngle == 0.) {
175 frontHalfHeight = radius / fZoomFactor; 103 frontHalfHeight = radius / fZoomFactor;
176 } 104 }
177 else { 105 else {
178 frontHalfHeight = nearDistance * std::tan << 106 frontHalfHeight = nearDistance * tan (fFieldHalfAngle) / fZoomFactor;
179 } 107 }
180 return frontHalfHeight; 108 return frontHalfHeight;
181 } 109 }
182 // Useful quantities - end snippet. 110 // Useful quantities - end snippet.
183 111
184 void G4ViewParameters::AddCutawayPlane (const 112 void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
185 if (fCutawayPlanes.size () < 3 ) { << 113 fCutaway = true;
186 fCutawayPlanes.push_back (cutawayPlane); << 114 if (fCutawayPlanes.entries () < 3 ) {
>> 115 fCutawayPlanes.insert (cutawayPlane);
187 } 116 }
188 else { 117 else {
189 G4warn << << 118 G4cerr << "A maximum of 3 cutaway planes supported." << G4endl;
190 "ERROR: G4ViewParameters::AddCutawayPlan <<
191 "\n A maximum of 3 cutaway planes suppo <<
192 } 119 }
193 } 120 }
194 121
195 void G4ViewParameters::ChangeCutawayPlane << 122 void G4ViewParameters::ClearCutawayPlanes () {
196 (size_t index, const G4Plane3D& cutawayPlane) << 123 fCutaway = false;
197 if (index >= fCutawayPlanes.size()) { << 124 fCutawayPlanes.clear ();
198 G4warn << <<
199 "ERROR: G4ViewParameters::ChangeCutawayP <<
200 "\n Plane " << index << " does not exis <<
201 } else { <<
202 fCutawayPlanes[index] = cutawayPlane; <<
203 } <<
204 } 125 }
205 126
206 void G4ViewParameters::SetVisibleDensity (G4do 127 void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
207 const G4double reasonableMaximum = 10.0 * g 128 const G4double reasonableMaximum = 10.0 * g / cm3;
208 if (visibleDensity < 0) { 129 if (visibleDensity < 0) {
209 G4warn << "G4ViewParameters::SetVisibleDen << 130 G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
210 "density - ignored." << G4endl; 131 "density - ignored." << G4endl;
211 } 132 }
212 else { 133 else {
213 if (visibleDensity > reasonableMaximum) { << 134 if (fVisibleDensity > reasonableMaximum) {
214 G4warn << "G4ViewParameters::SetVisibleD << 135 G4cout << "G4ViewParameters::SetVisibleDensity: density > "
215 << G4BestUnit (reasonableMaximum, "Volu << 136 << reasonableMaximum
216 << " - did you mean this?" << 137 << " g / cm3 - did you mean this?"
217 << G4endl; << 138 << G4endl;
218 } 139 }
219 fVisibleDensity = visibleDensity; 140 fVisibleDensity = visibleDensity;
220 } 141 }
221 } 142 }
222 143
223 G4int G4ViewParameters::SetNoOfSides (G4int nS << 144 void G4ViewParameters::SetNoOfSides (G4int nSides) {
224 const G4int nSidesMin = fDefaultVisAttribute << 145 const G4int nSidesMin = 3;
225 if (nSides < nSidesMin) { 146 if (nSides < nSidesMin) {
226 nSides = nSidesMin; 147 nSides = nSidesMin;
227 G4warn << "G4ViewParameters::SetNoOfSides: << 148 G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
228 "\nnumber of sides per circle < " << nSide << 149 "\nnumber of sides per circle < " << nSidesMin
229 << "; forced to " << nSides << G4endl; << 150 << "; forced to" << nSides << G4endl;
230 } 151 }
231 fNoOfSides = nSides; 152 fNoOfSides = nSides;
232 return fNoOfSides; <<
233 } <<
234 <<
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 } 153 }
246 154
247 void G4ViewParameters::SetViewAndLights 155 void G4ViewParameters::SetViewAndLights
248 (const G4Vector3D& viewpointDirection) { 156 (const G4Vector3D& viewpointDirection) {
249 <<
250 fViewpointDirection = viewpointDirection; 157 fViewpointDirection = viewpointDirection;
251 <<
252 // If the requested viewpoint direction is p <<
253 // vector, the orientation of the view is un <<
254 if (fViewpointDirection.unit() * fUpVector.u <<
255 static G4bool firstTime = true; <<
256 if (firstTime) { <<
257 firstTime = false; <<
258 G4warn << <<
259 "WARNING: Viewpoint direction is very cl <<
260 "\n Change the up vector or \"/vis/view <<
261 << G4endl; <<
262 } <<
263 } <<
264 <<
265 // Move the lights too if requested... <<
266 if (fLightsMoveWithCamera) { 158 if (fLightsMoveWithCamera) {
267 G4Vector3D zprime = fViewpointDirection.un << 159 G4Vector3D zprime = fViewpointDirection.unit ();
268 G4Vector3D xprime = (fUpVector.cross (zpri << 160 G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
269 G4Vector3D yprime = zprime.cross (xprime); << 161 G4Vector3D yprime = zprime.cross (xprime);
270 fActualLightpointDirection = << 162 fActualLightpointDirection =
271 fRelativeLightpointDirection.x () * xpri << 163 fRelativeLightpointDirection.x () * xprime +
272 fRelativeLightpointDirection.y () * ypri << 164 fRelativeLightpointDirection.y () * yprime +
273 fRelativeLightpointDirection.x () * zpri << 165 fRelativeLightpointDirection.x () * zprime;
274 } else { << 166 }
>> 167 else {
275 fActualLightpointDirection = fRelativeLigh 168 fActualLightpointDirection = fRelativeLightpointDirection;
276 } 169 }
277 } 170 }
278 171
279 void G4ViewParameters::SetLightpointDirection 172 void G4ViewParameters::SetLightpointDirection
280 (const G4Vector3D& lightpointDirection) { 173 (const G4Vector3D& lightpointDirection) {
281 fRelativeLightpointDirection = lightpointDir 174 fRelativeLightpointDirection = lightpointDirection;
282 SetViewAndLights (fViewpointDirection); 175 SetViewAndLights (fViewpointDirection);
283 } 176 }
284 177
285 void G4ViewParameters::SetPan (G4double right, << 178 void G4ViewParameters::Pan (G4double right, G4double up) {
286 G4Vector3D unitRight = (fUpVector.cross (fVi <<
287 G4Vector3D unitUp = (fViewpointDirection. <<
288 fCurrentTargetPoint = right * unitRight + u <<
289 } <<
290 <<
291 void G4ViewParameters::IncrementPan (G4double <<
292 IncrementPan (right,up, 0); <<
293 } <<
294 <<
295 void G4ViewParameters::IncrementPan (G4double <<
296 G4Vector3D unitRight = (fUpVector.cross (fVi 179 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
297 G4Vector3D unitUp = (fViewpointDirection. 180 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
298 fCurrentTargetPoint += right * unitRight + u << 181 fCurrentTargetPoint += right * unitRight + up * unitUp;
299 } <<
300 <<
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 } 182 }
758 183
759 void G4ViewParameters::PrintDifferences (const 184 void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
760 185
761 // Put performance-sensitive parameters firs 186 // Put performance-sensitive parameters first.
762 if ( 187 if (
763 // This first to optimise spin, etc. 188 // This first to optimise spin, etc.
764 (fViewpointDirection != v.fViewpointDi 189 (fViewpointDirection != v.fViewpointDirection) ||
765 190
766 // No particular order from here on. 191 // No particular order from here on.
767 (fDrawingStyle != v.fDrawingStyl 192 (fDrawingStyle != v.fDrawingStyle) ||
768 (fNumberOfCloudPoints != v.fNumberOfClo << 193 (fRepStyle != v.fRepStyle) ||
769 (fAuxEdgeVisible != v.fAuxEdgeVisi <<
770 (fCulling != v.fCulling) 194 (fCulling != v.fCulling) ||
771 (fCullInvisible != v.fCullInvisib 195 (fCullInvisible != v.fCullInvisible) ||
772 (fDensityCulling != v.fDensityCull 196 (fDensityCulling != v.fDensityCulling) ||
773 (fVisibleDensity != v.fVisibleDens 197 (fVisibleDensity != v.fVisibleDensity) ||
774 (fCullCovered != v.fCullCovered 198 (fCullCovered != v.fCullCovered) ||
775 (fCBDAlgorithmNumber != v.fCBDAlgorith <<
776 (fSection != v.fSection) 199 (fSection != v.fSection) ||
>> 200 (fCutaway != v.fCutaway) ||
>> 201 (fExplode != v.fExplode) ||
777 (fNoOfSides != v.fNoOfSides) 202 (fNoOfSides != v.fNoOfSides) ||
778 (fUpVector != v.fUpVector) 203 (fUpVector != v.fUpVector) ||
779 (fFieldHalfAngle != v.fFieldHalfAn 204 (fFieldHalfAngle != v.fFieldHalfAngle) ||
780 (fZoomFactor != v.fZoomFactor) 205 (fZoomFactor != v.fZoomFactor) ||
781 (fScaleFactor != v.fScaleFactor <<
782 (fCurrentTargetPoint != v.fCurrentTarg 206 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
783 (fDolly != v.fDolly) 207 (fDolly != v.fDolly) ||
784 (fRelativeLightpointDirection != v.fRela 208 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
785 (fLightsMoveWithCamera != v.fLightsMoveW 209 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
>> 210 (fViewGeom != v.fViewGeom) ||
>> 211 (fViewHits != v.fViewHits) ||
>> 212 (fViewDigis != v.fViewDigis) ||
786 (fDefaultVisAttributes != v.fDefaultVisA 213 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
787 (fDefaultTextVisAttributes != v.fDefault 214 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
788 (fDefaultMarker != v.fDefaultMark 215 (fDefaultMarker != v.fDefaultMarker) ||
789 (fGlobalMarkerScale != v.fGlobalMarke 216 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
790 (fGlobalLineWidthScale != v.fGlobalLineW <<
791 (fMarkerNotHidden != v.fMarkerNotHi 217 (fMarkerNotHidden != v.fMarkerNotHidden) ||
792 (fWindowSizeHintX != v.fWindowSizeH << 218 (fWindowSizeHintY != v.fWindowSizeHintY))
793 (fWindowSizeHintY != v.fWindowSizeH <<
794 (fXGeometryString != v.fXGeometrySt <<
795 (fGeometryMask != v.fGeometryMas <<
796 (fAutoRefresh != v.fAutoRefresh <<
797 (fBackgroundColour != v.fBackgroundC <<
798 (fPicking != v.fPicking) <<
799 (fRotationStyle != v.fRotationSty <<
800 ) <<
801 G4cout << "Difference in 1st batch." << G4 219 G4cout << "Difference in 1st batch." << G4endl;
802 220
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) { 221 if (fSection) {
812 if (!(fSectionPlane == v.fSectionPlane)) 222 if (!(fSectionPlane == v.fSectionPlane))
813 G4cout << "Difference in section planes 223 G4cout << "Difference in section planes batch." << G4endl;
814 } 224 }
815 225
816 if (IsCutaway()) { << 226 if (fCutaway) {
817 if (fCutawayPlanes.size () != v.fCutawayPl << 227 if (fCutawayPlanes.entries () != v.fCutawayPlanes.entries ()) {
818 G4cout << "Difference in no of cutaway p 228 G4cout << "Difference in no of cutaway planes." << G4endl;
819 } 229 }
820 else { 230 else {
821 for (size_t i = 0; i < fCutawayPlanes.si << 231 for (int i = 0; i < fCutawayPlanes.entries (); i++) {
822 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[ << 232 if (!(fCutawayPlanes (i) == v.fCutawayPlanes (i)))
823 G4cout << "Difference in cutaway plane no. 233 G4cout << "Difference in cutaway plane no. " << i << G4endl;
824 } 234 }
825 } 235 }
826 } 236 }
827 237
828 if (IsExplode()) { << 238 if (fExplode) {
829 if (fExplodeFactor != v.fExplodeFactor) 239 if (fExplodeFactor != v.fExplodeFactor)
830 G4cout << "Difference in explode factor. 240 G4cout << "Difference in explode factor." << G4endl;
831 if (fExplodeCentre != v.fExplodeCentre) <<
832 G4cout << "Difference in explode centre. <<
833 } <<
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 } 241 }
874 } 242 }
875 243
876 std::ostream& operator << << 244 G4std::ostream& operator << (G4std::ostream& os, const G4ViewParameters& v) {
877 (std::ostream& os, G4ViewParameters::DrawingS <<
878 { <<
879 switch (style) { <<
880 case G4ViewParameters::wireframe: <<
881 os << "wireframe"; break; <<
882 case G4ViewParameters::hlr: <<
883 os << "hlr - hidden lines removed"; brea <<
884 case G4ViewParameters::hsr: <<
885 os << "hsr - hidden surfaces removed"; b <<
886 case G4ViewParameters::hlhsr: <<
887 os << "hlhsr - hidden line, hidden surfa <<
888 case G4ViewParameters::cloud: <<
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 } <<
906 return os; <<
907 } <<
908 <<
909 std::ostream& operator << (std::ostream& os, c <<
910 os << "View parameters and options:"; 245 os << "View parameters and options:";
911 246
912 os << "\n Drawing style: " << v.fDrawingSty << 247 os << "\n Drawing style: ";
913 << 248 switch (v.fDrawingStyle) {
914 os << "\n Number of cloud points: " << v.fN << 249 case G4ViewParameters::wireframe:
>> 250 os << "wireframe"; break;
>> 251 case G4ViewParameters::hlr:
>> 252 os << "hlr - hidden lines removed"; break;
>> 253 case G4ViewParameters::hsr:
>> 254 os << "hsr - hidden surfaces removed"; break;
>> 255 case G4ViewParameters::hlhsr:
>> 256 os << "hlhsr - hidden line, hidden surface removed"; break;
>> 257 default: os << "unrecognised"; break;
>> 258 }
915 259
916 os << "\n Auxiliary edges: "; << 260 os << "\n Representation style: ";
917 if (!v.fAuxEdgeVisible) os << "in"; << 261 switch (v.fRepStyle) {
918 os << "visible"; << 262 case G4ViewParameters::polyhedron:
>> 263 os << "polyhedron"; break;
>> 264 case G4ViewParameters::nurbs:
>> 265 os << "nurbs"; break;
>> 266 default: os << "unrecognised"; break;
>> 267 }
919 268
920 os << "\n Culling: "; 269 os << "\n Culling: ";
921 if (v.fCulling) os << "on"; 270 if (v.fCulling) os << "on";
922 else os << "off"; 271 else os << "off";
923 272
924 os << "\n Culling invisible objects: "; 273 os << "\n Culling invisible objects: ";
925 if (v.fCullInvisible) os << "on"; 274 if (v.fCullInvisible) os << "on";
926 else os << "off"; 275 else os << "off";
927 276
928 os << "\n Density culling: "; 277 os << "\n Density culling: ";
929 if (v.fDensityCulling) { 278 if (v.fDensityCulling) {
930 os << "on - invisible if density less than 279 os << "on - invisible if density less than "
931 << v.fVisibleDensity / (1. * g / cm3) < 280 << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
932 } 281 }
933 else os << "off"; 282 else os << "off";
934 283
935 os << "\n Culling daughters covered by opaq 284 os << "\n Culling daughters covered by opaque mothers: ";
936 if (v.fCullCovered) os << "on"; 285 if (v.fCullCovered) os << "on";
937 else os << "off"; 286 else os << "off";
938 287
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: "; 288 os << "\n Section flag: ";
950 if (v.fSection) os << "true, section/cut pla 289 if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
951 else os << "false"; 290 else os << "false";
952 291
953 if (v.IsCutaway()) { << 292 os << "\n Cutaway flag: ";
954 os << "\n Cutaway planes: "; << 293 if (v.fCutaway) {
955 for (size_t i = 0; i < v.fCutawayPlanes.si << 294 os << "true, cutaway planes: ";
>> 295 for (int i = 0; i < v.fCutawayPlanes.entries (); i++) {
956 os << ' ' << v.fCutawayPlanes[i]; 296 os << ' ' << v.fCutawayPlanes[i];
957 } 297 }
958 } 298 }
959 else { 299 else {
960 os << "\n No cutaway planes"; << 300 os << "false";
961 } 301 }
962 302
963 os << "\n Explode factor: " << v.fExplodeFa << 303 os << "\n Explode flag: ";
964 << " about centre: " << v.fExplodeCentre; << 304 if (v.fExplode) os << "true, explode factor: " << v.fExplodeFactor;
>> 305 else os << "false";
965 306
966 os << "\n No. of sides used in circle polyg 307 os << "\n No. of sides used in circle polygon approximation: "
967 << v.fNoOfSides; 308 << v.fNoOfSides;
968 309
969 os << "\n Viewpoint direction: " << v.fVie 310 os << "\n Viewpoint direction: " << v.fViewpointDirection;
970 311
971 os << "\n Up vector: " << v.fUpV 312 os << "\n Up vector: " << v.fUpVector;
972 313
973 os << "\n Field half angle: " << v.fFie 314 os << "\n Field half angle: " << v.fFieldHalfAngle;
974 315
975 os << "\n Zoom factor: " << v.fZoo 316 os << "\n Zoom factor: " << v.fZoomFactor;
976 317
977 os << "\n Scale factor: " << v.fSca <<
978 <<
979 os << "\n Current target point: " << v.fCur 318 os << "\n Current target point: " << v.fCurrentTargetPoint;
980 319
981 os << "\n Dolly distance: " << v.fDol 320 os << "\n Dolly distance: " << v.fDolly;
982 321
983 os << "\n Light "; 322 os << "\n Light ";
984 if (v.fLightsMoveWithCamera) os << "moves"; 323 if (v.fLightsMoveWithCamera) os << "moves";
985 else os << "does not 324 else os << "does not move";
986 os << " with camera"; 325 os << " with camera";
987 326
988 os << "\n Relative lightpoint direction: " 327 os << "\n Relative lightpoint direction: "
989 << v.fRelativeLightpointDirection; 328 << v.fRelativeLightpointDirection;
990 329
991 os << "\n Actual lightpoint direction: " 330 os << "\n Actual lightpoint direction: "
992 << v.fActualLightpointDirection; 331 << v.fActualLightpointDirection;
993 332
994 os << "\n Derived parameters for standard v 333 os << "\n Derived parameters for standard view of object of unit radius:";
995 G4ViewParameters tempVP = v; 334 G4ViewParameters tempVP = v;
996 tempVP.fDolly = 0.; 335 tempVP.fDolly = 0.;
997 tempVP.fZoomFactor = 1.; 336 tempVP.fZoomFactor = 1.;
998 const G4double radius = 1.; 337 const G4double radius = 1.;
999 const G4double cameraDistance = tempVP.GetCa 338 const G4double cameraDistance = tempVP.GetCameraDistance (radius);
1000 const G4double nearDistance = 339 const G4double nearDistance =
1001 tempVP.GetNearDistance (cameraDistance, r 340 tempVP.GetNearDistance (cameraDistance, radius);
1002 const G4double farDistance = 341 const G4double farDistance =
1003 tempVP.GetFarDistance (cameraDistance, n 342 tempVP.GetFarDistance (cameraDistance, nearDistance, radius);
1004 const G4double right = tempVP.GetFrontHalf 343 const G4double right = tempVP.GetFrontHalfHeight (nearDistance, radius);
1005 os << "\n Camera distance: " << camera 344 os << "\n Camera distance: " << cameraDistance;
1006 os << "\n Near distance: " << nearDi 345 os << "\n Near distance: " << nearDistance;
1007 os << "\n Far distance: " << farDis 346 os << "\n Far distance: " << farDistance;
1008 os << "\n Front half height: " << right; 347 os << "\n Front half height: " << right;
1009 348
>> 349 os << "\n View geometry: ";
>> 350 if (v.fViewGeom) os << "true";
>> 351 else os << "false";
>> 352
>> 353 os << "\n View hits : ";
>> 354 if (v.fViewHits) os << "true";
>> 355 else os << "false";
>> 356
>> 357 os << "\n View digits : ";
>> 358 if (v.fViewDigis) os << "true";
>> 359 else os << "false";
>> 360
1010 os << "\n Default VisAttributes:\n " << v 361 os << "\n Default VisAttributes:\n " << v.fDefaultVisAttributes;
1011 362
1012 os << "\n Default TextVisAttributes:\n " 363 os << "\n Default TextVisAttributes:\n " << v.fDefaultTextVisAttributes;
1013 364
1014 os << "\n Default marker:\n " << v.fDef << 365 os << "\n Default marker: " << v.fDefaultMarker;
1015 366
1016 os << "\n Global marker scale: " << v.fGlo 367 os << "\n Global marker scale: " << v.fGlobalMarkerScale;
1017 368
1018 os << "\n Global lineWidth scale: " << v.f <<
1019 <<
1020 os << "\n Marker "; 369 os << "\n Marker ";
1021 if (v.fMarkerNotHidden) os << "not "; 370 if (v.fMarkerNotHidden) os << "not ";
1022 os << "hidden by surfaces."; 371 os << "hidden by surfaces.";
1023 372
1024 os << "\n Window size hint: " 373 os << "\n Window size hint: "
1025 << v.fWindowSizeHintX << 'x'<< v.fWindow 374 << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
1026 375
1027 os << "\n X geometry string: " << v.fXGeom <<
1028 os << "\n X geometry mask: " <<
1029 << std::showbase << std::hex << v.fGeome <<
1030 << std::noshowbase << std::dec; <<
1031 <<
1032 os << "\n Auto refresh: "; <<
1033 if (v.fAutoRefresh) os << "true"; <<
1034 else os << "false"; <<
1035 <<
1036 os << "\n Background colour: " << v.fBackg <<
1037 <<
1038 os << "\n Picking requested: "; <<
1039 if (v.fPicking) os << "true"; <<
1040 else os << "false"; <<
1041 <<
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; 376 return os;
1100 } 377 }
1101 378
1102 G4bool G4ViewParameters::operator != (const G 379 G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
1103 380
1104 // Put performance-sensitive parameters fir 381 // Put performance-sensitive parameters first.
1105 if ( 382 if (
1106 // This first to optimise spin, etc. 383 // This first to optimise spin, etc.
1107 (fViewpointDirection != v.fViewpointD 384 (fViewpointDirection != v.fViewpointDirection) ||
1108 385
1109 // No particular order from here on. 386 // No particular order from here on.
1110 (fDrawingStyle != v.fDrawingSty 387 (fDrawingStyle != v.fDrawingStyle) ||
1111 (fNumberOfCloudPoints != v.fNumberOfCl << 388 (fRepStyle != v.fRepStyle) ||
1112 (fAuxEdgeVisible != v.fAuxEdgeVis <<
1113 (fCulling != v.fCulling) 389 (fCulling != v.fCulling) ||
1114 (fCullInvisible != v.fCullInvisi 390 (fCullInvisible != v.fCullInvisible) ||
1115 (fDensityCulling != v.fDensityCul 391 (fDensityCulling != v.fDensityCulling) ||
1116 (fCullCovered != v.fCullCovere 392 (fCullCovered != v.fCullCovered) ||
1117 (fCBDAlgorithmNumber != v.fCBDAlgorit <<
1118 (fSection != v.fSection) 393 (fSection != v.fSection) ||
1119 (IsCutaway() != v.IsCutaway() << 394 (fCutaway != v.fCutaway) ||
1120 (IsExplode() != v.IsExplode() << 395 (fExplode != v.fExplode) ||
1121 (fNoOfSides != v.fNoOfSides) 396 (fNoOfSides != v.fNoOfSides) ||
1122 (fUpVector != v.fUpVector) 397 (fUpVector != v.fUpVector) ||
1123 (fFieldHalfAngle != v.fFieldHalfA 398 (fFieldHalfAngle != v.fFieldHalfAngle) ||
1124 (fZoomFactor != v.fZoomFactor 399 (fZoomFactor != v.fZoomFactor) ||
1125 (fScaleFactor != v.fScaleFacto <<
1126 (fCurrentTargetPoint != v.fCurrentTar 400 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
1127 (fDolly != v.fDolly) 401 (fDolly != v.fDolly) ||
1128 (fRelativeLightpointDirection != v.fRel 402 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
1129 (fLightsMoveWithCamera != v.fLightsMove 403 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
>> 404 (fViewGeom != v.fViewGeom) ||
>> 405 (fViewHits != v.fViewHits) ||
>> 406 (fViewDigis != v.fViewDigis) ||
1130 (fDefaultVisAttributes != v.fDefaultVis 407 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
1131 (fDefaultTextVisAttributes != v.fDefaul 408 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
1132 (fDefaultMarker != v.fDefaultMar 409 (fDefaultMarker != v.fDefaultMarker) ||
1133 (fGlobalMarkerScale != v.fGlobalMark 410 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
1134 (fGlobalLineWidthScale != v.fGlobalLine <<
1135 (fMarkerNotHidden != v.fMarkerNotH 411 (fMarkerNotHidden != v.fMarkerNotHidden) ||
1136 (fWindowSizeHintX != v.fWindowSize 412 (fWindowSizeHintX != v.fWindowSizeHintX) ||
1137 (fWindowSizeHintY != v.fWindowSize << 413 (fWindowSizeHintY != v.fWindowSizeHintY))
1138 (fXGeometryString != v.fXGeometryS <<
1139 (fGeometryMask != v.fGeometryMa <<
1140 (fAutoRefresh != v.fAutoRefres <<
1141 (fBackgroundColour != v.fBackground <<
1142 (fPicking != v.fPicking) <<
1143 (fRotationStyle != v.fRotationSt <<
1144 (fSpecialMeshRendering != v.fSpecialMes <<
1145 (fSpecialMeshRenderingOption != v.fSpec <<
1146 ) <<
1147 return true; 414 return true;
1148 415
1149 if (fDensityCulling && 416 if (fDensityCulling &&
1150 (fVisibleDensity != v.fVisibleDensity)) 417 (fVisibleDensity != v.fVisibleDensity)) return true;
1151 418
1152 if (fCBDAlgorithmNumber > 0) { <<
1153 if (fCBDParameters.size() != v.fCBDParame <<
1154 else if (fCBDParameters != v.fCBDParamete <<
1155 } <<
1156 <<
1157 if (fSection && 419 if (fSection &&
1158 (!(fSectionPlane == v.fSectionPlane))) 420 (!(fSectionPlane == v.fSectionPlane))) return true;
1159 421
1160 if (IsCutaway()) { << 422 if (fCutaway) {
1161 if (fCutawayPlanes.size () != v.fCutawayP << 423 if (fCutawayPlanes.entries () != v.fCutawayPlanes.entries ())
1162 return true; 424 return true;
1163 else { 425 else {
1164 for (size_t i = 0; i < fCutawayPlanes.s << 426 for (int i = 0; i < fCutawayPlanes.entries (); i++) {
1165 if (!(fCutawayPlanes[i] == v.fCutawayPlanes << 427 if (!(fCutawayPlanes (i) == v.fCutawayPlanes (i))) return true;
1166 } 428 }
1167 } 429 }
1168 } 430 }
1169 431
1170 if (IsExplode() && << 432 if (fExplode &&
1171 ((fExplodeFactor != v.fExplodeFactor) | << 433 (fExplodeFactor != v.fExplodeFactor)) return true;
1172 (fExplodeCentre != v.fExplodeCentre))) <<
1173 <<
1174 if (fVisAttributesModifiers != v.fVisAttrib <<
1175 <<
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 <<
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 <<
1205 if (fSpecialMeshRendering) { <<
1206 if (fSpecialMeshVolumes != v.fSpecialMesh <<
1207 return true;; <<
1208 } <<
1209 434
1210 return false; 435 return false;
1211 } <<
1212 <<
1213 void G4ViewParameters::SetXGeometryString (co <<
1214 { <<
1215 const G4String delimiters("xX+-"); <<
1216 G4String::size_type i = geomString.find_fir <<
1217 if (i == G4String::npos) { <<
1218 // Does not contain "xX+-". <<
1219 // Is it a single number? <<
1220 std::istringstream iss(geomString); <<
1221 G4int size; <<
1222 iss >> size; <<
1223 if (iss) { <<
1224 // It is a number <<
1225 fWindowSizeHintX = size; <<
1226 fWindowSizeHintY = size; <<
1227 } <<
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; <<
1234 oss << fWindowSizeHintX << 'x' << fWindow <<
1235 << signX << fWindowLocationHintX << signY <<
1236 fXGeometryString = oss.str(); <<
1237 return; <<
1238 } <<
1239 <<
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, <<
1244 <<
1245 // Handle special case : <<
1246 if ((fGeometryMask & fYValue) == 0) <<
1247 { // Using default <<
1248 y = fWindowLocationHintY; <<
1249 } <<
1250 if ((fGeometryMask & fXValue) == 0) <<
1251 { // Using default <<
1252 x = fWindowLocationHintX; <<
1253 } <<
1254 <<
1255 // Check errors <<
1256 // if there is no Width and Height <<
1257 if ( ((fGeometryMask & fHeightValue) == 0 ) <<
1258 ((fGeometryMask & fWidthValue) == 0 ) <<
1259 h = fWindowSizeHintY; <<
1260 w = fWindowSizeHintX; <<
1261 } else if ((fGeometryMask & fHeightValue) <<
1262 <<
1263 // if there is only Width. Special case t <<
1264 // We set Width and Height the same to ob <<
1265 <<
1266 G4warn << "Unrecognised geometry string \ <<
1267 << geomString <<
1268 << "\". No Height found. Using Wi <<
1269 << G4endl; <<
1270 h = w; <<
1271 } <<
1272 if ( ((fGeometryMask & fXValue) == 0 ) || <<
1273 ((fGeometryMask & fYValue) == 0 )) { <<
1274 //Using defaults <<
1275 x = fWindowLocationHintX; <<
1276 y = fWindowLocationHintY; <<
1277 } <<
1278 // Set the string <<
1279 fXGeometryString = geomString; <<
1280 <<
1281 // Set values <<
1282 fWindowSizeHintX = w; <<
1283 fWindowSizeHintY = h; <<
1284 fWindowLocationHintX = x; <<
1285 fWindowLocationHintY = y; <<
1286 <<
1287 if ( ((fGeometryMask & fXValue)) && <<
1288 ((fGeometryMask & fYValue))) { <<
1289 <<
1290 if ( (fGeometryMask & fXNegative) ) { <<
1291 fWindowLocationHintXNegative = true; <<
1292 } else { <<
1293 fWindowLocationHintXNegative = false; <<
1294 } <<
1295 if ( (fGeometryMask & fYNegative) ) { <<
1296 fWindowLocationHintYNegative = true; <<
1297 } else { <<
1298 fWindowLocationHintYNegative = false; <<
1299 } <<
1300 } <<
1301 } <<
1302 <<
1303 G4int G4ViewParameters::GetWindowAbsoluteLoca <<
1304 if ( fWindowLocationHintXNegative ) { <<
1305 return sizeX + fWindowLocationHintX - f <<
1306 } <<
1307 return fWindowLocationHintX; <<
1308 } <<
1309 <<
1310 G4int G4ViewParameters::GetWindowAbsoluteLoca <<
1311 if ( fWindowLocationHintYNegative ) { <<
1312 return sizeY + fWindowLocationHintY - f <<
1313 } <<
1314 return fWindowLocationHintY; <<
1315 } <<
1316 <<
1317 /* Keep from : <<
1318 * ftp://ftp.trolltech.com/qt/source/qt-embed <<
1319 * <<
1320 * ParseGeometry parses strings of the for <<
1321 * "=<width>x<height>{+-}<xoffset>{+-}<yoff <<
1322 * width, height, xoffset, and yoffset are <<
1323 * Example: "=80x24+300-49" <<
1324 * The equal sign is optional. <<
1325 * It returns a bitmask that indicates whic <<
1326 * were actually found in the string. For e <<
1327 * the corresponding argument is updated; <<
1328 * not found, the corresponding argument is <<
1329 */ <<
1330 <<
1331 int G4ViewParameters::ParseGeometry ( <<
1332 const char *string, <<
1333 G4int *x, <<
1334 G4int *y, <<
1335 unsigned int *width, <<
1336 unsigned int *height) <<
1337 { <<
1338 <<
1339 G4int mask = fNoValue; <<
1340 char *strind; <<
1341 unsigned int tempWidth = 0; <<
1342 unsigned int tempHeight = 0; <<
1343 G4int tempX = 0; <<
1344 G4int tempY = 0; <<
1345 char *nextCharacter; <<
1346 if ( (string == NULL) || (*string == '\0')) <<
1347 return(mask); <<
1348 } <<
1349 if (*string == '=') <<
1350 string++; /* ignore possible '=' at beg <<
1351 strind = (char *)string; <<
1352 if (*strind != '+' && *strind != '-' && *st <<
1353 tempWidth = ReadInteger(strind, &nextChar <<
1354 if (strind == nextCharacter) <<
1355 return (0); <<
1356 strind = nextCharacter; <<
1357 mask |= fWidthValue; <<
1358 } <<
1359 if (*strind == 'x' || *strind == 'X') { <<
1360 strind++; <<
1361 tempHeight = ReadInteger(strind, &nextCha <<
1362 if (strind == nextCharacter) <<
1363 return (0); <<
1364 strind = nextCharacter; <<
1365 mask |= fHeightValue; <<
1366 } <<
1367 <<
1368 if ((*strind == '+') || (*strind == '-')) { <<
1369 if (*strind == '-') { <<
1370 strind++; <<
1371 tempX = -ReadInteger(strind, &nextChara <<
1372 if (strind == nextCharacter) <<
1373 return (0); <<
1374 strind = nextCharacter; <<
1375 mask |= fXNegative; <<
1376 <<
1377 } <<
1378 else <<
1379 { strind++; <<
1380 tempX = ReadInteger(strind, &nextChar <<
1381 if (strind == nextCharacter) <<
1382 return(0); <<
1383 strind = nextCharacter; <<
1384 } <<
1385 mask |= fXValue; <<
1386 if ((*strind == '+') || (*strind == '-')) <<
1387 if (*strind == '-') { <<
1388 strind++; <<
1389 tempY = -ReadInteger(strind, &nextCha <<
1390 if (strind == nextCharacter) <<
1391 return(0); <<
1392 strind = nextCharacter; <<
1393 mask |= fYNegative; <<
1394 } <<
1395 else <<
1396 { <<
1397 strind++; <<
1398 tempY = ReadInteger(strind, &nextCh <<
1399 if (strind == nextCharacter) <<
1400 return(0); <<
1401 strind = nextCharacter; <<
1402 } <<
1403 mask |= fYValue; <<
1404 } <<
1405 } <<
1406 /* If strind isn't at the end of the string <<
1407 geometry specification. */ <<
1408 if (*strind != '\0') return (0); <<
1409 if (mask & fXValue) <<
1410 *x = tempX; <<
1411 if (mask & fYValue) <<
1412 *y = tempY; <<
1413 if (mask & fWidthValue) <<
1414 *width = tempWidth; <<
1415 if (mask & fHeightValue) <<
1416 *height = tempHeight; <<
1417 return (mask); <<
1418 } <<
1419 <<
1420 /* Keep from : <<
1421 * ftp://ftp.trolltech.com/qt/source/qt-embed <<
1422 * <<
1423 */ <<
1424 G4int G4ViewParameters::ReadInteger(char *str <<
1425 { <<
1426 G4int Result = 0; <<
1427 G4int Sign = 1; <<
1428 <<
1429 if (*string == '+') <<
1430 string++; <<
1431 else if (*string == '-') <<
1432 { <<
1433 string++; <<
1434 Sign = -1; <<
1435 } <<
1436 for (; (*string >= '0') && (*string <= '9 <<
1437 { <<
1438 Result = (Result * 10) + (*string - '0'); <<
1439 } <<
1440 *NextString = string; <<
1441 if (Sign >= 0) <<
1442 return (Result); <<
1443 else <<
1444 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 } 436 }
1721 437