| Geant4 Cross Reference |
1 // 1 //
2 // ******************************************* 2 // ********************************************************************
3 // * License and Disclaimer << 3 // * DISCLAIMER *
4 // * 4 // * *
5 // * The Geant4 software is copyright of th << 5 // * The following disclaimer summarizes all the specific disclaimers *
6 // * the Geant4 Collaboration. It is provided << 6 // * of contributors to this software. The specific disclaimers,which *
7 // * conditions of the Geant4 Software License << 7 // * govern, are listed with their locations in: *
8 // * LICENSE and available at http://cern.ch/ << 8 // * http://cern.ch/geant4/license *
9 // * include a list of copyright holders. <<
10 // * 9 // * *
11 // * Neither the authors of this software syst 10 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing fin 11 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warran 12 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assum 13 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file << 14 // * use. *
16 // * for the full disclaimer and the limitatio <<
17 // * 15 // * *
18 // * This code implementation is the result << 16 // * This code implementation is the intellectual property of the *
19 // * technical work of the GEANT4 collaboratio << 17 // * GEANT4 collaboration. *
20 // * By using, copying, modifying or distri << 18 // * By copying, distributing or modifying the Program (or any work *
21 // * any work based on the software) you ag << 19 // * based on the Program) you indicate your acceptance of this *
22 // * use in resulting scientific publicati << 20 // * statement, and all its terms. *
23 // * acceptance of all terms of the Geant4 Sof <<
24 // ******************************************* 21 // ********************************************************************
25 // 22 //
26 // 23 //
>> 24 // $Id: G4ViewParameters.cc,v 1.23 2005/11/13 15:26:18 allison Exp $
>> 25 // GEANT4 tag $Name: geant4-08-00-patch-01 $
27 // 26 //
28 // 27 //
29 // John Allison 19th July 1996 28 // John Allison 19th July 1996
30 // View parameters and options. 29 // View parameters and options.
31 30
32 #include "G4ViewParameters.hh" 31 #include "G4ViewParameters.hh"
33 32
34 #include "G4VisManager.hh" 33 #include "G4VisManager.hh"
35 #include "G4VPhysicalVolume.hh" <<
36 #include "G4UnitsTable.hh" 34 #include "G4UnitsTable.hh"
37 #include "G4SystemOfUnits.hh" << 35 #include "G4ios.hh"
38 #include "G4Polyhedron.hh" <<
39 <<
40 #include <sstream> <<
41 #include <cmath> <<
42 <<
43 #define G4warn G4cout <<
44 36
45 G4ViewParameters::G4ViewParameters (): 37 G4ViewParameters::G4ViewParameters ():
46 fDrawingStyle (wireframe), 38 fDrawingStyle (wireframe),
47 fNumberOfCloudPoints(10000), <<
48 fAuxEdgeVisible (false), 39 fAuxEdgeVisible (false),
>> 40 fRepStyle (polyhedron),
49 fCulling (true), 41 fCulling (true),
50 fCullInvisible (true), 42 fCullInvisible (true),
51 fDensityCulling (false), 43 fDensityCulling (false),
52 fVisibleDensity (0.01 * g / cm3), 44 fVisibleDensity (0.01 * g / cm3),
53 fCullCovered (false), 45 fCullCovered (false),
54 fCBDAlgorithmNumber (0), <<
55 fSection (false), 46 fSection (false),
56 fSectionPlane (), 47 fSectionPlane (),
57 fCutawayMode (cutawayUnion), << 48 fCutaway (false),
58 fCutawayPlanes (), 49 fCutawayPlanes (),
>> 50 fExplode (false),
59 fExplodeFactor (1.), 51 fExplodeFactor (1.),
60 fNoOfSides (), << 52 fNoOfSides (24),
61 fViewpointDirection (G4Vector3D (0., 0., 1.) 53 fViewpointDirection (G4Vector3D (0., 0., 1.)), // On z-axis.
62 fUpVector (G4Vector3D (0., 1., 0.)), 54 fUpVector (G4Vector3D (0., 1., 0.)), // y-axis up.
63 fFieldHalfAngle (0.), 55 fFieldHalfAngle (0.), // Orthogonal projection.
64 fZoomFactor (1.), 56 fZoomFactor (1.),
65 fScaleFactor (G4Vector3D (1., 1., 1.)), 57 fScaleFactor (G4Vector3D (1., 1., 1.)),
66 fCurrentTargetPoint (), 58 fCurrentTargetPoint (),
67 fDolly (0.), 59 fDolly (0.),
68 fLightsMoveWithCamera (false), 60 fLightsMoveWithCamera (false),
69 fRelativeLightpointDirection (G4Vector3D (1. 61 fRelativeLightpointDirection (G4Vector3D (1., 1., 1.)),
70 fActualLightpointDirection (G4Vector3D (1., 62 fActualLightpointDirection (G4Vector3D (1., 1., 1.)),
>> 63 fViewGeom (true),
>> 64 fViewHits (true),
>> 65 fViewDigis (true),
71 fDefaultVisAttributes (), 66 fDefaultVisAttributes (),
72 fDefaultTextVisAttributes (G4Colour (0., 0., 67 fDefaultTextVisAttributes (G4Colour (0., 0., 1.)),
73 fDefaultMarker (), 68 fDefaultMarker (),
74 fGlobalMarkerScale (1.), 69 fGlobalMarkerScale (1.),
75 fGlobalLineWidthScale (1.), <<
76 fMarkerNotHidden (true), 70 fMarkerNotHidden (true),
77 fWindowSizeHintX (600), 71 fWindowSizeHintX (600),
78 fWindowSizeHintY (600), 72 fWindowSizeHintY (600),
79 fWindowLocationHintX(0), <<
80 fWindowLocationHintY(0), <<
81 fWindowLocationHintXNegative(true), <<
82 fWindowLocationHintYNegative(false), <<
83 fGeometryMask(0), <<
84 fAutoRefresh (false), 73 fAutoRefresh (false),
85 fBackgroundColour (G4Colour(0.,0.,0.)), << 74 fBackgroundColour (G4Colour(0.,0.,0.)) // Black
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 { 75 {
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.); 76 fDefaultMarker.SetScreenSize (5.);
119 // Markers are 5 pixels "overall" size, i.e. 77 // Markers are 5 pixels "overall" size, i.e., diameter.
120 } 78 }
121 79
122 G4ViewParameters::~G4ViewParameters () {} 80 G4ViewParameters::~G4ViewParameters () {}
123 81
124 void G4ViewParameters::MultiplyScaleFactor 82 void G4ViewParameters::MultiplyScaleFactor
125 (const G4Vector3D& scaleFactorMultiplier) { 83 (const G4Vector3D& scaleFactorMultiplier) {
126 fScaleFactor.setX(fScaleFactor.x() * scaleFa 84 fScaleFactor.setX(fScaleFactor.x() * scaleFactorMultiplier.x());
127 fScaleFactor.setY(fScaleFactor.y() * scaleFa 85 fScaleFactor.setY(fScaleFactor.y() * scaleFactorMultiplier.y());
128 fScaleFactor.setZ(fScaleFactor.z() * scaleFa 86 fScaleFactor.setZ(fScaleFactor.z() * scaleFactorMultiplier.z());
129 } 87 }
130 88
131 G4Vector3D& G4ViewParameters::GetActualLightpo 89 G4Vector3D& G4ViewParameters::GetActualLightpointDirection () {
132 SetViewAndLights (fViewpointDirection); 90 SetViewAndLights (fViewpointDirection);
133 return fActualLightpointDirection; 91 return fActualLightpointDirection;
134 } 92 }
135 93
136 // Useful quantities - begin snippet. 94 // Useful quantities - begin snippet.
137 // Here Follow functions to evaluate the above 95 // Here Follow functions to evaluate the above algorithms as a
138 // function of the radius of the Bounding Sphe 96 // function of the radius of the Bounding Sphere of the object being
139 // viewed. Call them in the order given - for 97 // viewed. Call them in the order given - for efficiency, later
140 // functions depend on the results of earlier 98 // functions depend on the results of earlier ones (Store the
141 // results of earlier functions in your own te 99 // results of earlier functions in your own temporary variables -
142 // see, for example, G4OpenGLView::SetView (). 100 // see, for example, G4OpenGLView::SetView ().)
143 101
144 G4double G4ViewParameters::GetCameraDistance ( 102 G4double G4ViewParameters::GetCameraDistance (G4double radius) const {
145 G4double cameraDistance; 103 G4double cameraDistance;
146 if (fFieldHalfAngle == 0.) { 104 if (fFieldHalfAngle == 0.) {
147 cameraDistance = radius; 105 cameraDistance = radius;
148 } 106 }
149 else { 107 else {
150 cameraDistance = radius / std::sin (fField 108 cameraDistance = radius / std::sin (fFieldHalfAngle) - fDolly;
151 } 109 }
152 return cameraDistance; 110 return cameraDistance;
153 } 111 }
154 112
155 G4double G4ViewParameters::GetNearDistance (G4 113 G4double G4ViewParameters::GetNearDistance (G4double cameraDistance,
156 G4double radius) const { 114 G4double radius) const {
157 const G4double small = 1.e-6 * radius; 115 const G4double small = 1.e-6 * radius;
158 G4double nearDistance = cameraDistance - rad 116 G4double nearDistance = cameraDistance - radius;
159 if (nearDistance < small) nearDistance = sma 117 if (nearDistance < small) nearDistance = small;
160 return nearDistance; 118 return nearDistance;
161 } 119 }
162 120
163 G4double G4ViewParameters::GetFarDistance (G4d 121 G4double G4ViewParameters::GetFarDistance (G4double cameraDistance,
164 G4double nearDistance, 122 G4double nearDistance,
165 G4double radius) const { 123 G4double radius) const {
166 G4double farDistance = cameraDistance + radi 124 G4double farDistance = cameraDistance + radius;
167 if (farDistance < nearDistance) farDistance 125 if (farDistance < nearDistance) farDistance = nearDistance;
168 return farDistance; 126 return farDistance;
169 } 127 }
170 128
171 G4double G4ViewParameters::GetFrontHalfHeight 129 G4double G4ViewParameters::GetFrontHalfHeight (G4double nearDistance,
172 G4double radius) const { 130 G4double radius) const {
173 G4double frontHalfHeight; 131 G4double frontHalfHeight;
174 if (fFieldHalfAngle == 0.) { 132 if (fFieldHalfAngle == 0.) {
175 frontHalfHeight = radius / fZoomFactor; 133 frontHalfHeight = radius / fZoomFactor;
176 } 134 }
177 else { 135 else {
178 frontHalfHeight = nearDistance * std::tan 136 frontHalfHeight = nearDistance * std::tan (fFieldHalfAngle) / fZoomFactor;
179 } 137 }
180 return frontHalfHeight; 138 return frontHalfHeight;
181 } 139 }
182 // Useful quantities - end snippet. 140 // Useful quantities - end snippet.
183 141
184 void G4ViewParameters::AddCutawayPlane (const 142 void G4ViewParameters::AddCutawayPlane (const G4Plane3D& cutawayPlane) {
>> 143 fCutaway = true;
185 if (fCutawayPlanes.size () < 3 ) { 144 if (fCutawayPlanes.size () < 3 ) {
186 fCutawayPlanes.push_back (cutawayPlane); 145 fCutawayPlanes.push_back (cutawayPlane);
187 } 146 }
188 else { 147 else {
189 G4warn << << 148 G4cout <<
190 "ERROR: G4ViewParameters::AddCutawayPlan 149 "ERROR: G4ViewParameters::AddCutawayPlane:"
191 "\n A maximum of 3 cutaway planes suppo 150 "\n A maximum of 3 cutaway planes supported." << G4endl;
192 } 151 }
193 } 152 }
194 153
195 void G4ViewParameters::ChangeCutawayPlane << 154 void G4ViewParameters::ClearCutawayPlanes () {
196 (size_t index, const G4Plane3D& cutawayPlane) << 155 fCutaway = false;
197 if (index >= fCutawayPlanes.size()) { << 156 fCutawayPlanes.clear ();
198 G4warn << <<
199 "ERROR: G4ViewParameters::ChangeCutawayP <<
200 "\n Plane " << index << " does not exis <<
201 } else { <<
202 fCutawayPlanes[index] = cutawayPlane; <<
203 } <<
204 } 157 }
205 158
206 void G4ViewParameters::SetVisibleDensity (G4do 159 void G4ViewParameters::SetVisibleDensity (G4double visibleDensity) {
207 const G4double reasonableMaximum = 10.0 * g 160 const G4double reasonableMaximum = 10.0 * g / cm3;
208 if (visibleDensity < 0) { 161 if (visibleDensity < 0) {
209 G4warn << "G4ViewParameters::SetVisibleDen << 162 G4cout << "G4ViewParameters::SetVisibleDensity: attempt to set negative "
210 "density - ignored." << G4endl; 163 "density - ignored." << G4endl;
211 } 164 }
212 else { 165 else {
213 if (visibleDensity > reasonableMaximum) { 166 if (visibleDensity > reasonableMaximum) {
214 G4warn << "G4ViewParameters::SetVisibleD << 167 G4cout << "G4ViewParameters::SetVisibleDensity: density > "
215 << G4BestUnit (reasonableMaximum, "Volu 168 << G4BestUnit (reasonableMaximum, "Volumic Mass")
216 << " - did you mean this?" 169 << " - did you mean this?"
217 << G4endl; 170 << G4endl;
218 } 171 }
219 fVisibleDensity = visibleDensity; 172 fVisibleDensity = visibleDensity;
220 } 173 }
221 } 174 }
222 175
223 G4int G4ViewParameters::SetNoOfSides (G4int nS 176 G4int G4ViewParameters::SetNoOfSides (G4int nSides) {
224 const G4int nSidesMin = fDefaultVisAttribute << 177 const G4int nSidesMin = 12;
225 if (nSides < nSidesMin) { 178 if (nSides < nSidesMin) {
226 nSides = nSidesMin; 179 nSides = nSidesMin;
227 G4warn << "G4ViewParameters::SetNoOfSides: << 180 G4cout << "G4ViewParameters::SetNoOfSides: attempt to set the"
228 "\nnumber of sides per circle < " << nSide << 181 "\nnumber of sides per circle < " << nSidesMin
229 << "; forced to " << nSides << G4endl; << 182 << "; forced to " << nSides << G4endl;
230 } 183 }
231 fNoOfSides = nSides; 184 fNoOfSides = nSides;
232 return fNoOfSides; 185 return fNoOfSides;
233 } 186 }
234 187
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 188 void G4ViewParameters::SetViewAndLights
248 (const G4Vector3D& viewpointDirection) { 189 (const G4Vector3D& viewpointDirection) {
249 190
250 fViewpointDirection = viewpointDirection; 191 fViewpointDirection = viewpointDirection;
251 192
252 // If the requested viewpoint direction is p 193 // If the requested viewpoint direction is parallel to the up
253 // vector, the orientation of the view is un 194 // vector, the orientation of the view is undefined...
254 if (fViewpointDirection.unit() * fUpVector.u 195 if (fViewpointDirection.unit() * fUpVector.unit() > .9999) {
255 static G4bool firstTime = true; << 196 G4cout <<
256 if (firstTime) { <<
257 firstTime = false; <<
258 G4warn << <<
259 "WARNING: Viewpoint direction is very cl 197 "WARNING: Viewpoint direction is very close to the up vector direction."
260 "\n Change the up vector or \"/vis/view << 198 "\n Consider setting the up vector to obtain definable behaviour."
261 << G4endl; << 199 << G4endl;
262 } <<
263 } 200 }
264 201
265 // Move the lights too if requested... 202 // Move the lights too if requested...
266 if (fLightsMoveWithCamera) { 203 if (fLightsMoveWithCamera) {
267 G4Vector3D zprime = fViewpointDirection.un 204 G4Vector3D zprime = fViewpointDirection.unit ();
268 G4Vector3D xprime = (fUpVector.cross (zpri 205 G4Vector3D xprime = (fUpVector.cross (zprime)).unit ();
269 G4Vector3D yprime = zprime.cross (xprime); 206 G4Vector3D yprime = zprime.cross (xprime);
270 fActualLightpointDirection = 207 fActualLightpointDirection =
271 fRelativeLightpointDirection.x () * xpri 208 fRelativeLightpointDirection.x () * xprime +
272 fRelativeLightpointDirection.y () * ypri 209 fRelativeLightpointDirection.y () * yprime +
273 fRelativeLightpointDirection.x () * zpri 210 fRelativeLightpointDirection.x () * zprime;
274 } else { 211 } else {
275 fActualLightpointDirection = fRelativeLigh 212 fActualLightpointDirection = fRelativeLightpointDirection;
276 } 213 }
277 } 214 }
278 215
279 void G4ViewParameters::SetLightpointDirection 216 void G4ViewParameters::SetLightpointDirection
280 (const G4Vector3D& lightpointDirection) { 217 (const G4Vector3D& lightpointDirection) {
281 fRelativeLightpointDirection = lightpointDir 218 fRelativeLightpointDirection = lightpointDirection;
282 SetViewAndLights (fViewpointDirection); 219 SetViewAndLights (fViewpointDirection);
283 } 220 }
284 221
285 void G4ViewParameters::SetPan (G4double right, 222 void G4ViewParameters::SetPan (G4double right, G4double up) {
286 G4Vector3D unitRight = (fUpVector.cross (fVi 223 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
287 G4Vector3D unitUp = (fViewpointDirection. 224 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
288 fCurrentTargetPoint = right * unitRight + u 225 fCurrentTargetPoint = right * unitRight + up * unitUp;
289 } 226 }
290 227
291 void G4ViewParameters::IncrementPan (G4double 228 void G4ViewParameters::IncrementPan (G4double right, G4double up) {
292 IncrementPan (right,up, 0); <<
293 } <<
294 <<
295 void G4ViewParameters::IncrementPan (G4double <<
296 G4Vector3D unitRight = (fUpVector.cross (fVi 229 G4Vector3D unitRight = (fUpVector.cross (fViewpointDirection)).unit();
297 G4Vector3D unitUp = (fViewpointDirection. 230 G4Vector3D unitUp = (fViewpointDirection.cross (unitRight)).unit();
298 fCurrentTargetPoint += right * unitRight + u << 231 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 } 232 }
758 233
759 void G4ViewParameters::PrintDifferences (const 234 void G4ViewParameters::PrintDifferences (const G4ViewParameters& v) const {
760 235
761 // Put performance-sensitive parameters firs 236 // Put performance-sensitive parameters first.
762 if ( 237 if (
763 // This first to optimise spin, etc. 238 // This first to optimise spin, etc.
764 (fViewpointDirection != v.fViewpointDi 239 (fViewpointDirection != v.fViewpointDirection) ||
765 240
766 // No particular order from here on. 241 // No particular order from here on.
767 (fDrawingStyle != v.fDrawingStyl 242 (fDrawingStyle != v.fDrawingStyle) ||
768 (fNumberOfCloudPoints != v.fNumberOfClo <<
769 (fAuxEdgeVisible != v.fAuxEdgeVisi 243 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
>> 244 (fRepStyle != v.fRepStyle) ||
770 (fCulling != v.fCulling) 245 (fCulling != v.fCulling) ||
771 (fCullInvisible != v.fCullInvisib 246 (fCullInvisible != v.fCullInvisible) ||
772 (fDensityCulling != v.fDensityCull 247 (fDensityCulling != v.fDensityCulling) ||
773 (fVisibleDensity != v.fVisibleDens 248 (fVisibleDensity != v.fVisibleDensity) ||
774 (fCullCovered != v.fCullCovered 249 (fCullCovered != v.fCullCovered) ||
775 (fCBDAlgorithmNumber != v.fCBDAlgorith <<
776 (fSection != v.fSection) 250 (fSection != v.fSection) ||
>> 251 (fCutaway != v.fCutaway) ||
>> 252 (fExplode != v.fExplode) ||
777 (fNoOfSides != v.fNoOfSides) 253 (fNoOfSides != v.fNoOfSides) ||
778 (fUpVector != v.fUpVector) 254 (fUpVector != v.fUpVector) ||
779 (fFieldHalfAngle != v.fFieldHalfAn 255 (fFieldHalfAngle != v.fFieldHalfAngle) ||
780 (fZoomFactor != v.fZoomFactor) 256 (fZoomFactor != v.fZoomFactor) ||
781 (fScaleFactor != v.fScaleFactor 257 (fScaleFactor != v.fScaleFactor) ||
782 (fCurrentTargetPoint != v.fCurrentTarg 258 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
783 (fDolly != v.fDolly) 259 (fDolly != v.fDolly) ||
784 (fRelativeLightpointDirection != v.fRela 260 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
785 (fLightsMoveWithCamera != v.fLightsMoveW 261 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
>> 262 (fViewGeom != v.fViewGeom) ||
>> 263 (fViewHits != v.fViewHits) ||
>> 264 (fViewDigis != v.fViewDigis) ||
786 (fDefaultVisAttributes != v.fDefaultVisA 265 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
787 (fDefaultTextVisAttributes != v.fDefault 266 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
788 (fDefaultMarker != v.fDefaultMark 267 (fDefaultMarker != v.fDefaultMarker) ||
789 (fGlobalMarkerScale != v.fGlobalMarke 268 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
790 (fGlobalLineWidthScale != v.fGlobalLineW <<
791 (fMarkerNotHidden != v.fMarkerNotHi 269 (fMarkerNotHidden != v.fMarkerNotHidden) ||
792 (fWindowSizeHintX != v.fWindowSizeH 270 (fWindowSizeHintX != v.fWindowSizeHintX) ||
793 (fWindowSizeHintY != v.fWindowSizeH 271 (fWindowSizeHintY != v.fWindowSizeHintY) ||
794 (fXGeometryString != v.fXGeometrySt 272 (fXGeometryString != v.fXGeometryString) ||
795 (fGeometryMask != v.fGeometryMas <<
796 (fAutoRefresh != v.fAutoRefresh 273 (fAutoRefresh != v.fAutoRefresh) ||
797 (fBackgroundColour != v.fBackgroundC << 274 (fBackgroundColour != v.fBackgroundColour))
798 (fPicking != v.fPicking) <<
799 (fRotationStyle != v.fRotationSty <<
800 ) <<
801 G4cout << "Difference in 1st batch." << G4 275 G4cout << "Difference in 1st batch." << G4endl;
802 276
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) { 277 if (fSection) {
812 if (!(fSectionPlane == v.fSectionPlane)) 278 if (!(fSectionPlane == v.fSectionPlane))
813 G4cout << "Difference in section planes 279 G4cout << "Difference in section planes batch." << G4endl;
814 } 280 }
815 281
816 if (IsCutaway()) { << 282 if (fCutaway) {
817 if (fCutawayPlanes.size () != v.fCutawayPl 283 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ()) {
818 G4cout << "Difference in no of cutaway p 284 G4cout << "Difference in no of cutaway planes." << G4endl;
819 } 285 }
820 else { 286 else {
821 for (size_t i = 0; i < fCutawayPlanes.si 287 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
822 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[ 288 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i]))
823 G4cout << "Difference in cutaway plane no. 289 G4cout << "Difference in cutaway plane no. " << i << G4endl;
824 } 290 }
825 } 291 }
826 } 292 }
827 293
828 if (IsExplode()) { << 294 if (fExplode) {
829 if (fExplodeFactor != v.fExplodeFactor) 295 if (fExplodeFactor != v.fExplodeFactor)
830 G4cout << "Difference in explode factor. 296 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 } 297 }
874 } 298 }
875 299
876 std::ostream& operator << << 300 std::ostream& operator << (std::ostream& os,
877 (std::ostream& os, G4ViewParameters::DrawingS << 301 const G4ViewParameters::DrawingStyle& style) {
878 { <<
879 switch (style) { 302 switch (style) {
880 case G4ViewParameters::wireframe: << 303 case G4ViewParameters::wireframe:
881 os << "wireframe"; break; << 304 os << "wireframe"; break;
882 case G4ViewParameters::hlr: << 305 case G4ViewParameters::hlr:
883 os << "hlr - hidden lines removed"; brea << 306 os << "hlr - hidden lines removed"; break;
884 case G4ViewParameters::hsr: << 307 case G4ViewParameters::hsr:
885 os << "hsr - hidden surfaces removed"; b << 308 os << "hsr - hidden surfaces removed"; break;
886 case G4ViewParameters::hlhsr: << 309 case G4ViewParameters::hlhsr:
887 os << "hlhsr - hidden line, hidden surfa << 310 os << "hlhsr - hidden line, hidden surface removed"; break;
888 case G4ViewParameters::cloud: << 311 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 } 312 }
906 return os; 313 return os;
907 } 314 }
908 315
909 std::ostream& operator << (std::ostream& os, c 316 std::ostream& operator << (std::ostream& os, const G4ViewParameters& v) {
910 os << "View parameters and options:"; 317 os << "View parameters and options:";
911 318
912 os << "\n Drawing style: " << v.fDrawingSty 319 os << "\n Drawing style: " << v.fDrawingStyle;
913 320
914 os << "\n Number of cloud points: " << v.fN <<
915 <<
916 os << "\n Auxiliary edges: "; 321 os << "\n Auxiliary edges: ";
917 if (!v.fAuxEdgeVisible) os << "in"; 322 if (!v.fAuxEdgeVisible) os << "in";
918 os << "visible"; 323 os << "visible";
919 324
>> 325 os << "\n Representation style: ";
>> 326 switch (v.fRepStyle) {
>> 327 case G4ViewParameters::polyhedron:
>> 328 os << "polyhedron"; break;
>> 329 case G4ViewParameters::nurbs:
>> 330 os << "nurbs"; break;
>> 331 default: os << "unrecognised"; break;
>> 332 }
>> 333
920 os << "\n Culling: "; 334 os << "\n Culling: ";
921 if (v.fCulling) os << "on"; 335 if (v.fCulling) os << "on";
922 else os << "off"; 336 else os << "off";
923 337
924 os << "\n Culling invisible objects: "; 338 os << "\n Culling invisible objects: ";
925 if (v.fCullInvisible) os << "on"; 339 if (v.fCullInvisible) os << "on";
926 else os << "off"; 340 else os << "off";
927 341
928 os << "\n Density culling: "; 342 os << "\n Density culling: ";
929 if (v.fDensityCulling) { 343 if (v.fDensityCulling) {
930 os << "on - invisible if density less than 344 os << "on - invisible if density less than "
931 << v.fVisibleDensity / (1. * g / cm3) < 345 << v.fVisibleDensity / (1. * g / cm3) << " g cm^-3";
932 } 346 }
933 else os << "off"; 347 else os << "off";
934 348
935 os << "\n Culling daughters covered by opaq 349 os << "\n Culling daughters covered by opaque mothers: ";
936 if (v.fCullCovered) os << "on"; 350 if (v.fCullCovered) os << "on";
937 else os << "off"; 351 else os << "off";
938 352
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: "; 353 os << "\n Section flag: ";
950 if (v.fSection) os << "true, section/cut pla 354 if (v.fSection) os << "true, section/cut plane: " << v.fSectionPlane;
951 else os << "false"; 355 else os << "false";
952 356
953 if (v.IsCutaway()) { << 357 os << "\n Cutaway flag: ";
954 os << "\n Cutaway planes: "; << 358 if (v.fCutaway) {
>> 359 os << "true, cutaway planes: ";
955 for (size_t i = 0; i < v.fCutawayPlanes.si 360 for (size_t i = 0; i < v.fCutawayPlanes.size (); i++) {
956 os << ' ' << v.fCutawayPlanes[i]; 361 os << ' ' << v.fCutawayPlanes[i];
957 } 362 }
958 } 363 }
959 else { 364 else {
960 os << "\n No cutaway planes"; << 365 os << "false";
961 } 366 }
962 367
963 os << "\n Explode factor: " << v.fExplodeFa << 368 os << "\n Explode flag: ";
964 << " about centre: " << v.fExplodeCentre; << 369 if (v.fExplode) os << "true, explode factor: " << v.fExplodeFactor;
>> 370 else os << "false";
965 371
966 os << "\n No. of sides used in circle polyg 372 os << "\n No. of sides used in circle polygon approximation: "
967 << v.fNoOfSides; 373 << v.fNoOfSides;
968 374
969 os << "\n Viewpoint direction: " << v.fVie 375 os << "\n Viewpoint direction: " << v.fViewpointDirection;
970 376
971 os << "\n Up vector: " << v.fUpV 377 os << "\n Up vector: " << v.fUpVector;
972 378
973 os << "\n Field half angle: " << v.fFie 379 os << "\n Field half angle: " << v.fFieldHalfAngle;
974 380
975 os << "\n Zoom factor: " << v.fZoo 381 os << "\n Zoom factor: " << v.fZoomFactor;
976 382
977 os << "\n Scale factor: " << v.fSca 383 os << "\n Scale factor: " << v.fScaleFactor;
978 384
979 os << "\n Current target point: " << v.fCur 385 os << "\n Current target point: " << v.fCurrentTargetPoint;
980 386
981 os << "\n Dolly distance: " << v.fDol 387 os << "\n Dolly distance: " << v.fDolly;
982 388
983 os << "\n Light "; 389 os << "\n Light ";
984 if (v.fLightsMoveWithCamera) os << "moves"; 390 if (v.fLightsMoveWithCamera) os << "moves";
985 else os << "does not 391 else os << "does not move";
986 os << " with camera"; 392 os << " with camera";
987 393
988 os << "\n Relative lightpoint direction: " 394 os << "\n Relative lightpoint direction: "
989 << v.fRelativeLightpointDirection; 395 << v.fRelativeLightpointDirection;
990 396
991 os << "\n Actual lightpoint direction: " 397 os << "\n Actual lightpoint direction: "
992 << v.fActualLightpointDirection; 398 << v.fActualLightpointDirection;
993 399
994 os << "\n Derived parameters for standard v 400 os << "\n Derived parameters for standard view of object of unit radius:";
995 G4ViewParameters tempVP = v; 401 G4ViewParameters tempVP = v;
996 tempVP.fDolly = 0.; 402 tempVP.fDolly = 0.;
997 tempVP.fZoomFactor = 1.; 403 tempVP.fZoomFactor = 1.;
998 const G4double radius = 1.; 404 const G4double radius = 1.;
999 const G4double cameraDistance = tempVP.GetCa 405 const G4double cameraDistance = tempVP.GetCameraDistance (radius);
1000 const G4double nearDistance = 406 const G4double nearDistance =
1001 tempVP.GetNearDistance (cameraDistance, r 407 tempVP.GetNearDistance (cameraDistance, radius);
1002 const G4double farDistance = 408 const G4double farDistance =
1003 tempVP.GetFarDistance (cameraDistance, n 409 tempVP.GetFarDistance (cameraDistance, nearDistance, radius);
1004 const G4double right = tempVP.GetFrontHalf 410 const G4double right = tempVP.GetFrontHalfHeight (nearDistance, radius);
1005 os << "\n Camera distance: " << camera 411 os << "\n Camera distance: " << cameraDistance;
1006 os << "\n Near distance: " << nearDi 412 os << "\n Near distance: " << nearDistance;
1007 os << "\n Far distance: " << farDis 413 os << "\n Far distance: " << farDistance;
1008 os << "\n Front half height: " << right; 414 os << "\n Front half height: " << right;
1009 415
>> 416 os << "\n View geometry: ";
>> 417 if (v.fViewGeom) os << "true";
>> 418 else os << "false";
>> 419
>> 420 os << "\n View hits : ";
>> 421 if (v.fViewHits) os << "true";
>> 422 else os << "false";
>> 423
>> 424 os << "\n View digits : ";
>> 425 if (v.fViewDigis) os << "true";
>> 426 else os << "false";
>> 427
1010 os << "\n Default VisAttributes:\n " << v 428 os << "\n Default VisAttributes:\n " << v.fDefaultVisAttributes;
1011 429
1012 os << "\n Default TextVisAttributes:\n " 430 os << "\n Default TextVisAttributes:\n " << v.fDefaultTextVisAttributes;
1013 431
1014 os << "\n Default marker:\n " << v.fDef << 432 os << "\n Default marker: " << v.fDefaultMarker;
1015 433
1016 os << "\n Global marker scale: " << v.fGlo 434 os << "\n Global marker scale: " << v.fGlobalMarkerScale;
1017 435
1018 os << "\n Global lineWidth scale: " << v.f <<
1019 <<
1020 os << "\n Marker "; 436 os << "\n Marker ";
1021 if (v.fMarkerNotHidden) os << "not "; 437 if (v.fMarkerNotHidden) os << "not ";
1022 os << "hidden by surfaces."; 438 os << "hidden by surfaces.";
1023 439
1024 os << "\n Window size hint: " 440 os << "\n Window size hint: "
1025 << v.fWindowSizeHintX << 'x'<< v.fWindow 441 << v.fWindowSizeHintX << 'x'<< v.fWindowSizeHintX;
1026 442
1027 os << "\n X geometry string: " << v.fXGeom 443 os << "\n X geometry string: " << v.fXGeometryString;
1028 os << "\n X geometry mask: " <<
1029 << std::showbase << std::hex << v.fGeome <<
1030 << std::noshowbase << std::dec; <<
1031 444
1032 os << "\n Auto refresh: "; 445 os << "\n Auto refresh: ";
1033 if (v.fAutoRefresh) os << "true"; 446 if (v.fAutoRefresh) os << "true";
1034 else os << "false"; 447 else os << "false";
1035 448
1036 os << "\n Background colour: " << v.fBackg 449 os << "\n Background colour: " << v.fBackgroundColour;
1037 450
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; 451 return os;
1100 } 452 }
1101 453
1102 G4bool G4ViewParameters::operator != (const G 454 G4bool G4ViewParameters::operator != (const G4ViewParameters& v) const {
1103 455
1104 // Put performance-sensitive parameters fir 456 // Put performance-sensitive parameters first.
1105 if ( 457 if (
1106 // This first to optimise spin, etc. 458 // This first to optimise spin, etc.
1107 (fViewpointDirection != v.fViewpointD 459 (fViewpointDirection != v.fViewpointDirection) ||
1108 460
1109 // No particular order from here on. 461 // No particular order from here on.
1110 (fDrawingStyle != v.fDrawingSty 462 (fDrawingStyle != v.fDrawingStyle) ||
1111 (fNumberOfCloudPoints != v.fNumberOfCl <<
1112 (fAuxEdgeVisible != v.fAuxEdgeVis 463 (fAuxEdgeVisible != v.fAuxEdgeVisible) ||
>> 464 (fRepStyle != v.fRepStyle) ||
1113 (fCulling != v.fCulling) 465 (fCulling != v.fCulling) ||
1114 (fCullInvisible != v.fCullInvisi 466 (fCullInvisible != v.fCullInvisible) ||
1115 (fDensityCulling != v.fDensityCul 467 (fDensityCulling != v.fDensityCulling) ||
1116 (fCullCovered != v.fCullCovere 468 (fCullCovered != v.fCullCovered) ||
1117 (fCBDAlgorithmNumber != v.fCBDAlgorit <<
1118 (fSection != v.fSection) 469 (fSection != v.fSection) ||
1119 (IsCutaway() != v.IsCutaway() << 470 (fCutaway != v.fCutaway) ||
1120 (IsExplode() != v.IsExplode() << 471 (fExplode != v.fExplode) ||
1121 (fNoOfSides != v.fNoOfSides) 472 (fNoOfSides != v.fNoOfSides) ||
1122 (fUpVector != v.fUpVector) 473 (fUpVector != v.fUpVector) ||
1123 (fFieldHalfAngle != v.fFieldHalfA 474 (fFieldHalfAngle != v.fFieldHalfAngle) ||
1124 (fZoomFactor != v.fZoomFactor 475 (fZoomFactor != v.fZoomFactor) ||
1125 (fScaleFactor != v.fScaleFacto 476 (fScaleFactor != v.fScaleFactor) ||
1126 (fCurrentTargetPoint != v.fCurrentTar 477 (fCurrentTargetPoint != v.fCurrentTargetPoint) ||
1127 (fDolly != v.fDolly) 478 (fDolly != v.fDolly) ||
1128 (fRelativeLightpointDirection != v.fRel 479 (fRelativeLightpointDirection != v.fRelativeLightpointDirection) ||
1129 (fLightsMoveWithCamera != v.fLightsMove 480 (fLightsMoveWithCamera != v.fLightsMoveWithCamera) ||
>> 481 (fViewGeom != v.fViewGeom) ||
>> 482 (fViewHits != v.fViewHits) ||
>> 483 (fViewDigis != v.fViewDigis) ||
1130 (fDefaultVisAttributes != v.fDefaultVis 484 (fDefaultVisAttributes != v.fDefaultVisAttributes) ||
1131 (fDefaultTextVisAttributes != v.fDefaul 485 (fDefaultTextVisAttributes != v.fDefaultTextVisAttributes) ||
1132 (fDefaultMarker != v.fDefaultMar 486 (fDefaultMarker != v.fDefaultMarker) ||
1133 (fGlobalMarkerScale != v.fGlobalMark 487 (fGlobalMarkerScale != v.fGlobalMarkerScale) ||
1134 (fGlobalLineWidthScale != v.fGlobalLine <<
1135 (fMarkerNotHidden != v.fMarkerNotH 488 (fMarkerNotHidden != v.fMarkerNotHidden) ||
1136 (fWindowSizeHintX != v.fWindowSize 489 (fWindowSizeHintX != v.fWindowSizeHintX) ||
1137 (fWindowSizeHintY != v.fWindowSize 490 (fWindowSizeHintY != v.fWindowSizeHintY) ||
1138 (fXGeometryString != v.fXGeometryS 491 (fXGeometryString != v.fXGeometryString) ||
1139 (fGeometryMask != v.fGeometryMa <<
1140 (fAutoRefresh != v.fAutoRefres 492 (fAutoRefresh != v.fAutoRefresh) ||
1141 (fBackgroundColour != v.fBackground << 493 (fBackgroundColour != v.fBackgroundColour))
1142 (fPicking != v.fPicking) <<
1143 (fRotationStyle != v.fRotationSt <<
1144 (fSpecialMeshRendering != v.fSpecialMes <<
1145 (fSpecialMeshRenderingOption != v.fSpec <<
1146 ) <<
1147 return true; 494 return true;
1148 495
1149 if (fDensityCulling && 496 if (fDensityCulling &&
1150 (fVisibleDensity != v.fVisibleDensity)) 497 (fVisibleDensity != v.fVisibleDensity)) return true;
1151 498
1152 if (fCBDAlgorithmNumber > 0) { <<
1153 if (fCBDParameters.size() != v.fCBDParame <<
1154 else if (fCBDParameters != v.fCBDParamete <<
1155 } <<
1156 <<
1157 if (fSection && 499 if (fSection &&
1158 (!(fSectionPlane == v.fSectionPlane))) 500 (!(fSectionPlane == v.fSectionPlane))) return true;
1159 501
1160 if (IsCutaway()) { << 502 if (fCutaway) {
1161 if (fCutawayPlanes.size () != v.fCutawayP 503 if (fCutawayPlanes.size () != v.fCutawayPlanes.size ())
1162 return true; 504 return true;
1163 else { 505 else {
1164 for (size_t i = 0; i < fCutawayPlanes.s 506 for (size_t i = 0; i < fCutawayPlanes.size (); i++) {
1165 if (!(fCutawayPlanes[i] == v.fCutawayPlanes 507 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[i])) return true;
1166 } 508 }
1167 } 509 }
1168 } 510 }
1169 511
1170 if (IsExplode() && << 512 if (fExplode &&
1171 ((fExplodeFactor != v.fExplodeFactor) | << 513 (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 514
1210 return false; 515 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 } 516 }
1721 517