ROOT  6.06/09
Reference Guide
Plane3D.h
Go to the documentation of this file.
1 // @(#)root/mathcore:$Id$
2 // Authors: L. Moneta 12/2005
3 
4 /**********************************************************************
5  * *
6  * Copyright (c) 2005 , LCG ROOT MathLib Team *
7  * *
8  * *
9  **********************************************************************/
10 
11 // Header file for class LorentzVector
12 //
13 // Created by: moneta at Fri Dec 02 2005
14 //
15 // Last update: $Id$
16 //
17 #ifndef ROOT_Math_GenVector_Plane3D
18 #define ROOT_Math_GenVector_Plane3D 1
19 
22 
23 
24 
25 namespace ROOT {
26 
27 namespace Math {
28 
29 
30 
31 //_______________________________________________________________________________
32  /**
33  Class describing a geometrical plane in 3 dimensions.
34  A Plane3D is a 2 dimensional surface spanned by two linearly independent vectors.
35  The plane is described by the equation
36  \f$ a*x + b*y + c*z + d = 0 \f$ where (a,b,c) are the components of the
37  normal vector to the plane \f$ n = (a,b,c) \f$ and \f$ d = - n \dot x \f$, where x is any point
38  belonging to plane.
39  More information on the mathematics describing a plane in 3D is available on
40  <A HREF=http://mathworld.wolfram.com/Plane.html>MathWord</A>.
41  The Plane3D class contains the 4 scalar values in double which represent the
42  four coefficients, fA, fB, fC, fD. fA, fB, fC are the normal components normalized to 1,
43  i.e. fA**2 + fB**2 + fC**2 = 1
44 
45  @ingroup GenVector
46  */
47  class Plane3D {
48 
49  public:
50 
51  // ------ ctors ------
52 
53  typedef double Scalar;
54 
57 
58 
59 
60  /**
61  default constructor create plane z = 0
62  */
63  Plane3D ( ) : fA(0), fB(0), fC(1.), fD(0) { }
64 
65  /**
66  generic constructors from the four scalar values describing the plane
67  according to the equation ax + by + cz + d = 0
68  \param a scalar value
69  \param b scalar value
70  \param c scalar value
71  \param d sxcalar value
72  */
73  Plane3D(const Scalar & a, const Scalar & b, const Scalar & c, const Scalar & d);
74 
75  /**
76  constructor a Plane3D from a normal vector and a point coplanar to the plane
77  \param n normal expressed as a ROOT::Math::DisplacementVector3D<Cartesian3D<double> >
78  \param p point expressed as a ROOT::Math::PositionVector3D<Cartesian3D<double> >
79  */
80  Plane3D(const Vector & n, const Point & p )
81  {
82  BuildFromVecAndPoint( n, p );
83  }
84 
85 
86  /**
87  Construct from a generic DisplacementVector3D (normal vector) and PositionVector3D (point coplanar to
88  the plane)
89  \param n normal expressed as a generic ROOT::Math::DisplacementVector3D
90  \param p point expressed as a generic ROOT::Math::PositionVector3D
91  */
92  template<class T1, class T2, class U>
94  {
96  }
97 
98  /**
99  constructor from three Cartesian point belonging to the plane
100  \param p1 point1 expressed as a generic ROOT::Math::PositionVector3D
101  \param p2 point2 expressed as a generic ROOT::Math::PositionVector3D
102  \param p3 point3 expressed as a generic ROOT::Math::PositionVector3D
103  */
104  Plane3D(const Point & p1, const Point & p2, const Point & p3 ) {
105  BuildFrom3Points(p1,p2,p3);
106  }
107 
108  /**
109  constructor from three generic point belonging to the plane
110  \param p1 point1 expressed as ROOT::Math::DisplacementVector3D<Cartesian3D<double> >
111  \param p2 point2 expressed as ROOT::Math::DisplacementVector3D<Cartesian3D<double> >
112  \param p3 point3 expressed as ROOT::Math::DisplacementVector3D<Cartesian3D<double> >
113  */
114  template <class T1, class T2, class T3, class U>
116  {
117  BuildFrom3Points( Point(p1.X(), p1.Y(), p1.Z()),
118  Point(p2.X(), p2.Y(), p2.Z()),
119  Point(p3.X(), p3.Y(), p3.Z()) );
120  }
121 
122 
123 
124  // compiler-generated copy ctor and dtor are fine.
125 
126  // ------ assignment ------
127 
128  /**
129  Assignment operator from other Plane3D class
130  */
131  Plane3D & operator= ( const Plane3D & plane) {
132  fA = plane.fA;
133  fB = plane.fB;
134  fC = plane.fC;
135  fD = plane.fD;
136  return *this;
137  }
138 
139  /**
140  Return the a coefficient of the plane equation \f$ a*x + b*y + c*z + d = 0 \f$. It is also the
141  x-component of the vector perpendicular to the plane.
142  */
143  Scalar A() const { return fA; }
144 
145  /**
146  Return the b coefficient of the plane equation \f$ a*x + b*y + c*z + d = 0 \f$. It is also the
147  y-component of the vector perpendicular to the plane
148  */
149  Scalar B() const { return fB; }
150 
151  /**
152  Return the c coefficient of the plane equation \f$ a*x + b*y + c*z + d = 0 \f$. It is also the
153  z-component of the vector perpendicular to the plane
154  */
155  Scalar C() const { return fC; }
156 
157  /**
158  Return the d coefficient of the plane equation \f$ a*x + b*y + c*z + d = 0 \f$. It is also
159  the distance from the origin (HesseDistance)
160  */
161  Scalar D() const { return fD; }
162 
163  /**
164  Return normal vector to the plane as Cartesian DisplacementVector
165  */
166  Vector Normal() const {
167  return Vector(fA, fB, fC);
168  }
169 
170  /**
171  Return the Hesse Distance (distance from the origin) of the plane or
172  the d coefficient expressed in normalize form
173  */
174  Scalar HesseDistance() const {
175  return fD;
176  }
177 
178 
179  /**
180  Return the signed distance to a Point.
181  The distance is signed positive if the Point is in the same side of the
182  normal vector to the plane.
183  \param p Point expressed in Cartesian Coordinates
184  */
185  Scalar Distance(const Point & p) const;
186 
187  /**
188  Return the distance to a Point described with generic coordinates
189  \param p Point expressed as generic ROOT::Math::PositionVector3D
190  */
191  template <class T, class U>
192  Scalar Distance(const PositionVector3D<T,U> & p) const {
193  return Distance( Point(p.X(), p.Y(), p.Z() ) );
194  }
195 
196  /**
197  Return the projection of a Cartesian point to a plane
198  \param p Point expressed as PositionVector3D<Cartesian3D<double> >
199  */
200  Point ProjectOntoPlane(const Point & p) const;
201 
202  /**
203  Return the projection of a point to a plane
204  \param p Point expressed as generic ROOT::Math::PositionVector3D
205  */
206  template <class T, class U>
208  Point pxyz = ProjectOntoPlane(Point(p.X(), p.Y(), p.Z() ) );
210  p2.SetXYZ( pxyz.X(), pxyz.Y(), pxyz.Z() );
211  return p2;
212  }
213 
214 
215 
216  // ------------------- Equality -----------------
217 
218  /**
219  Exact equality
220  */
221  bool operator==(const Plane3D & rhs) const {
222  return fA == rhs.fA && fB == rhs.fB && fC == rhs.fC && fD == rhs.fD;
223  }
224  bool operator!= (const Plane3D & rhs) const {
225  return !(operator==(rhs));
226  }
227 
228  protected:
229 
230  /**
231  Normalize the normal (a,b,c) plane components
232  */
233  void Normalize();
234 
235 
236  private:
237 
238  // internal method to construct class from a vector and a point
239  void BuildFromVecAndPoint(const Vector & n, const Point & p);
240  // internal method to construct class from 3 points
241  void BuildFrom3Points(const Point & p1, const Point & p2, const Point & p3);
242 
243  // plane data members the four scalar which satisfies fA*x + fB*y + fC*z + fD = 0
244  // for every point (x,y,z) belonging to the plane.
245  // fA**2 + fB**2 + fC** =1 plane is stored in normalized form
246  Scalar fA;
247  Scalar fB;
248  Scalar fC;
249  Scalar fD;
250 
251 
252  }; // Plane3D<>
253 
254  /**
255  Stream Output and Input
256  */
257  // TODO - I/O should be put in the manipulator form
258 
259  std::ostream & operator<< (std::ostream & os, const Plane3D & p);
260 
261 
262 } // end namespace Math
263 
264 } // end namespace ROOT
265 
266 
267 #endif
268 
269 
270 
271 
Scalar Distance(const PositionVector3D< T, U > &p) const
Return the distance to a Point described with generic coordinates.
Definition: Plane3D.h:192
Class describing a geometrical plane in 3 dimensions.
Definition: Plane3D.h:47
Scalar D() const
Return the d coefficient of the plane equation .
Definition: Plane3D.h:161
static double p3(double t, double a, double b, double c, double d)
Namespace for new ROOT classes and functions.
Definition: ROOT.py:1
Plane3D()
default constructor create plane z = 0
Definition: Plane3D.h:63
Class describing a generic position vector (point) in 3 dimensions.
TArc * a
Definition: textangle.C:12
Scalar B() const
Return the b coefficient of the plane equation .
Definition: Plane3D.h:149
Scalar Z() const
Cartesian Z, converting if necessary from internal coordinate system.
Scalar Y() const
Cartesian Y, converting if necessary from internal coordinate system.
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition: AxisAngle.cxx:91
Plane3D & operator=(const Plane3D &plane)
Assignment operator from other Plane3D class.
Definition: Plane3D.h:131
Vector Normal() const
Return normal vector to the plane as Cartesian DisplacementVector.
Definition: Plane3D.h:166
static double p2(double t, double a, double b, double c)
Scalar A() const
Return the a coefficient of the plane equation .
Definition: Plane3D.h:143
Plane3D(const DisplacementVector3D< T1, U > &n, const PositionVector3D< T2, U > &p)
Construct from a generic DisplacementVector3D (normal vector) and PositionVector3D (point coplanar to...
Definition: Plane3D.h:93
bool operator==(const Plane3D &rhs) const
Exact equality.
Definition: Plane3D.h:221
bool operator!=(const Plane3D &rhs) const
Definition: Plane3D.h:224
Plane3D(const Vector &n, const Point &p)
constructor a Plane3D from a normal vector and a point coplanar to the plane
Definition: Plane3D.h:80
Point ProjectOntoPlane(const Point &p) const
Return the projection of a Cartesian point to a plane.
Definition: Plane3D.cxx:87
Class describing a generic displacement vector in 3 dimensions.
Scalar HesseDistance() const
Return the Hesse Distance (distance from the origin) of the plane or the d coefficient expressed in n...
Definition: Plane3D.h:174
PositionVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag > Point
Definition: Plane3D.h:56
static double p1(double t, double a, double b)
DisplacementVector3D< Cartesian3D< double >, DefaultCoordinateSystemTag > Vector
Definition: Plane3D.h:55
PositionVector3D< T, U > ProjectOntoPlane(const PositionVector3D< T, U > &p) const
Return the projection of a point to a plane.
Definition: Plane3D.h:207
void BuildFromVecAndPoint(const Vector &n, const Point &p)
Definition: Plane3D.cxx:45
void Normalize()
Normalize the normal (a,b,c) plane components.
Definition: Plane3D.cxx:73
Plane3D(const PositionVector3D< T1, U > &p1, const PositionVector3D< T2, U > &p2, const PositionVector3D< T3, U > &p3)
constructor from three generic point belonging to the plane
Definition: Plane3D.h:115
Namespace for new Math classes and functions.
void BuildFrom3Points(const Point &p1, const Point &p2, const Point &p3)
Definition: Plane3D.cxx:56
PositionVector3D< 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...
Scalar X() const
Cartesian X, converting if necessary from internal coordinate system.
Plane3D(const Point &p1, const Point &p2, const Point &p3)
constructor from three Cartesian point belonging to the plane
Definition: Plane3D.h:104
Scalar Distance(const Point &p) const
Return the signed distance to a Point.
Definition: Plane3D.cxx:69
Scalar C() const
Return the c coefficient of the plane equation .
Definition: Plane3D.h:155
DefaultCoordinateSystemTag Default tag for identifying any coordinate system.
const Int_t n
Definition: legend1.C:16