| Geant4 Cross Reference |
1 // 1
2 // *******************************************
3 // * License and Disclaimer
4 // *
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 //
27 //
28 //
29 // John Allison 19th July 1996
30 // View parameters and options.
31
32 #include "G4ViewParameters.hh"
33
34 #include "G4VisManager.hh"
35 #include "G4VPhysicalVolume.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
45 G4ViewParameters::G4ViewParameters ():
46 fDrawingStyle (wireframe),
47 fNumberOfCloudPoints(10000),
48 fAuxEdgeVisible (false),
49 fCulling (true),
50 fCullInvisible (true),
51 fDensityCulling (false),
52 fVisibleDensity (0.01 * g / cm3),
53 fCullCovered (false),
54 fCBDAlgorithmNumber (0),
55 fSection (false),
56 fSectionPlane (),
57 fCutawayMode (cutawayUnion),
58 fCutawayPlanes (),
59 fExplodeFactor (1.),
60 fNoOfSides (),
61 fViewpointDirection (G4Vector3D (0., 0., 1.)
62 fUpVector (G4Vector3D (0., 1., 0.)),
63 fFieldHalfAngle (0.),
64 fZoomFactor (1.),
65 fScaleFactor (G4Vector3D (1., 1., 1.)),
66 fCurrentTargetPoint (),
67 fDolly (0.),
68 fLightsMoveWithCamera (false),
69 fRelativeLightpointDirection (G4Vector3D (1.
70 fActualLightpointDirection (G4Vector3D (1.,
71 fDefaultVisAttributes (),
72 fDefaultTextVisAttributes (G4Colour (0., 0.,
73 fDefaultMarker (),
74 fGlobalMarkerScale (1.),
75 fGlobalLineWidthScale (1.),
76 fMarkerNotHidden (true),
77 fWindowSizeHintX (600),
78 fWindowSizeHintY (600),
79 fWindowLocationHintX(0),
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 {
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.);
119 // Markers are 5 pixels "overall" size, i.e.
120 }
121
122 G4ViewParameters::~G4ViewParameters () {}
123
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 }
130
131 G4Vector3D& G4ViewParameters::GetActualLightpo
132 SetViewAndLights (fViewpointDirection);
133 return fActualLightpointDirection;
134 }
135
136 // Useful quantities - begin snippet.
137 // Here Follow functions to evaluate the above
138 // function of the radius of the Bounding Sphe
139 // viewed. Call them in the order given - for
140 // functions depend on the results of earlier
141 // results of earlier functions in your own te
142 // see, for example, G4OpenGLView::SetView ().
143
144 G4double G4ViewParameters::GetCameraDistance (
145 G4double cameraDistance;
146 if (fFieldHalfAngle == 0.) {
147 cameraDistance = radius;
148 }
149 else {
150 cameraDistance = radius / std::sin (fField
151 }
152 return cameraDistance;
153 }
154
155 G4double G4ViewParameters::GetNearDistance (G4
156 G4double radius) const {
157 const G4double small = 1.e-6 * radius;
158 G4double nearDistance = cameraDistance - rad
159 if (nearDistance < small) nearDistance = sma
160 return nearDistance;
161 }
162
163 G4double G4ViewParameters::GetFarDistance (G4d
164 G4double nearDistance,
165 G4double radius) const {
166 G4double farDistance = cameraDistance + radi
167 if (farDistance < nearDistance) farDistance
168 return farDistance;
169 }
170
171 G4double G4ViewParameters::GetFrontHalfHeight
172 G4double radius) const {
173 G4double frontHalfHeight;
174 if (fFieldHalfAngle == 0.) {
175 frontHalfHeight = radius / fZoomFactor;
176 }
177 else {
178 frontHalfHeight = nearDistance * std::tan
179 }
180 return frontHalfHeight;
181 }
182 // Useful quantities - end snippet.
183
184 void G4ViewParameters::AddCutawayPlane (const
185 if (fCutawayPlanes.size () < 3 ) {
186 fCutawayPlanes.push_back (cutawayPlane);
187 }
188 else {
189 G4warn <<
190 "ERROR: G4ViewParameters::AddCutawayPlan
191 "\n A maximum of 3 cutaway planes suppo
192 }
193 }
194
195 void G4ViewParameters::ChangeCutawayPlane
196 (size_t index, const G4Plane3D& cutawayPlane)
197 if (index >= fCutawayPlanes.size()) {
198 G4warn <<
199 "ERROR: G4ViewParameters::ChangeCutawayP
200 "\n Plane " << index << " does not exis
201 } else {
202 fCutawayPlanes[index] = cutawayPlane;
203 }
204 }
205
206 void G4ViewParameters::SetVisibleDensity (G4do
207 const G4double reasonableMaximum = 10.0 * g
208 if (visibleDensity < 0) {
209 G4warn << "G4ViewParameters::SetVisibleDen
210 "density - ignored." << G4endl;
211 }
212 else {
213 if (visibleDensity > reasonableMaximum) {
214 G4warn << "G4ViewParameters::SetVisibleD
215 << G4BestUnit (reasonableMaximum, "Volu
216 << " - did you mean this?"
217 << G4endl;
218 }
219 fVisibleDensity = visibleDensity;
220 }
221 }
222
223 G4int G4ViewParameters::SetNoOfSides (G4int nS
224 const G4int nSidesMin = fDefaultVisAttribute
225 if (nSides < nSidesMin) {
226 nSides = nSidesMin;
227 G4warn << "G4ViewParameters::SetNoOfSides:
228 "\nnumber of sides per circle < " << nSide
229 << "; forced to " << nSides << G4endl;
230 }
231 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 }
246
247 void G4ViewParameters::SetViewAndLights
248 (const G4Vector3D& viewpointDirection) {
249
250 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) {
267 G4Vector3D zprime = fViewpointDirection.un
268 G4Vector3D xprime = (fUpVector.cross (zpri
269 G4Vector3D yprime = zprime.cross (xprime);
270 fActualLightpointDirection =
271 fRelativeLightpointDirection.x () * xpri
272 fRelativeLightpointDirection.y () * ypri
273 fRelativeLightpointDirection.x () * zpri
274 } else {
275 fActualLightpointDirection = fRelativeLigh
276 }
277 }
278
279 void G4ViewParameters::SetLightpointDirection
280 (const G4Vector3D& lightpointDirection) {
281 fRelativeLightpointDirection = lightpointDir
282 SetViewAndLights (fViewpointDirection);
283 }
284
285 void G4ViewParameters::SetPan (G4double right,
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
297 G4Vector3D unitUp = (fViewpointDirection.
298 fCurrentTargetPoint += right * unitRight + u
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 }
758
759 void G4ViewParameters::PrintDifferences (const
760
761 // Put performance-sensitive parameters firs
762 if (
763 // This first to optimise spin, etc.
764 (fViewpointDirection != v.fViewpointDi
765
766 // No particular order from here on.
767 (fDrawingStyle != v.fDrawingStyl
768 (fNumberOfCloudPoints != v.fNumberOfClo
769 (fAuxEdgeVisible != v.fAuxEdgeVisi
770 (fCulling != v.fCulling)
771 (fCullInvisible != v.fCullInvisib
772 (fDensityCulling != v.fDensityCull
773 (fVisibleDensity != v.fVisibleDens
774 (fCullCovered != v.fCullCovered
775 (fCBDAlgorithmNumber != v.fCBDAlgorith
776 (fSection != v.fSection)
777 (fNoOfSides != v.fNoOfSides)
778 (fUpVector != v.fUpVector)
779 (fFieldHalfAngle != v.fFieldHalfAn
780 (fZoomFactor != v.fZoomFactor)
781 (fScaleFactor != v.fScaleFactor
782 (fCurrentTargetPoint != v.fCurrentTarg
783 (fDolly != v.fDolly)
784 (fRelativeLightpointDirection != v.fRela
785 (fLightsMoveWithCamera != v.fLightsMoveW
786 (fDefaultVisAttributes != v.fDefaultVisA
787 (fDefaultTextVisAttributes != v.fDefault
788 (fDefaultMarker != v.fDefaultMark
789 (fGlobalMarkerScale != v.fGlobalMarke
790 (fGlobalLineWidthScale != v.fGlobalLineW
791 (fMarkerNotHidden != v.fMarkerNotHi
792 (fWindowSizeHintX != v.fWindowSizeH
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
802
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) {
812 if (!(fSectionPlane == v.fSectionPlane))
813 G4cout << "Difference in section planes
814 }
815
816 if (IsCutaway()) {
817 if (fCutawayPlanes.size () != v.fCutawayPl
818 G4cout << "Difference in no of cutaway p
819 }
820 else {
821 for (size_t i = 0; i < fCutawayPlanes.si
822 if (!(fCutawayPlanes[i] == v.fCutawayPlanes[
823 G4cout << "Difference in cutaway plane no.
824 }
825 }
826 }
827
828 if (IsExplode()) {
829 if (fExplodeFactor != v.fExplodeFactor)
830 G4cout << "Difference in explode factor.
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 }
874 }
875
876 std::ostream& operator <<
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:";
911
912 os << "\n Drawing style: " << v.fDrawingSty
913
914 os << "\n Number of cloud points: " << v.fN
915
916 os << "\n Auxiliary edges: ";
917 if (!v.fAuxEdgeVisible) os << "in";
918 os << "visible";
919
920 os << "\n Culling: ";
921 if (v.fCulling) os << "on";
922 else os << "off";
923
924 os << "\n Culling invisible objects: ";
925 if (v.fCullInvisible) os << "on";
926 else os << "off";
927
928 os << "\n Density culling: ";
929 if (v.fDensityCulling) {
930 os << "on - invisible if density less than
931 << v.fVisibleDensity / (1. * g / cm3) <
932 }
933 else os << "off";
934
935 os << "\n Culling daughters covered by opaq
936 if (v.fCullCovered) os << "on";
937 else os << "off";
938
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: ";
950 if (v.fSection) os << "true, section/cut pla
951 else os << "false";
952
953 if (v.IsCutaway()) {
954 os << "\n Cutaway planes: ";
955 for (size_t i = 0; i < v.fCutawayPlanes.si
956 os << ' ' << v.fCutawayPlanes[i];
957 }
958 }
959 else {
960 os << "\n No cutaway planes";
961 }
962
963 os << "\n Explode factor: " << v.fExplodeFa
964 << " about centre: " << v.fExplodeCentre;
965
966 os << "\n No. of sides used in circle polyg
967 << v.fNoOfSides;
968
969 os << "\n Viewpoint direction: " << v.fVie
970
971 os << "\n Up vector: " << v.fUpV
972
973 os << "\n Field half angle: " << v.fFie
974
975 os << "\n Zoom factor: " << v.fZoo
976
977 os << "\n Scale factor: " << v.fSca
978
979 os << "\n Current target point: " << v.fCur
980
981 os << "\n Dolly distance: " << v.fDol
982
983 os << "\n Light ";
984 if (v.fLightsMoveWithCamera) os << "moves";
985 else os << "does not
986 os << " with camera";
987
988 os << "\n Relative lightpoint direction: "
989 << v.fRelativeLightpointDirection;
990
991 os << "\n Actual lightpoint direction: "
992 << v.fActualLightpointDirection;
993
994 os << "\n Derived parameters for standard v
995 G4ViewParameters tempVP = v;
996 tempVP.fDolly = 0.;
997 tempVP.fZoomFactor = 1.;
998 const G4double radius = 1.;
999 const G4double cameraDistance = tempVP.GetCa
1000 const G4double nearDistance =
1001 tempVP.GetNearDistance (cameraDistance, r
1002 const G4double farDistance =
1003 tempVP.GetFarDistance (cameraDistance, n
1004 const G4double right = tempVP.GetFrontHalf
1005 os << "\n Camera distance: " << camera
1006 os << "\n Near distance: " << nearDi
1007 os << "\n Far distance: " << farDis
1008 os << "\n Front half height: " << right;
1009
1010 os << "\n Default VisAttributes:\n " << v
1011
1012 os << "\n Default TextVisAttributes:\n "
1013
1014 os << "\n Default marker:\n " << v.fDef
1015
1016 os << "\n Global marker scale: " << v.fGlo
1017
1018 os << "\n Global lineWidth scale: " << v.f
1019
1020 os << "\n Marker ";
1021 if (v.fMarkerNotHidden) os << "not ";
1022 os << "hidden by surfaces.";
1023
1024 os << "\n Window size hint: "
1025 << v.fWindowSizeHintX << 'x'<< v.fWindow
1026
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;
1100 }
1101
1102 G4bool G4ViewParameters::operator != (const G
1103
1104 // Put performance-sensitive parameters fir
1105 if (
1106 // This first to optimise spin, etc.
1107 (fViewpointDirection != v.fViewpointD
1108
1109 // No particular order from here on.
1110 (fDrawingStyle != v.fDrawingSty
1111 (fNumberOfCloudPoints != v.fNumberOfCl
1112 (fAuxEdgeVisible != v.fAuxEdgeVis
1113 (fCulling != v.fCulling)
1114 (fCullInvisible != v.fCullInvisi
1115 (fDensityCulling != v.fDensityCul
1116 (fCullCovered != v.fCullCovere
1117 (fCBDAlgorithmNumber != v.fCBDAlgorit
1118 (fSection != v.fSection)
1119 (IsCutaway() != v.IsCutaway()
1120 (IsExplode() != v.IsExplode()
1121 (fNoOfSides != v.fNoOfSides)
1122 (fUpVector != v.fUpVector)
1123 (fFieldHalfAngle != v.fFieldHalfA
1124 (fZoomFactor != v.fZoomFactor
1125 (fScaleFactor != v.fScaleFacto
1126 (fCurrentTargetPoint != v.fCurrentTar
1127 (fDolly != v.fDolly)
1128 (fRelativeLightpointDirection != v.fRel
1129 (fLightsMoveWithCamera != v.fLightsMove
1130 (fDefaultVisAttributes != v.fDefaultVis
1131 (fDefaultTextVisAttributes != v.fDefaul
1132 (fDefaultMarker != v.fDefaultMar
1133 (fGlobalMarkerScale != v.fGlobalMark
1134 (fGlobalLineWidthScale != v.fGlobalLine
1135 (fMarkerNotHidden != v.fMarkerNotH
1136 (fWindowSizeHintX != v.fWindowSize
1137 (fWindowSizeHintY != v.fWindowSize
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;
1148
1149 if (fDensityCulling &&
1150 (fVisibleDensity != v.fVisibleDensity))
1151
1152 if (fCBDAlgorithmNumber > 0) {
1153 if (fCBDParameters.size() != v.fCBDParame
1154 else if (fCBDParameters != v.fCBDParamete
1155 }
1156
1157 if (fSection &&
1158 (!(fSectionPlane == v.fSectionPlane)))
1159
1160 if (IsCutaway()) {
1161 if (fCutawayPlanes.size () != v.fCutawayP
1162 return true;
1163 else {
1164 for (size_t i = 0; i < fCutawayPlanes.s
1165 if (!(fCutawayPlanes[i] == v.fCutawayPlanes
1166 }
1167 }
1168 }
1169
1170 if (IsExplode() &&
1171 ((fExplodeFactor != v.fExplodeFactor) |
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
1210 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 }
1721