| 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 // class G4AffineTransform
27 //
28 // Class description:
29 //
30 // A class for geometric affine transformations [see, eg. Foley & Van Dam]
31 // Supports efficient arbitrary rotation & transformation of vectors and the
32 // computation of compound & inverse transformations. A `rotation flag' is
33 // maintained internally for greater computational efficiency for transforms
34 // that do not involve rotation.
35 //
36 // Interfaces to the CLHEP classes G4ThreeVector & G4RotationMatrix
37 //
38 // For member function descriptions, see comments by declarations. For
39 // additional clarification, also check the `const' declarations for
40 // functions & their parameters.
41 //
42 // Member data:
43 //
44 // G4double rxx,rxy,rxz;
45 // G4double ryx,ryy,ryz; A 3x3 rotation matrix - net rotation
46 // G4double rzx,rzy,rzz;
47 // G4double tx,ty,tz; Net translation
48
49 // 06.08.1996 Paul R C Kent:
50 // - initial version
51 // 19.09.1996 E.Tcherniaev:
52 // - direct access to the protected members of the G4RotationMatrix class
53 // replaced by access via public access functions
54 // - conversion of the rotation matrix to angle & axis used to get
55 // a possibility to remove "friend" from the G4RotationMatrix class
56 // 06.05.2018 E.Tcherniaev:
57 // - optimised InverseProduct
58 // - added methods for inverse transformation: InverseTrasformPoint,
59 // InverseTransformAxis, InverseNetRotation, InverseNetTranslation
60 // --------------------------------------------------------------------
61 #ifndef G4AFFINETRANSFORM_HH
62 #define G4AFFINETRANSFORM_HH
63
64 #include "G4Types.hh"
65 #include "G4ThreeVector.hh"
66 #include "G4RotationMatrix.hh"
67 #include "G4Transform3D.hh"
68
69 class G4AffineTransform
70 {
71 public:
72
73 inline G4AffineTransform();
74
75 public: // with description
76
77 inline G4AffineTransform(const G4ThreeVector& tlate);
78 // Translation only: under t'form translate point at origin by tlate
79
80 inline G4AffineTransform(const G4RotationMatrix& rot);
81 // Rotation only: under t'form rotate by rot
82
83 inline G4AffineTransform(const G4RotationMatrix& rot,
84 const G4ThreeVector& tlate);
85 // Under t'form: rotate by rot then translate by tlate
86
87 inline G4AffineTransform(const G4RotationMatrix* rot,
88 const G4ThreeVector& tlate);
89 // Optionally rotate by *rot then translate by tlate - rot may be null
90
91 inline G4AffineTransform(const G4AffineTransform& rhs) = default;
92 inline G4AffineTransform(G4AffineTransform&& rhs) = default;
93 // Copy and move constructors
94
95 inline G4AffineTransform& operator=(const G4AffineTransform& rhs);
96 inline G4AffineTransform& operator=(G4AffineTransform&& rhs) = default;
97 // Assignment & Move operators
98
99 inline ~G4AffineTransform() = default;
100 // Destructor
101
102 inline G4AffineTransform operator * (const G4AffineTransform& tf) const;
103 // Compound Transforms:
104 // tf2=tf2*tf1 equivalent to tf2*=tf1
105 // Returns compound transformation of self*tf
106
107 inline G4AffineTransform& operator *= (const G4AffineTransform& tf);
108 // (Modifying) Multiplies self by tf; Returns self reference
109 // ie. A=AB for a*=b
110
111 inline G4AffineTransform& Product(const G4AffineTransform& tf1,
112 const G4AffineTransform& tf2);
113 // 'Products' for avoiding (potential) temporaries:
114 // c.Product(a,b) equivalent to c=a*b
115 // c.InverseProduct(a*b,b ) equivalent to c=a
116 // (Modifying) Sets self=tf1*tf2; Returns self reference
117
118 inline G4AffineTransform& InverseProduct(const G4AffineTransform& tf1,
119 const G4AffineTransform& tf2);
120 // (Modifying) Sets self=tf1*(tf2^-1); Returns self reference
121
122 inline G4ThreeVector TransformPoint(const G4ThreeVector& vec) const;
123 // Transform the specified point: returns vec*rot+tlate
124
125 inline G4ThreeVector InverseTransformPoint(const G4ThreeVector& vec) const;
126 // Transform the specified point using inverse transformation
127
128 inline G4ThreeVector TransformAxis(const G4ThreeVector& axis) const;
129 // Transform the specified axis: returns vec*rot
130
131 inline G4ThreeVector InverseTransformAxis(const G4ThreeVector& axis) const;
132 // Transform the specified axis using inverse transfromation
133
134 inline void ApplyPointTransform(G4ThreeVector& vec) const;
135 // Transform the specified point (in place): sets vec=vec*rot+tlate
136
137 inline void ApplyAxisTransform(G4ThreeVector& axis) const;
138 // Transform the specified axis (in place): sets axis=axis*rot;
139
140 inline G4AffineTransform Inverse() const;
141 // Return inverse of current transform
142
143 inline G4AffineTransform& Invert();
144 // (Modifying) Sets self=inverse of self; Returns self reference
145
146 inline G4AffineTransform& operator +=(const G4ThreeVector& tlate);
147 inline G4AffineTransform& operator -=(const G4ThreeVector& tlate);
148 // (Modifying) Adjust net translation by given vector;
149 // Returns self reference
150
151 inline G4bool operator == (const G4AffineTransform& tf) const;
152 inline G4bool operator != (const G4AffineTransform& tf) const;
153
154 inline G4double operator [] (const G4int n) const;
155
156 inline G4bool IsRotated() const;
157 // True if transform includes rotation
158
159 inline G4bool IsTranslated() const;
160 // True if transform includes translation
161
162 inline G4RotationMatrix NetRotation() const;
163
164 inline G4RotationMatrix InverseNetRotation() const;
165
166 inline G4ThreeVector NetTranslation() const;
167
168 inline G4ThreeVector InverseNetTranslation() const;
169
170 inline void SetNetRotation(const G4RotationMatrix& rot);
171
172 inline void SetNetTranslation(const G4ThreeVector& tlate);
173
174 inline operator G4Transform3D () const;
175 // Conversion operator (cast) to G4Transform3D
176
177 private:
178
179 inline G4AffineTransform(
180 const G4double prxx, const G4double prxy, const G4double prxz,
181 const G4double pryx, const G4double pryy, const G4double pryz,
182 const G4double przx, const G4double przy, const G4double przz,
183 const G4double ptx, const G4double pty, const G4double ptz);
184
185 G4double rxx,rxy,rxz;
186 G4double ryx,ryy,ryz;
187 G4double rzx,rzy,rzz;
188 G4double tx,ty,tz;
189 };
190
191 std::ostream& operator << (std::ostream& os, const G4AffineTransform& transf);
192
193 #include "G4AffineTransform.icc"
194
195 #endif
196