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

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

file release beta
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-02-ref-02 $
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.