source: trunk/source/geometry/management/include/G4AffineTransform.icc@ 1347

Last change on this file since 1347 was 1337, checked in by garnier, 15 years ago

tag geant4.9.4 beta 1 + modifs locales
File size: 12.9 KB
Line 
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//
27// $Id: G4AffineTransform.icc,v 1.8 2006/06/29 18:30:39 gunter Exp $
28// GEANT4 tag $Name: geant4-09-04-beta-01 $
29//
30//
31// G4AffineTransformation Inline implementation
32//
33// --------------------------------------------------------------------
34
35inline G4AffineTransform::G4AffineTransform()
36 : rxx(1),rxy(0),rxz(0),
37 ryx(0),ryy(1),ryz(0),
38 rzx(0),rzy(0),rzz(1),
39 tx(0),ty(0),tz(0)
40{}
41
42inline G4AffineTransform::G4AffineTransform(const G4ThreeVector& tlate)
43 : rxx(1),rxy(0),rxz(0),
44 ryx(0),ryy(1),ryz(0),
45 rzx(0),rzy(0),rzz(1),
46 tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
47{}
48
49inline G4AffineTransform::G4AffineTransform(const G4RotationMatrix& rot)
50 : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
51 ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
52 rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
53 tx(0),ty(0),tz(0)
54{}
55
56inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix& rot,
57 const G4ThreeVector& tlate )
58 : rxx(rot.xx()),rxy(rot.xy()),rxz(rot.xz()),
59 ryx(rot.yx()),ryy(rot.yy()),ryz(rot.yz()),
60 rzx(rot.zx()),rzy(rot.zy()),rzz(rot.zz()),
61 tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
62{}
63
64inline G4AffineTransform::G4AffineTransform( const G4RotationMatrix *rot,
65 const G4ThreeVector& tlate)
66 : tx(tlate.x()),ty(tlate.y()),tz(tlate.z())
67{
68 if (rot)
69 {
70 rxx=rot->xx();rxy=rot->xy();rxz=rot->xz();
71 ryx=rot->yx();ryy=rot->yy();ryz=rot->yz();
72 rzx=rot->zx();rzy=rot->zy();rzz=rot->zz();
73 }
74 else
75 {
76 rxx=1; rxy=0; rxz=0;
77 ryx=0; ryy=1; ryz=0;
78 rzx=0; rzy=0; rzz=1;
79 }
80}
81
82inline
83G4AffineTransform::
84G4AffineTransform( const G4double prxx,const G4double prxy,const G4double prxz,
85 const G4double pryx,const G4double pryy,const G4double pryz,
86 const G4double przx,const G4double przy,const G4double przz,
87 const G4double ptx,const G4double pty,const G4double ptz)
88 : rxx(prxx),rxy(prxy),rxz(prxz),
89 ryx(pryx),ryy(pryy),ryz(pryz),
90 rzx(przx),rzy(przy),rzz(przz),
91 tx(ptx),ty(pty),tz(ptz)
92{}
93
94inline G4AffineTransform
95G4AffineTransform::operator * (const G4AffineTransform& tf) const
96{
97 return G4AffineTransform(
98 rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx,
99 rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy,
100 rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz,
101
102 ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx,
103 ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy,
104 ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz,
105
106 rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx,
107 rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy,
108 rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz,
109
110 tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx,
111 tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty,
112 tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz);
113}
114
115inline G4AffineTransform&
116G4AffineTransform::operator *= (const G4AffineTransform& tf)
117{
118 // Use temporaries for `in place' compound transform computation
119
120 G4double nrxx=rxx*tf.rxx+rxy*tf.ryx+rxz*tf.rzx;
121 G4double nrxy=rxx*tf.rxy+rxy*tf.ryy+rxz*tf.rzy;
122 G4double nrxz=rxx*tf.rxz+rxy*tf.ryz+rxz*tf.rzz;
123
124 G4double nryx=ryx*tf.rxx+ryy*tf.ryx+ryz*tf.rzx;
125 G4double nryy=ryx*tf.rxy+ryy*tf.ryy+ryz*tf.rzy;
126 G4double nryz=ryx*tf.rxz+ryy*tf.ryz+ryz*tf.rzz;
127
128 G4double nrzx=rzx*tf.rxx+rzy*tf.ryx+rzz*tf.rzx;
129 G4double nrzy=rzx*tf.rxy+rzy*tf.ryy+rzz*tf.rzy;
130 G4double nrzz=rzx*tf.rxz+rzy*tf.ryz+rzz*tf.rzz;
131
132 G4double ntx=tx*tf.rxx+ty*tf.ryx+tz*tf.rzx+tf.tx;
133 G4double nty=tx*tf.rxy+ty*tf.ryy+tz*tf.rzy+tf.ty;
134 G4double ntz=tx*tf.rxz+ty*tf.ryz+tz*tf.rzz+tf.tz;
135
136 tx=ntx; ty=nty; tz=ntz;
137 rxx=nrxx; rxy=nrxy; rxz=nrxz;
138 ryx=nryx; ryy=nryy; ryz=nryz;
139 rzx=nrzx; rzy=nrzy; rzz=nrzz;
140
141 return *this;
142}
143
144inline G4AffineTransform&
145G4AffineTransform::Product(const G4AffineTransform& tf1,
146 const G4AffineTransform& tf2)
147{
148 rxx=tf1.rxx*tf2.rxx + tf1.rxy*tf2.ryx + tf1.rxz*tf2.rzx;
149 rxy=tf1.rxx*tf2.rxy + tf1.rxy*tf2.ryy + tf1.rxz*tf2.rzy;
150 rxz=tf1.rxx*tf2.rxz + tf1.rxy*tf2.ryz + tf1.rxz*tf2.rzz;
151
152 ryx=tf1.ryx*tf2.rxx + tf1.ryy*tf2.ryx + tf1.ryz*tf2.rzx;
153 ryy=tf1.ryx*tf2.rxy + tf1.ryy*tf2.ryy + tf1.ryz*tf2.rzy;
154 ryz=tf1.ryx*tf2.rxz + tf1.ryy*tf2.ryz + tf1.ryz*tf2.rzz;
155
156 rzx=tf1.rzx*tf2.rxx + tf1.rzy*tf2.ryx + tf1.rzz*tf2.rzx;
157 rzy=tf1.rzx*tf2.rxy + tf1.rzy*tf2.ryy + tf1.rzz*tf2.rzy;
158 rzz=tf1.rzx*tf2.rxz + tf1.rzy*tf2.ryz + tf1.rzz*tf2.rzz;
159
160 tx=tf1.tx*tf2.rxx + tf1.ty*tf2.ryx + tf1.tz*tf2.rzx + tf2.tx;
161 ty=tf1.tx*tf2.rxy + tf1.ty*tf2.ryy + tf1.tz*tf2.rzy + tf2.ty;
162 tz=tf1.tx*tf2.rxz + tf1.ty*tf2.ryz + tf1.tz*tf2.rzz + tf2.tz;
163
164 return *this;
165}
166
167inline G4AffineTransform&
168G4AffineTransform::InverseProduct( const G4AffineTransform& tf1,
169 const G4AffineTransform& tf2)
170{
171 G4double itf2tx = - tf2.tx*tf2.rxx - tf2.ty*tf2.rxy - tf2.tz*tf2.rxz;
172 G4double itf2ty = - tf2.tx*tf2.ryx - tf2.ty*tf2.ryy - tf2.tz*tf2.ryz;
173 G4double itf2tz = - tf2.tx*tf2.rzx - tf2.ty*tf2.rzy - tf2.tz*tf2.rzz;
174
175 rxx=tf1.rxx*tf2.rxx+tf1.rxy*tf2.rxy+tf1.rxz*tf2.rxz;
176 rxy=tf1.rxx*tf2.ryx+tf1.rxy*tf2.ryy+tf1.rxz*tf2.ryz;
177 rxz=tf1.rxx*tf2.rzx+tf1.rxy*tf2.rzy+tf1.rxz*tf2.rzz;
178
179 ryx=tf1.ryx*tf2.rxx+tf1.ryy*tf2.rxy+tf1.ryz*tf2.rxz;
180 ryy=tf1.ryx*tf2.ryx+tf1.ryy*tf2.ryy+tf1.ryz*tf2.ryz;
181 ryz=tf1.ryx*tf2.rzx+tf1.ryy*tf2.rzy+tf1.ryz*tf2.rzz;
182
183 rzx=tf1.rzx*tf2.rxx+tf1.rzy*tf2.rxy+tf1.rzz*tf2.rxz;
184 rzy=tf1.rzx*tf2.ryx+tf1.rzy*tf2.ryy+tf1.rzz*tf2.ryz;
185 rzz=tf1.rzx*tf2.rzx+tf1.rzy*tf2.rzy+tf1.rzz*tf2.rzz;
186
187 tx=tf1.tx*tf2.rxx+tf1.ty*tf2.rxy+tf1.tz*tf2.rxz+itf2tx;
188 ty=tf1.tx*tf2.ryx+tf1.ty*tf2.ryy+tf1.tz*tf2.ryz+itf2ty;
189 tz=tf1.tx*tf2.rzx+tf1.ty*tf2.rzy+tf1.tz*tf2.rzz+itf2tz;
190
191 return *this;
192}
193
194inline
195G4ThreeVector G4AffineTransform::TransformPoint(const G4ThreeVector& vec) const
196{
197 return G4ThreeVector( vec.x()*rxx + vec.y()*ryx + vec.z()*rzx + tx,
198 vec.x()*rxy + vec.y()*ryy + vec.z()*rzy + ty,
199 vec.x()*rxz + vec.y()*ryz + vec.z()*rzz + tz );
200}
201
202inline
203G4ThreeVector G4AffineTransform::TransformAxis(const G4ThreeVector& axis) const
204{
205 return G4ThreeVector( axis.x()*rxx + axis.y()*ryx + axis.z()*rzx,
206 axis.x()*rxy + axis.y()*ryy + axis.z()*rzy,
207 axis.x()*rxz + axis.y()*ryz + axis.z()*rzz );
208}
209
210inline
211void G4AffineTransform::ApplyPointTransform(G4ThreeVector& vec) const
212{
213 G4double x = vec.x()*rxx + vec.y()*ryx + vec.z()*rzx + tx;
214 G4double y = vec.x()*rxy + vec.y()*ryy + vec.z()*rzy + ty;
215 G4double z = vec.x()*rxz + vec.y()*ryz + vec.z()*rzz + tz;
216
217 vec.setX(x);
218 vec.setY(y);
219 vec.setZ(z);
220}
221
222inline
223void G4AffineTransform::ApplyAxisTransform(G4ThreeVector& axis) const
224{
225 G4double x = axis.x()*rxx + axis.y()*ryx + axis.z()*rzx;
226 G4double y = axis.x()*rxy + axis.y()*ryy + axis.z()*rzy;
227 G4double z = axis.x()*rxz + axis.y()*ryz + axis.z()*rzz;
228
229 axis.setX(x);
230 axis.setY(y);
231 axis.setZ(z);
232}
233
234inline
235G4AffineTransform G4AffineTransform::Inverse() const
236{
237 return G4AffineTransform( rxx, ryx, rzx,
238 rxy, ryy, rzy,
239 rxz, ryz, rzz,
240
241 -tx*rxx - ty*rxy - tz*rxz,
242 -tx*ryx - ty*ryy - tz*ryz,
243 -tx*rzx - ty*rzy - tz*rzz );
244}
245
246inline
247G4AffineTransform& G4AffineTransform::Invert()
248{
249 G4double v1 = -tx*rxx - ty*rxy - tz*rxz;
250 G4double v2 = -tx*ryx - ty*ryy - tz*ryz;
251 G4double v3 = -tx*rzx - ty*rzy - tz*rzz;
252
253 tx=v1; ty=v2; tz=v3;
254
255 G4double tmp1=ryx; ryx=rxy; rxy=tmp1;
256 G4double tmp2=rzx; rzx=rxz; rxz=tmp2;
257 G4double tmp3=rzy; rzy=ryz; ryz=tmp3;
258
259 return *this;
260
261}
262
263inline
264G4AffineTransform& G4AffineTransform::operator +=(const G4ThreeVector& tlate)
265{
266 tx += tlate.x();
267 ty += tlate.y();
268 tz += tlate.z();
269
270 return *this;
271}
272
273inline
274G4AffineTransform& G4AffineTransform::operator -=(const G4ThreeVector& tlate)
275{
276 tx -= tlate.x();
277 ty -= tlate.y();
278 tz -= tlate.z();
279
280 return *this;
281}
282
283inline
284G4bool G4AffineTransform::operator == (const G4AffineTransform& tf) const
285{
286 return (tx==tf.tx&&ty==tf.ty&&tz==tf.tz&&
287 rxx==tf.rxx&&rxy==tf.rxy&&rxz==tf.rxz&&
288 ryx==tf.ryx&&ryy==tf.ryy&&ryz==tf.ryz&&
289 rzx==tf.rzx&&rzy==tf.rzy&&rzz==tf.rzz) ? true : false;
290}
291inline
292G4bool G4AffineTransform::operator != (const G4AffineTransform& tf) const
293{
294 return (tx!=tf.tx||ty!=tf.ty||tz!=tf.tz||
295 rxx!=tf.rxx||rxy!=tf.rxy||rxz!=tf.rxz||
296 ryx!=tf.ryx||ryy!=tf.ryy||ryz!=tf.ryz||
297 rzx!=tf.rzx||rzy!=tf.rzy||rzz!=tf.rzz) ? true : false;
298}
299
300inline
301G4double G4AffineTransform::operator [] (const G4int n) const
302{
303 G4double v = 0.0;
304 switch(n)
305 {
306 case 0:
307 v=rxx;
308 break;
309 case 1:
310 v=rxy;
311 break;
312 case 2:
313 v=rxz;
314 break;
315 case 4:
316 v=ryx;
317 break;
318 case 5:
319 v=ryy;
320 break;
321 case 6:
322 v=ryz;
323 break;
324 case 8:
325 v=rzx;
326 break;
327 case 9:
328 v=rzy;
329 break;
330 case 10:
331 v=rzz;
332 break;
333 case 12:
334 v=tx;
335 break;
336 case 13:
337 v=ty;
338 break;
339 case 14:
340 v=tz;
341 break;
342 case 3:
343 case 7:
344 case 11:
345 break;
346 case 15:
347 v=1.0;
348 break;
349 }
350 return v;
351}
352
353inline
354G4bool G4AffineTransform::IsRotated() const
355{
356 return (rxx==1.0 && ryy==1.0 && rzz==1.0) ? false : true;
357}
358
359inline
360G4bool G4AffineTransform::IsTranslated() const
361{
362 return (tx || ty || tz) ? true:false;
363}
364
365inline G4RotationMatrix G4AffineTransform::NetRotation() const {
366 G4RotationMatrix m;
367 return m.rotateAxes(G4ThreeVector(rxx,ryx,rzx),
368 G4ThreeVector(rxy,ryy,rzy),
369 G4ThreeVector(rxz,ryz,rzz));
370}
371
372inline
373G4ThreeVector G4AffineTransform::NetTranslation() const
374{
375 return G4ThreeVector(tx,ty,tz);
376}
377
378inline
379void G4AffineTransform::SetNetRotation(const G4RotationMatrix& rot)
380{
381 rxx=rot.xx();
382 rxy=rot.xy();
383 rxz=rot.xz();
384 ryx=rot.yx();
385 ryy=rot.yy();
386 ryz=rot.yz();
387 rzx=rot.zx();
388 rzy=rot.zy();
389 rzz=rot.zz();
390}
391
392inline
393void G4AffineTransform::SetNetTranslation(const G4ThreeVector& tlate)
394{
395 tx=tlate.x();
396 ty=tlate.y();
397 tz=tlate.z();
398}
Note: See TracBrowser for help on using the repository browser.