| Geant4 Cross Reference |
1 //
2 // ********************************************************************
3 // * License and Disclaimer *
4 // * *
5 // * The Geant4 software is copyright of the Copyright Holders of *
6 // * the Geant4 Collaboration. It is provided under the terms and *
7 // * conditions of the Geant4 Software License, included in the file *
8 // * LICENSE and available at http://cern.ch/geant4/license . These *
9 // * include a list of copyright holders. *
10 // * *
11 // * Neither the authors of this software system, nor their employing *
12 // * institutes,nor the agencies providing financial support for this *
13 // * work make any representation or warranty, express or implied, *
14 // * regarding this software system or assume any liability for its *
15 // * use. Please see the license in the file LICENSE and URL above *
16 // * for the full disclaimer and the limitation of liability. *
17 // * *
18 // * This code implementation is the result of the scientific and *
19 // * technical work of the GEANT4 collaboration. *
20 // * By using, copying, modifying or distributing the software (or *
21 // * any work based on the software) you agree to acknowledge its *
22 // * use in resulting scientific publications, and indicate your *
23 // * acceptance of all terms of the Geant4 Software license. *
24 // ********************************************************************
25 //
26 // Created by Stewart Boogert on 05/03/2023.
27 //
28
29 #include "G4VVtkPipeline.hh" // Move basic hashing functionality to G4VtkUtility.(hh/cc
30 #include "G4VtkUtility.hh"
31
32 #include "G4Transform3D.hh"
33 #include "G4Colour.hh"
34
35 #include <vtkMatrix4x4.h>
36 #include <vtkPlane.h>
37
38 vtkSmartPointer<vtkMatrix4x4> G4Transform3DToVtkMatrix4x4(const G4Transform3D& g4Trans)
39 {
40 auto transform = vtkSmartPointer<vtkMatrix4x4>();
41
42 double transformArray[16] = {g4Trans.xx(), g4Trans.xy(), g4Trans.xy(), g4Trans.dx(),
43 g4Trans.yx(), g4Trans.yy(), g4Trans.yy(), g4Trans.dy(),
44 g4Trans.zx(), g4Trans.zy(), g4Trans.zy(), g4Trans.dz(),
45 0., 0., 0., 1.};
46 transform->DeepCopy(transformArray);
47 return transform;
48 }
49
50 vtkSmartPointer<vtkPlane> G4Plane3DToVtkPlane(const G4Plane3D& g4plane)
51 {
52 auto plane = vtkSmartPointer<vtkPlane>::New();
53
54 auto g4normal = g4plane.normal();
55 auto g4point = g4plane.point();
56
57 plane->SetNormal(g4normal.x(), g4normal.y(), g4normal.z());
58 plane->SetOrigin(g4point.x(), g4point.y(), g4point.z());
59
60 return plane;
61 }
62
63 G4Plane3D VtkPlaneToG4Plane3D(vtkPlane* vtkPlane)
64 {
65 auto point = vtkPlane->GetOrigin();
66 auto normal = vtkPlane->GetNormal();
67
68 G4Plane3D plane =
69 G4Plane3D(G4Normal3D(normal[0], normal[1], normal[2]), G4Point3D(point[0], point[1], point[2]));
70 return plane;
71 }
72
73 void MaxBounds(G4double* maxBound, G4double* boundToCheck)
74 {
75 if (boundToCheck[0] < maxBound[0]) maxBound[0] = boundToCheck[0];
76 if (boundToCheck[1] > maxBound[1]) maxBound[1] = boundToCheck[1];
77
78 if (boundToCheck[2] < maxBound[2]) maxBound[2] = boundToCheck[2];
79 if (boundToCheck[3] > maxBound[3]) maxBound[3] = boundToCheck[3];
80
81 if (boundToCheck[4] < maxBound[4]) maxBound[4] = boundToCheck[4];
82 if (boundToCheck[5] > maxBound[5]) maxBound[5] = boundToCheck[5];
83 }
84
85
86 std::size_t MakeHash(const G4ThreeVector &v)
87 {
88
89 std::size_t xhash = std::hash<G4double>{}(v.x());
90 std::size_t yhash = std::hash<G4double>{}(v.y());
91 std::size_t zhash = std::hash<G4double>{}(v.z());
92
93 std::hash_combine(xhash, yhash);
94 std::hash_combine(yhash, zhash);
95
96 return xhash;
97 }
98
99 std::size_t MakeHash(const G4Colour &c)
100 {
101
102 std::size_t rhash = std::hash<G4double>{}(c.GetRed());
103 std::size_t ghash = std::hash<G4double>{}(c.GetGreen());
104 std::size_t bhash = std::hash<G4double>{}(c.GetBlue());
105 std::size_t ahash = std::hash<G4double>{}(c.GetAlpha());
106
107 std::hash_combine(rhash, ghash);
108 std::hash_combine(rhash, bhash);
109 std::hash_combine(rhash, ahash);
110
111 return rhash;
112 }