Logo ROOT   6.19/01
Reference Guide
AxisAngle.h
Go to the documentation of this file.
1 // @(#)root/mathcore:$Id$
2 // Authors: W. Brown, M. Fischler, L. Moneta 2005
3 
4 /**********************************************************************
5  * *
6  * Copyright (c) 2005 , LCG ROOT MathLib Team *
7  * *
8  * *
9  **********************************************************************/
10 
11 // Header file for class AxisAngle
12 //
13 // Created by: Lorenzo Moneta at Wed May 11 10:37:10 2005
14 //
15 // Last update: Wed May 11 10:37:10 2005
16 //
17 #ifndef ROOT_Math_GenVector_AxisAngle
18 #define ROOT_Math_GenVector_AxisAngle 1
19 
25 #include <algorithm>
26 #include <cassert>
27 
28 
29 namespace ROOT {
30 namespace Math {
31 
32 
33 //__________________________________________________________________________________________
34  /**
35  AxisAngle class describing rotation represented with direction axis (3D Vector) and an
36  angle of rotation around that axis.
37 
38  @ingroup GenVector
39 
40  */
41 class AxisAngle {
42 
43 public:
44 
45  typedef double Scalar;
46 
47  /**
48  definition of vector axis
49  */
51 
52 
53  /**
54  Default constructor (axis is z and angle is zero)
55  */
56  AxisAngle() : fAxis(0,0,1), fAngle(0) { }
57 
58  /**
59  Construct from a non-zero vector (x,y,z) and an angle.
60  Precondition: the Vector needs to implement x(), y(), z(), and unit()
61  */
62  template<class AnyVector>
63  AxisAngle(const AnyVector & v, Scalar angle) :
64  fAxis(v.unit()), fAngle(angle) { }
65 
66  /**
67  Construct given a pair of pointers or iterators defining the
68  beginning and end of an array of four Scalars, to be treated as
69  the x, y, and z components of a unit axis vector, and the angle
70  of rotation.
71  Precondition: The first three components are assumed to represent
72  the rotation axis vector and the 4-th the rotation angle.
73  The angle is assumed to be in the range (-pi,pi].
74  The axis vector is automatically normalized to be a unit vector
75  */
76  template<class IT>
77  AxisAngle(IT begin, IT end) { SetComponents(begin,end); }
78 
79  // The compiler-generated copy ctor, copy assignment, and dtor are OK.
80 
81  /**
82  Re-adjust components to eliminate small deviations from the axis
83  being a unit vector and angles out of the canonical range (-pi,pi]
84  */
85  void Rectify();
86 
87  // ======== Construction From other Rotation Forms ==================
88 
89  /**
90  Construct from another supported rotation type (see gv_detail::convert )
91  */
92  template <class OtherRotation>
93  explicit AxisAngle(const OtherRotation & r) {gv_detail::convert(r,*this);}
94 
95 
96  /**
97  Assign from another supported rotation type (see gv_detail::convert )
98  */
99  template <class OtherRotation>
100  AxisAngle & operator=( OtherRotation const & r ) {
101  gv_detail::convert(r,*this);
102  return *this;
103  }
104 
105  // ======== Components ==============
106 
107  /**
108  Set the axis and then the angle given a pair of pointers or iterators
109  defining the beginning and end of an array of four Scalars.
110  Precondition: The first three components are assumed to represent
111  the rotation axis vector and the 4-th the rotation angle.
112  The angle is assumed to be in the range (-pi,pi].
113  The axis vector is automatically normalized to be a unit vector
114  */
115  template<class IT>
116 #ifndef NDEBUG
117  void SetComponents(IT begin, IT end) {
118 #else
119  void SetComponents(IT begin, IT ) {
120 #endif
121  IT a = begin; IT b = ++begin; IT c = ++begin;
122  fAxis.SetCoordinates(*a,*b,*c);
123  fAngle = *(++begin);
124  assert (++begin==end);
125  // re-normalize the vector
126  double tot = fAxis.R();
127  if (tot > 0) fAxis /= tot;
128  }
129 
130  /**
131  Get the axis and then the angle into data specified by an iterator begin
132  and another to the end of the desired data (4 past start).
133  */
134  template<class IT>
135 #ifndef NDEBUG
136  void GetComponents(IT begin, IT end) const {
137 #else
138  void GetComponents(IT begin, IT ) const {
139 #endif
140  IT a = begin; IT b = ++begin; IT c = ++begin;
141  fAxis.GetCoordinates(*a,*b,*c);
142  *(++begin) = fAngle;
143  assert (++begin==end);
144  }
145 
146  /**
147  Get the axis and then the angle into data specified by an iterator begin
148  */
149  template<class IT>
150  void GetComponents(IT begin) const {
151  double ax,ay,az = 0;
152  fAxis.GetCoordinates(ax,ay,az);
153  *begin++ = ax;
154  *begin++ = ay;
155  *begin++ = az;
156  *begin = fAngle;
157  }
158 
159  /**
160  Set components from a non-zero vector (x,y,z) and an angle.
161  Precondition: the Vector needs to implement x(), y(), z(), and unit()
162  */
163  template<class AnyVector>
164  void SetComponents(const AnyVector & v, Scalar angle) {
165  fAxis=v.unit();
166  fAngle=angle;
167  }
168 
169  /**
170  Set components into a non-zero vector (x,y,z) and an angle.
171  The vector is intended to be a cartesian dispalcement vector
172  but any vector class assignable from one will work.
173  */
174  template<class AnyVector>
175  void GetComponents(AnyVector & axis, Scalar & angle) const {
176  axis = fAxis;
177  angle = fAngle;
178  }
179 
180  /**
181  accesss to rotation axis
182  */
183  AxisVector Axis() const { return fAxis; }
184 
185  /**
186  access to rotation angle
187  */
188  Scalar Angle() const { return fAngle; }
189 
190  // =========== operations ==============
191 
192  /**
193  Rotation operation on a cartesian vector
194  */
196  XYZVector operator() (const XYZVector & v) const;
197 
198  /**
199  Rotation operation on a displacement vector in any coordinate system
200  */
201  template <class CoordSystem, class Tag>
204  DisplacementVector3D< Cartesian3D<double> > xyz(v.X(), v.Y(), v.Z());
207  vNew.SetXYZ( rxyz.X(), rxyz.Y(), rxyz.Z() );
208  return vNew;
209  }
210 
211  /**
212  Rotation operation on a position vector in any coordinate system
213  */
214  template <class CoordSystem, class Tag>
219  return PositionVector3D<CoordSystem,Tag> ( rxyz );
220  }
221 
222  /**
223  Rotation operation on a Lorentz vector in any 4D coordinate system
224  */
225  template <class CoordSystem>
229  xyz = operator()(xyz);
230  LorentzVector< PxPyPzE4D<double> > xyzt (xyz.X(), xyz.Y(), xyz.Z(), v.E());
231  return LorentzVector<CoordSystem> ( xyzt );
232  }
233 
234 
235  /**
236  Rotation operation on an arbitrary vector v.
237  Preconditions: v must implement methods x(), y(), and z()
238  and the arbitrary vector type must have a constructor taking (x,y,z)
239  */
240  template <class ForeignVector>
241  ForeignVector
242  operator() (const ForeignVector & v) const {
245  return ForeignVector ( rxyz.X(), rxyz.Y(), rxyz.Z() );
246  }
247 
248  /**
249  Overload operator * for rotation on a vector
250  */
251  template <class AVector>
252  inline
253  AVector operator* (const AVector & v) const
254  {
255  return operator()(v);
256  }
257 
258  /**
259  Invert an AxisAngle rotation in place
260  */
261  void Invert() { fAngle = -fAngle; }
262 
263  /**
264  Return inverse of an AxisAngle rotation
265  */
266  AxisAngle Inverse() const { AxisAngle result(*this); result.Invert(); return result; }
267 
268  // ========= Multi-Rotation Operations ===============
269 
270  /**
271  Multiply (combine) two rotations
272  */
273  AxisAngle operator * (const Rotation3D & r) const;
274  AxisAngle operator * (const AxisAngle & a) const;
275  AxisAngle operator * (const EulerAngles & e) const;
276  AxisAngle operator * (const Quaternion & q) const;
277  AxisAngle operator * (const RotationZYX & r) const;
278  AxisAngle operator * (const RotationX & rx) const;
279  AxisAngle operator * (const RotationY & ry) const;
280  AxisAngle operator * (const RotationZ & rz) const;
281 
282  /**
283  Post-Multiply (on right) by another rotation : T = T*R
284  */
285  template <class R>
286  AxisAngle & operator *= (const R & r) { return *this = (*this)*r; }
287 
288 
289  /**
290  Distance between two rotations
291  */
292  template <class R>
293  Scalar Distance ( const R & r ) const {return gv_detail::dist(*this,r);}
294 
295  /**
296  Equality/inequality operators
297  */
298  bool operator == (const AxisAngle & rhs) const {
299  if( fAxis != rhs.fAxis ) return false;
300  if( fAngle != rhs.fAngle ) return false;
301  return true;
302  }
303  bool operator != (const AxisAngle & rhs) const {
304  return ! operator==(rhs);
305  }
306 
307 private:
308 
309  AxisVector fAxis; // rotation axis (3D vector)
310  Scalar fAngle; // rotation angle
311 
312  void RectifyAngle();
313 
314  static double Pi() { return 3.14159265358979323; }
315 
316 }; // AxisAngle
317 
318 // ============ Class AxisAngle ends here ============
319 
320 /**
321  Distance between two rotations
322  */
323 template <class R>
324 inline
325 typename AxisAngle::Scalar
326 Distance ( const AxisAngle& r1, const R & r2) {return gv_detail::dist(r1,r2);}
327 
328 /**
329  Multiplication of an axial rotation by an AxisAngle
330  */
331 AxisAngle operator* (RotationX const & r1, AxisAngle const & r2);
332 AxisAngle operator* (RotationY const & r1, AxisAngle const & r2);
333 AxisAngle operator* (RotationZ const & r1, AxisAngle const & r2);
334 
335 /**
336  Stream Output and Input
337  */
338  // TODO - I/O should be put in the manipulator form
339 
340 std::ostream & operator<< (std::ostream & os, const AxisAngle & a);
341 
342 } // namespace Math
343 } // namespace ROOT
344 
345 
346 #endif /* ROOT_Math_GenVector_AxisAngle */
Class describing a generic LorentzVector in the 4D space-time, using the specified coordinate syste...
Definition: LorentzVector.h:59
double dist(Rotation3D const &r1, Rotation3D const &r2)
Definition: 3DDistances.cxx:48
DisplacementVector3D< CoordSystem, Tag > & SetCoordinates(const Scalar src[])
Set internal data based on a C-style array of 3 Scalar numbers.
Scalar R() const
Polar R, converting if necessary from internal coordinate system.
DisplacementVector3D< Cartesian3D< Scalar > > AxisVector
definition of vector axis
Definition: AxisAngle.h:50
DisplacementVector3D< CoordSystem, Tag > & SetXYZ(Scalar a, Scalar b, Scalar c)
set the values of the vector from the cartesian components (x,y,z) (if the vector is held in polar or...
VSD Structures.
Definition: StringConv.hxx:21
AVector operator*(const AVector &v) const
Overload operator * for rotation on a vector.
Definition: AxisAngle.h:253
AxisAngle()
Default constructor (axis is z and angle is zero)
Definition: AxisAngle.h:56
Rotation class representing a 3D rotation about the Z axis by the angle of rotation.
Definition: RotationZ.h:43
void SetComponents(const AnyVector &v, Scalar angle)
Set components from a non-zero vector (x,y,z) and an angle.
Definition: AxisAngle.h:164
bool operator!=(const AxisAngle &rhs) const
Definition: AxisAngle.h:303
Class describing a generic position vector (point) in 3 dimensions.
Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle p...
Definition: RotationZYX.h:61
AxisAngle(const OtherRotation &r)
Construct from another supported rotation type (see gv_detail::convert )
Definition: AxisAngle.h:93
Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k).
Definition: Quaternion.h:47
#define R(a, b, c, d, e, f, g, h, i)
Definition: RSha256.hxx:110
void GetComponents(IT begin, IT end) const
Get the axis and then the angle into data specified by an iterator begin and another to the end of th...
Definition: AxisAngle.h:136
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:91
AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotat...
Definition: AxisAngle.h:41
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
Rotation class representing a 3D rotation about the Y axis by the angle of rotation.
Definition: RotationY.h:43
AxisAngle(const AnyVector &v, Scalar angle)
Construct from a non-zero vector (x,y,z) and an angle.
Definition: AxisAngle.h:63
void SetComponents(IT begin, IT end)
Set the axis and then the angle given a pair of pointers or iterators defining the beginning and end ...
Definition: AxisAngle.h:117
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag > XYZVector
Rotation operation on a cartesian vector.
Definition: AxisAngle.h:195
AxisAngle & operator*=(const R &r)
Post-Multiply (on right) by another rotation : T = T*R.
Definition: AxisAngle.h:286
AxisVector Axis() const
accesss to rotation axis
Definition: AxisAngle.h:183
void Rectify()
Re-adjust components to eliminate small deviations from the axis being a unit vector and angles out o...
Definition: AxisAngle.cxx:47
Class describing a generic displacement vector in 3 dimensions.
ROOT::R::TRInterface & r
Definition: Object.C:4
Scalar Angle() const
access to rotation angle
Definition: AxisAngle.h:188
auto * a
Definition: textangle.C:12
Rotation class representing a 3D rotation about the X axis by the angle of rotation.
Definition: RotationX.h:43
void Invert()
Invert an AxisAngle rotation in place.
Definition: AxisAngle.h:261
Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix.
Definition: Rotation3D.h:65
void convert(R1 const &, R2 const)
Definition: 3DConversions.h:41
void GetCoordinates(Scalar &a, Scalar &b, Scalar &c) const
get internal data into 3 Scalar numbers
void GetComponents(IT begin) const
Get the axis and then the angle into data specified by an iterator begin.
Definition: AxisAngle.h:150
bool operator==(const AxisAngle &rhs) const
Equality/inequality operators.
Definition: AxisAngle.h:298
EulerAngles class describing rotation as three angles (Euler Angles).
Definition: EulerAngles.h:43
XYZVector operator()(const XYZVector &v) const
AxisAngle(IT begin, IT end)
Construct given a pair of pointers or iterators defining the beginning and end of an array of four Sc...
Definition: AxisAngle.h:77
you should not use this method at all Int_t Int_t Double_t Double_t Double_t e
Definition: TRolke.cxx:630
void GetComponents(AnyVector &axis, Scalar &angle) const
Set components into a non-zero vector (x,y,z) and an angle.
Definition: AxisAngle.h:175
Namespace for new Math classes and functions.
AxisAngle Inverse() const
Return inverse of an AxisAngle rotation.
Definition: AxisAngle.h:266
Scalar Distance(const R &r) const
Distance between two rotations.
Definition: AxisAngle.h:293
AxisAngle & operator=(OtherRotation const &r)
Assign from another supported rotation type (see gv_detail::convert )
Definition: AxisAngle.h:100
you should not use this method at all Int_t Int_t Double_t Double_t Double_t Int_t Double_t Double_t Double_t Double_t b
Definition: TRolke.cxx:630
#define c(i)
Definition: RSha256.hxx:101
DefaultCoordinateSystemTag Default tag for identifying any coordinate system.
float * q
Definition: THbookFile.cxx:87
static double Pi()
Definition: AxisAngle.h:314