Logo ROOT  
Reference Guide
 
Loading...
Searching...
No Matches
Rotation3D.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 FNAL MathLib Team *
7 * *
8 * *
9 **********************************************************************/
10
11// Header file for class Rotation in 3 dimensions, represented by 3x3 matrix
12//
13// Created by: Mark Fischler Thurs June 9 2005
14//
15// Last update: $Id$
16//
17#ifndef ROOT_Math_GenVector_Rotation3D
18#define ROOT_Math_GenVector_Rotation3D 1
19
20
28
36
38
39#include <algorithm>
40#include <cassert>
41#include <iostream>
42
43
44namespace ROOT {
45namespace Math {
46
47
48//__________________________________________________________________________________________
49 /**
50 Rotation class with the (3D) rotation represented by
51 a 3x3 orthogonal matrix.
52 This is the optimal representation for application to vectors.
53 See also ROOT::Math::AxisAngle, ROOT::Math::EulerAngles, and ROOT::Math::Quaternion for
54 classes which have conversion operators to Rotation3D.
55
56 All Rotations types (not only Rotation3D) can be applied to all 3D Vector classes
57 (like ROOT::Math::DisplacementVector3D and ROOT::Math::PositionVector3D)
58 and also to the 4D Vectors (ROOT::Math::LorentzVector classes), acting on the 3D components.
59 A rotation operation is applied by using the operator() or the operator *.
60 With the operator * is possible also to combine rotations.
61 Note that the operator is NOT commutative, the order how the rotations are applied is relevant.
62
63 @ingroup GenVector
64
65 @sa Overview of the @ref GenVector "physics vector library"
66 */
67
69
70public:
71
72 typedef double Scalar;
73
75 kXX = 0, kXY = 1, kXZ = 2
76 , kYX = 3, kYY = 4, kYZ = 5
77 , kZX = 6, kZY = 7, kZZ = 8
78 };
79
80 // ========== Constructors and Assignment =====================
81
82 /**
83 Default constructor (identity rotation)
84 */
85 Rotation3D();
86
87 /**
88 Construct given a pair of pointers or iterators defining the
89 beginning and end of an array of nine Scalars
90 */
91 template<class IT>
92 Rotation3D(IT begin, IT end) { SetComponents(begin,end); }
93
94 /**
95 copy constructor
96 */
97 Rotation3D ( Rotation3D const & r ) {
98 *this = r;
99 }
100
101 /**
102 Construct from an AxisAngle
103 */
104 explicit Rotation3D( AxisAngle const & a ) { gv_detail::convert(a, *this); }
105
106 /**
107 Construct from EulerAngles
108 */
109 explicit Rotation3D( EulerAngles const & e ) { gv_detail::convert(e, *this); }
110
111 /**
112 Construct from RotationZYX
113 */
114 explicit Rotation3D( RotationZYX const & e ) { gv_detail::convert(e, *this); }
115
116 /**
117 Construct from a Quaternion
118 */
119 explicit Rotation3D( Quaternion const & q ) { gv_detail::convert(q, *this); }
120
121 /**
122 Construct from an axial rotation
123 */
124 explicit Rotation3D( RotationZ const & r ) { gv_detail::convert(r, *this); }
125 explicit Rotation3D( RotationY const & r ) { gv_detail::convert(r, *this); }
126 explicit Rotation3D( RotationX const & r ) { gv_detail::convert(r, *this); }
127
128 /**
129 Construct from a linear algebra matrix of size at least 3x3,
130 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
131 Precondition: The matrix is assumed to be orthonormal. No checking
132 or re-adjusting is performed.
133 */
134 template<class ForeignMatrix>
135 explicit constexpr Rotation3D(const ForeignMatrix & m) { SetComponents(m); }
136
137 /**
138 Construct from three orthonormal vectors (which must have methods
139 x(), y() and z()) which will be used as the columns of the rotation
140 matrix. The orthonormality will be checked, and values adjusted
141 so that the result will always be a good rotation matrix.
142 */
143 template<class ForeignVector>
145 const ForeignVector& v2,
146 const ForeignVector& v3 ) { SetComponents(v1, v2, v3); }
147
148 // compiler generated destruuctor is ok
149
150 /**
151 Raw constructor from nine Scalar components (without any checking)
152 */
154 Scalar yx, Scalar yy, Scalar yz,
156 {
157 SetComponents (xx, xy, xz, yx, yy, yz, zx, zy, zz);
158 }
159
160 // need to implement assignment operator to avoid using the templated one
161
162 /**
163 Assignment operator
164 */
165 Rotation3D &
167 SetComponents( rhs.fM[0], rhs.fM[1], rhs.fM[2],
168 rhs.fM[3], rhs.fM[4], rhs.fM[5],
169 rhs.fM[6], rhs.fM[7], rhs.fM[8] );
170 return *this;
171 }
172
173 /**
174 Assign from an AxisAngle
175 */
176 Rotation3D &
177 operator=( AxisAngle const & a ) { return operator=(Rotation3D(a)); }
178
179 /**
180 Assign from EulerAngles
181 */
182 Rotation3D &
183 operator=( EulerAngles const & e ) { return operator=(Rotation3D(e)); }
184
185 /**
186 Assign from RotationZYX
187 */
188 Rotation3D &
189 operator=( RotationZYX const & r ) { return operator=(Rotation3D(r)); }
190
191 /**
192 Assign from a Quaternion
193 */
194 Rotation3D &
195 operator=( Quaternion const & q ) {return operator=(Rotation3D(q)); }
196
197 /**
198 Assign from an axial rotation
199 */
200 Rotation3D &
201 operator=( RotationZ const & r ) { return operator=(Rotation3D(r)); }
202 Rotation3D &
203 operator=( RotationY const & r ) { return operator=(Rotation3D(r)); }
204 Rotation3D &
205 operator=( RotationX const & r ) { return operator=(Rotation3D(r)); }
206
207 /**
208 Assign from an orthonormal linear algebra matrix of size 3x3,
209 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
210 */
211 template<class ForeignMatrix>
212 Rotation3D &
214 SetComponents( m(0,0), m(0,1), m(0,2),
215 m(1,0), m(1,1), m(1,2),
216 m(2,0), m(2,1), m(2,2) );
217 return *this;
218 }
219
220 /**
221 Re-adjust components to eliminate small deviations from perfect
222 orthonormality.
223 */
224 void Rectify();
225
226 // ======== Components ==============
227
228 /**
229 Set components from three orthonormal vectors (which must have methods
230 x(), y() and z()) which will be used as the columns of the rotation
231 matrix. The orthonormality will be checked, and values adjusted
232 so that the result will always be a good rotation matrix.
233 */
234 template<class ForeignVector>
235 void
237 const ForeignVector& v2,
238 const ForeignVector& v3 ) {
239 fM[kXX]=v1.x(); fM[kXY]=v2.x(); fM[kXZ]=v3.x();
240 fM[kYX]=v1.y(); fM[kYY]=v2.y(); fM[kYZ]=v3.y();
241 fM[kZX]=v1.z(); fM[kZY]=v2.z(); fM[kZZ]=v3.z();
242 Rectify();
243 }
244
245 /**
246 Get components into three vectors which will be the (orthonormal)
247 columns of the rotation matrix. (The vector class must have a
248 constructor from 3 Scalars.)
249 */
250 template<class ForeignVector>
251 void
254 ForeignVector& v3 ) const {
255 v1 = ForeignVector ( fM[kXX], fM[kYX], fM[kZX] );
256 v2 = ForeignVector ( fM[kXY], fM[kYY], fM[kZY] );
257 v3 = ForeignVector ( fM[kXZ], fM[kYZ], fM[kZZ] );
258 }
259
260 /**
261 Set the 9 matrix components given an iterator to the start of
262 the desired data, and another to the end (9 past start).
263 */
264 template<class IT>
265 void SetComponents(IT begin, IT end) {
266 for (int i = 0; i <9; ++i) {
267 fM[i] = *begin;
268 ++begin;
269 }
270 (void)end;
271 assert (end==begin);
272 }
273
274 /**
275 Get the 9 matrix components into data specified by an iterator begin
276 and another to the end of the desired data (9 past start).
277 */
278 template<class IT>
279 void GetComponents(IT begin, IT end) const {
280 for (int i = 0; i <9; ++i) {
281 *begin = fM[i];
282 ++begin;
283 }
284 (void)end;
285 assert (end==begin);
286 }
287
288 /**
289 Get the 9 matrix components into data specified by an iterator begin
290 */
291 template<class IT>
292 void GetComponents(IT begin) const {
293 std::copy ( fM, fM+9, begin );
294 }
295
296 /**
297 Set components from a linear algebra matrix of size at least 3x3,
298 which must support operator()(i,j) to obtain elements (0,0) thru (2,2).
299 Precondition: The matrix is assumed to be orthonormal. NO checking
300 or re-adjusting is performed.
301 */
302 template<class ForeignMatrix>
303 void
305 fM[kXX]=m(0,0); fM[kXY]=m(0,1); fM[kXZ]=m(0,2);
306 fM[kYX]=m(1,0); fM[kYY]=m(1,1); fM[kYZ]=m(1,2);
307 fM[kZX]=m(2,0); fM[kZY]=m(2,1); fM[kZZ]=m(2,2);
308 }
309
310 /**
311 Get components into a linear algebra matrix of size at least 3x3,
312 which must support operator()(i,j) for write access to elements
313 (0,0) thru (2,2).
314 */
315 template<class ForeignMatrix>
316 void
318 m(0,0)=fM[kXX]; m(0,1)=fM[kXY]; m(0,2)=fM[kXZ];
319 m(1,0)=fM[kYX]; m(1,1)=fM[kYY]; m(1,2)=fM[kYZ];
320 m(2,0)=fM[kZX]; m(2,1)=fM[kZY]; m(2,2)=fM[kZZ];
321 }
322
323 /**
324 Set the components from nine scalars -- UNCHECKED for orthonormaility
325 */
326 void
328 Scalar yx, Scalar yy, Scalar yz,
330 fM[kXX]=xx; fM[kXY]=xy; fM[kXZ]=xz;
331 fM[kYX]=yx; fM[kYY]=yy; fM[kYZ]=yz;
332 fM[kZX]=zx; fM[kZY]=zy; fM[kZZ]=zz;
333 }
334
335 /**
336 Get the nine components into nine scalars
337 */
338 void
340 Scalar &yx, Scalar &yy, Scalar &yz,
341 Scalar &zx, Scalar &zy, Scalar &zz) const {
342 xx=fM[kXX]; xy=fM[kXY]; xz=fM[kXZ];
343 yx=fM[kYX]; yy=fM[kYY]; yz=fM[kYZ];
344 zx=fM[kZX]; zy=fM[kZY]; zz=fM[kZZ];
345 }
346
347 // =========== operations ==============
348
349 /**
350 Access operator, used to have direct access to rotation matrix's entries
351 \param i row index in {0,1,2}
352 \param j column index in {0,1,2}
353 */
354 Scalar operator()(size_t i, size_t j) const
355 {
356 if (i < 3 && j < 3)
357 return fM[i + 3 * j];
358 else
359 GenVector::Throw("Rotation3D::operator(size_t i, size_t j):\n"
360 " indices i and j must range in {0,1,2}");
361 return 0.0;
362 }
363
364 /**
365 Rotation operation on a displacement vector in any coordinate system
366 */
367 template <class CoordSystem, class U>
371 xyz.SetXYZ( fM[kXX] * v.X() + fM[kXY] * v.Y() + fM[kXZ] * v.Z() ,
372 fM[kYX] * v.X() + fM[kYY] * v.Y() + fM[kYZ] * v.Z() ,
373 fM[kZX] * v.X() + fM[kZY] * v.Y() + fM[kZZ] * v.Z() );
375 }
376
377 /**
378 Rotation operation on a position vector in any coordinate system
379 */
380 template <class CoordSystem, class U>
387
388 /**
389 Rotation operation on a Lorentz vector in any spatial coordinate system
390 */
391 template <class CoordSystem>
395 xyz = operator()(xyz);
396 LorentzVector< PxPyPzE4D<double> > xyzt (xyz.X(), xyz.Y(), xyz.Z(), v.E());
398 }
399
400 /**
401 Rotation operation on an arbitrary vector v.
402 Preconditions: v must implement methods x(), y(), and z()
403 and the arbitrary vector type must have a constructor taking (x,y,z)
404 */
405 template <class ForeignVector>
412
413 /**
414 Overload operator * for rotation on a vector
415 */
416 template <class AVector>
417 inline
419 {
420 return operator()(v);
421 }
422
423 /**
424 Invert a rotation in place
425 */
426 void Invert();
427
428 /**
429 Return inverse of a rotation
430 */
431 Rotation3D Inverse() const { Rotation3D t(*this); t.Invert(); return t; }
432
433 // ========= Multi-Rotation Operations ===============
434
435 /**
436 Multiply (combine) two rotations
437 */
439 return Rotation3D
440 ( fM[kXX]*r.fM[kXX] + fM[kXY]*r.fM[kYX] + fM[kXZ]*r.fM[kZX]
441 , fM[kXX]*r.fM[kXY] + fM[kXY]*r.fM[kYY] + fM[kXZ]*r.fM[kZY]
442 , fM[kXX]*r.fM[kXZ] + fM[kXY]*r.fM[kYZ] + fM[kXZ]*r.fM[kZZ]
443
444 , fM[kYX]*r.fM[kXX] + fM[kYY]*r.fM[kYX] + fM[kYZ]*r.fM[kZX]
445 , fM[kYX]*r.fM[kXY] + fM[kYY]*r.fM[kYY] + fM[kYZ]*r.fM[kZY]
446 , fM[kYX]*r.fM[kXZ] + fM[kYY]*r.fM[kYZ] + fM[kYZ]*r.fM[kZZ]
447
448 , fM[kZX]*r.fM[kXX] + fM[kZY]*r.fM[kYX] + fM[kZZ]*r.fM[kZX]
449 , fM[kZX]*r.fM[kXY] + fM[kZY]*r.fM[kYY] + fM[kZZ]*r.fM[kZY]
450 , fM[kZX]*r.fM[kXZ] + fM[kZY]*r.fM[kYZ] + fM[kZZ]*r.fM[kZZ] );
451
452 }
453
454
455 /**
456 Multiplication with arbitrary rotations
457 */
458 // note: cannot have a template method since it is ambiguous with the operator * on vectors
459
460 Rotation3D operator * (const AxisAngle & a) const;
461 Rotation3D operator * (const EulerAngles & e) const;
462 Rotation3D operator * (const Quaternion & q) const;
463 Rotation3D operator * (const RotationZYX & r) const;
464 Rotation3D operator * (const RotationX & rx) const;
465 Rotation3D operator * (const RotationY & ry) const;
466 Rotation3D operator * (const RotationZ & rz) const;
467
468 /**
469 Post-Multiply (on right) by another rotation : T = T*R
470 */
471 template <class R>
472 Rotation3D & operator *= (const R & r) { return *this = (*this)*r; }
473
474 /**
475 Equality/inequality operators
476 */
477 bool operator == (const Rotation3D & rhs) const {
478 if( fM[0] != rhs.fM[0] ) return false;
479 if( fM[1] != rhs.fM[1] ) return false;
480 if( fM[2] != rhs.fM[2] ) return false;
481 if( fM[3] != rhs.fM[3] ) return false;
482 if( fM[4] != rhs.fM[4] ) return false;
483 if( fM[5] != rhs.fM[5] ) return false;
484 if( fM[6] != rhs.fM[6] ) return false;
485 if( fM[7] != rhs.fM[7] ) return false;
486 if( fM[8] != rhs.fM[8] ) return false;
487 return true;
488 }
489 bool operator != (const Rotation3D & rhs) const {
490 return ! operator==(rhs);
491 }
492
493private:
494
495 Scalar fM[9]; // 9 elements (3x3 matrix) representing the rotation
496
497}; // Rotation3D
498
499// ============ Class Rotation3D ends here ============
500
501/**
502 Distance between two rotations
503 */
504template <class R>
505inline
506typename Rotation3D::Scalar
507Distance ( const Rotation3D& r1, const R & r2) {return gv_detail::dist(r1,r2);}
508
509/**
510 Multiplication of an axial rotation by a Rotation3D
511 */
512Rotation3D operator* (RotationX const & r1, Rotation3D const & r2);
513Rotation3D operator* (RotationY const & r1, Rotation3D const & r2);
514Rotation3D operator* (RotationZ const & r1, Rotation3D const & r2);
515
516/**
517 Multiplication of an axial rotation by another axial Rotation
518 */
519Rotation3D operator* (RotationX const & r1, RotationY const & r2);
520Rotation3D operator* (RotationX const & r1, RotationZ const & r2);
521
522Rotation3D operator* (RotationY const & r1, RotationX const & r2);
523Rotation3D operator* (RotationY const & r1, RotationZ const & r2);
524
525Rotation3D operator* (RotationZ const & r1, RotationX const & r2);
526Rotation3D operator* (RotationZ const & r1, RotationY const & r2);
527
528/**
529 Stream Output and Input
530 */
531 // TODO - I/O should be put in the manipulator form
532
533std::ostream & operator<< (std::ostream & os, const Rotation3D & r);
534
535} // namespace Math
536} // namespace ROOT
537
538#endif // ROOT_Math_GenVector_Rotation3D
#define a(i)
Definition RSha256.hxx:99
#define e(i)
Definition RSha256.hxx:103
ROOT::Detail::TRangeCast< T, true > TRangeDynCast
TRangeDynCast is an adapter class that allows the typed iteration through a TCollection.
Option_t Option_t TPoint TPoint const char GetTextMagnitude GetFillStyle GetLineColor GetLineWidth GetMarkerStyle GetTextAlign GetTextColor GetTextSize void char Point_t Rectangle_t WindowAttributes_t Float_t r
Option_t Option_t TPoint xy
float * q
AxisAngle class describing rotation represented with direction axis (3D Vector) and an angle of rotat...
Definition AxisAngle.h:42
EulerAngles class describing rotation as three angles (Euler Angles).
Definition EulerAngles.h:46
Rotation class with the (3D) rotation represented by a unit quaternion (u, i, j, k).
Definition Quaternion.h:49
Rotation class with the (3D) rotation represented by a 3x3 orthogonal matrix.
Definition Rotation3D.h:68
Rotation3D(AxisAngle const &a)
Construct from an AxisAngle.
Definition Rotation3D.h:104
constexpr Rotation3D(const ForeignMatrix &m)
Construct from a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition Rotation3D.h:135
Rotation3D(RotationZ const &r)
Construct from an axial rotation.
Definition Rotation3D.h:124
void SetComponents(IT begin, IT end)
Set the 9 matrix components given an iterator to the start of the desired data, and another to the en...
Definition Rotation3D.h:265
Rotation3D & operator=(Quaternion const &q)
Assign from a Quaternion.
Definition Rotation3D.h:195
void GetComponents(IT begin) const
Get the 9 matrix components into data specified by an iterator begin.
Definition Rotation3D.h:292
Rotation3D(IT begin, IT end)
Construct given a pair of pointers or iterators defining the beginning and end of an array of nine Sc...
Definition Rotation3D.h:92
Rotation3D(RotationX const &r)
Definition Rotation3D.h:126
void SetComponents(Scalar xx, Scalar xy, Scalar xz, Scalar yx, Scalar yy, Scalar yz, Scalar zx, Scalar zy, Scalar zz)
Set the components from nine scalars – UNCHECKED for orthonormaility.
Definition Rotation3D.h:327
void Rectify()
Re-adjust components to eliminate small deviations from perfect orthonormality.
Rotation3D & operator=(AxisAngle const &a)
Assign from an AxisAngle.
Definition Rotation3D.h:177
void Invert()
Invert a rotation in place.
void SetRotationMatrix(const ForeignMatrix &m)
Set components from a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition Rotation3D.h:304
Scalar operator()(size_t i, size_t j) const
Access operator, used to have direct access to rotation matrix's entries.
Definition Rotation3D.h:354
Rotation3D & operator=(Rotation3D const &rhs)
Assignment operator.
Definition Rotation3D.h:166
Rotation3D(RotationY const &r)
Definition Rotation3D.h:125
void GetComponents(ForeignVector &v1, ForeignVector &v2, ForeignVector &v3) const
Get components into three vectors which will be the (orthonormal) columns of the rotation matrix.
Definition Rotation3D.h:252
bool operator!=(const Rotation3D &rhs) const
Definition Rotation3D.h:489
Rotation3D & operator=(RotationZ const &r)
Assign from an axial rotation.
Definition Rotation3D.h:201
Rotation3D Inverse() const
Return inverse of a rotation.
Definition Rotation3D.h:431
Rotation3D & operator=(RotationZYX const &r)
Assign from RotationZYX.
Definition Rotation3D.h:189
Rotation3D(RotationZYX const &e)
Construct from RotationZYX.
Definition Rotation3D.h:114
AVector operator*(const AVector &v) const
Overload operator * for rotation on a vector.
Definition Rotation3D.h:418
Rotation3D(Rotation3D const &r)
copy constructor
Definition Rotation3D.h:97
Rotation3D(Quaternion const &q)
Construct from a Quaternion.
Definition Rotation3D.h:119
void SetComponents(const ForeignVector &v1, const ForeignVector &v2, const ForeignVector &v3)
Set components from three orthonormal vectors (which must have methods x(), y() and z()) which will b...
Definition Rotation3D.h:236
Rotation3D(EulerAngles const &e)
Construct from EulerAngles.
Definition Rotation3D.h:109
void GetComponents(IT begin, IT end) const
Get the 9 matrix components into data specified by an iterator begin and another to the end of the de...
Definition Rotation3D.h:279
Rotation3D(const ForeignVector &v1, const ForeignVector &v2, const ForeignVector &v3)
Construct from three orthonormal vectors (which must have methods x(), y() and z()) which will be use...
Definition Rotation3D.h:144
Rotation3D & operator=(RotationY const &r)
Definition Rotation3D.h:203
Rotation3D()
Default constructor (identity rotation)
void GetRotationMatrix(ForeignMatrix &m) const
Get components into a linear algebra matrix of size at least 3x3, which must support operator()(i,...
Definition Rotation3D.h:317
void GetComponents(Scalar &xx, Scalar &xy, Scalar &xz, Scalar &yx, Scalar &yy, Scalar &yz, Scalar &zx, Scalar &zy, Scalar &zz) const
Get the nine components into nine scalars.
Definition Rotation3D.h:339
Rotation3D & operator*=(const R &r)
Post-Multiply (on right) by another rotation : T = T*R.
Definition Rotation3D.h:472
Rotation3D(Scalar xx, Scalar xy, Scalar xz, Scalar yx, Scalar yy, Scalar yz, Scalar zx, Scalar zy, Scalar zz)
Raw constructor from nine Scalar components (without any checking)
Definition Rotation3D.h:153
Rotation3D & operator=(EulerAngles const &e)
Assign from EulerAngles.
Definition Rotation3D.h:183
Rotation3D & operator=(const ForeignMatrix &m)
Assign from an orthonormal linear algebra matrix of size 3x3, which must support operator()(i,...
Definition Rotation3D.h:213
Rotation3D & operator=(RotationX const &r)
Definition Rotation3D.h:205
bool operator==(const Rotation3D &rhs) const
Equality/inequality operators.
Definition Rotation3D.h:477
Rotation class representing a 3D rotation about the X axis by the angle of rotation.
Definition RotationX.h:46
Rotation class representing a 3D rotation about the Y axis by the angle of rotation.
Definition RotationY.h:46
Rotation class with the (3D) rotation represented by angles describing first a rotation of an angle p...
Definition RotationZYX.h:64
Rotation class representing a 3D rotation about the Z axis by the angle of rotation.
Definition RotationZ.h:46
Namespace for new Math classes and functions.
void Throw(const char *)
function throwing exception, by creating internally a GenVector_exception only when needed
double dist(Rotation3D const &r1, Rotation3D const &r2)
void convert(R1 const &, R2 const)
std::ostream & operator<<(std::ostream &os, const AxisAngle &a)
Stream Output and Input.
Definition AxisAngle.cxx:91
AxisAngle operator*(RotationX const &r1, AxisAngle const &r2)
Multiplication of an axial rotation by an AxisAngle.
AxisAngle::Scalar Distance(const AxisAngle &r1, const R &r2)
Distance between two rotations.
Definition AxisAngle.h:321
tbb::task_arena is an alias of tbb::interface7::task_arena, which doesn't allow to forward declare tb...
TMarker m
Definition textangle.C:8