```// @(#)root/mathcore:\$Id\$
// Authors: W. Brown, M. Fischler, L. Moneta    2005

/**********************************************************************
*                                                                    *
* Copyright (c) 2005 , LCG ROOT MathLib Team                         *
*                                                                    *
*                                                                    *
**********************************************************************/

// Header file for class Transform3D
//
// Created by: Lorenzo Moneta  October 21 2005
//
//
#ifndef ROOT_Math_GenVector_Transform3D
#define ROOT_Math_GenVector_Transform3D  1

#ifndef ROOT_Math_GenVector_DisplacementVector3D
#include "Math/GenVector/DisplacementVector3D.h"
#endif

#ifndef ROOT_Math_GenVector_PositionVector3D
#include "Math/GenVector/PositionVector3D.h"
#endif

#ifndef ROOT_Math_GenVector_Rotation3D
#include "Math/GenVector/Rotation3D.h"
#endif

#ifndef ROOT_Math_GenVector_Translation3D
#include "Math/GenVector/Translation3D.h"
#endif

#include "Math/GenVector/AxisAnglefwd.h"
#include "Math/GenVector/EulerAnglesfwd.h"
#include "Math/GenVector/Quaternionfwd.h"
#include "Math/GenVector/RotationZYXfwd.h"
#include "Math/GenVector/RotationXfwd.h"
#include "Math/GenVector/RotationYfwd.h"
#include "Math/GenVector/RotationZfwd.h"

#include <iostream>

//#include "Math/Vector3Dfwd.h"

namespace ROOT {

namespace Math {

class Plane3D;

//_________________________________________________________________________________________
/**
Basic 3D Transformation class describing  a rotation and then a translation
The internal data are a 3D rotation data (represented as a 3x3 matrix) and a 3D vector data.
They are represented and held in this class like a 3x4 matrix (a simple array of 12 numbers).

The class can be constructed from any 3D rotation object
(ROOT::Math::Rotation3D, ROOT::Math::AxisAngle, ROOT::Math::Quaternion, etc...) and/or
a 3D Vector (ROOT::Math::DislacementVector3D or via ROOT::Math::Translation ) representing a Translation.
The Transformation is defined by applying first the rotation and then the translation.
A transformation defined by applying first a translation and then a rotation is equivalent to the
transformation obtained applying first the rotation and then a translation equivalent to the rotated vector.
The operator * can be used to obtain directly such transformations, in addition to combine various
transformations.
Keep in mind that the operator * (like in the case of rotations ) is not commutative.
The operator * is used (in addition to operator() ) to apply a transformations on the vector
(DisplacementVector3D and LorentzVector classes) and point (PositionVector3D)  classes.
In the case of Vector objects the transformation only rotates them and does not translate them.
Only Point objects are able to be both rotated and translated.

@ingroup GenVector

*/

class Transform3D {

public:

typedef  DisplacementVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag >  Vector;
typedef  PositionVector3D<Cartesian3D<double>, DefaultCoordinateSystemTag >      Point;

enum ETransform3DMatrixIndex {
kXX = 0, kXY = 1, kXZ = 2, kDX = 3,
kYX = 4, kYY = 5, kYZ = 6, kDY = 7,
kZX = 8, kZY = 9, kZZ =10, kDZ = 11
};

/**
Default constructor (identy rotation) + zero translation
*/
Transform3D()
{
SetIdentity();
}

/**
Construct given a pair of pointers or iterators defining the
beginning and end of an array of 12 Scalars
*/
template<class IT>
Transform3D(IT begin, IT end)
{
SetComponents(begin,end);
}

/**
Construct from a rotation and then a translation described by a Vector
*/
Transform3D( const Rotation3D & r, const Vector & v)
{
AssignFrom( r, v );
}
/**
Construct from a rotation and then a translation described by a Translation3D class
*/
Transform3D( const Rotation3D & r, const Translation3D & t)
{
AssignFrom( r, t.Vect() );
}

/**
Construct from a rotation (any rotation object)  and then a translation
(represented by any DisplacementVector)
The requirements on the rotation and vector objects are that they can be transformed in a
Rotation3D class and in a Cartesian3D Vector
*/
template <class ARotation, class CoordSystem, class Tag>
Transform3D( const ARotation & r, const DisplacementVector3D<CoordSystem,Tag> & v)
{
AssignFrom( Rotation3D(r), Vector (v.X(),v.Y(),v.Z()) );
}

/**
Construct from a rotation (any rotation object)  and then a translation
represented by a Translation3D class
The requirements on the rotation is that it can be transformed in a
Rotation3D class
*/
template <class ARotation>
Transform3D( const ARotation & r, const Translation3D & t)
{
AssignFrom( Rotation3D(r), t.Vect() );
}

#ifdef OLD_VERSION
/**
Construct from a translation and then a rotation (inverse assignment)
*/
Transform3D( const Vector & v, const Rotation3D & r)
{
// is equivalent from having first the rotation and then the translation vector rotated
AssignFrom( r, r(v) );
}
#endif

/**
Construct from a 3D Rotation only with zero translation
*/
explicit Transform3D( const Rotation3D & r) {
AssignFrom(r);
}

// convenience methods for constructing a Transform3D from all the 3D rotations classes
// (cannot use templates for conflict with LA)

explicit Transform3D( const AxisAngle & r) {
AssignFrom(Rotation3D(r));
}
explicit Transform3D( const EulerAngles & r) {
AssignFrom(Rotation3D(r));
}
explicit Transform3D( const Quaternion & r) {
AssignFrom(Rotation3D(r));
}
explicit Transform3D( const RotationZYX & r) {
AssignFrom(Rotation3D(r));
}

// Constructors from axial rotations
// TO DO: implement direct methods for axial rotations without going through Rotation3D
explicit Transform3D( const RotationX & r) {
AssignFrom(Rotation3D(r));
}
explicit Transform3D( const RotationY & r) {
AssignFrom(Rotation3D(r));
}
explicit Transform3D( const RotationZ & r) {
AssignFrom(Rotation3D(r));
}

/**
Construct from a translation only, represented by any DisplacementVector3D
and with an identity rotation
*/
template<class CoordSystem, class Tag>
explicit Transform3D( const DisplacementVector3D<CoordSystem,Tag> & v) {
AssignFrom(Vector(v.X(),v.Y(),v.Z()));
}
/**
Construct from a translation only, represented by a Cartesian 3D Vector,
and with an identity rotation
*/
explicit Transform3D( const Vector & v) {
AssignFrom(v);
}
/**
Construct from a translation only, represented by a Translation3D class
and with an identity rotation
*/
explicit Transform3D( const Translation3D & t) {
AssignFrom(t.Vect());
}

//#if !defined(__MAKECINT__) && !defined(G__DICTIONARY)  // this is ambigous with double * , double *

#ifdef OLD_VERSION
/**
Construct from a translation (using any type of DisplacementVector )
and then a rotation (any rotation object).
Requirement on the rotation and vector objects are that they can be transformed in a
Rotation3D class and in a Vector
*/
template <class ARotation, class CoordSystem, class Tag>
Transform3D(const DisplacementVector3D<CoordSystem,Tag> & v , const ARotation & r)
{
// is equivalent from having first the rotation and then the translation vector rotated
Rotation3D r3d(r);
AssignFrom( r3d, r3d( Vector(v.X(),v.Y(),v.Z()) ) );
}
#endif

/**
Construct transformation from one coordinate system defined by three
points (origin + two axis) to
a new coordinate system defined by other three points (origin + axis)
@param fr0  point defining origin of original reference system
@param fr1  point defining first axis of original reference system
@param fr2  point defining second axis of original reference system
@param to0  point defining origin of transformed reference system
@param to1  point defining first axis transformed reference system
@param to2  point defining second axis transformed reference system

*/
Transform3D
(const Point & fr0, const Point & fr1, const Point & fr2,
const Point & to0, const Point & to1, const Point & to2 );

// use compiler generated copy ctor, copy assignmet and dtor

/**
Construct from a linear algebra matrix of size at least 3x4,
which must support operator()(i,j) to obtain elements (0,0) thru (2,3).
The 3x3 sub-block is assumed to be the rotation part and the translations vector
are described by the 4-th column
*/
template<class ForeignMatrix>
explicit Transform3D(const ForeignMatrix & m) {
SetComponents(m);
}

/**
Raw constructor from 12 Scalar components
*/
Transform3D(double  xx, double  xy, double  xz, double dx,
double  yx, double  yy, double  yz, double dy,
double  zx, double  zy, double  zz, double dz)
{
SetComponents (xx, xy, xz, dx, yx, yy, yz, dy, zx, zy, zz, dz);
}

/**
Construct from a linear algebra matrix of size at least 3x4,
which must support operator()(i,j) to obtain elements (0,0) thru (2,3).
The 3x3 sub-block is assumed to be the rotation part and the translations vector
are described by the 4-th column
*/
template<class ForeignMatrix>
Transform3D & operator= (const ForeignMatrix & m) {
SetComponents(m);
return *this;
}

// ======== Components ==============

/**
Set the 12 matrix components given an iterator to the start of
the desired data, and another to the end (12 past start).
*/
template<class IT>
#ifndef NDEBUG
void SetComponents(IT begin, IT end) {
#else
void SetComponents(IT begin, IT ) {
#endif
for (int i = 0; i <12; ++i) {
fM[i] = *begin;
++begin;
}
assert (end==begin);
}

/**
Get the 12 matrix components into data specified by an iterator begin
and another to the end of the desired data (12 past start).
*/
template<class IT>
#ifndef NDEBUG
void GetComponents(IT begin, IT end) const {
#else
void GetComponents(IT begin, IT ) const {
#endif
for (int i = 0; i <12; ++i) {
*begin = fM[i];
++begin;
}
assert (end==begin);
}

/**
Get the 12 matrix components into data specified by an iterator begin
*/
template<class IT>
void GetComponents(IT begin) const {
std::copy ( fM, fM+12, begin );
}

/**
Set components from a linear algebra matrix of size at least 3x4,
which must support operator()(i,j) to obtain elements (0,0) thru (2,3).
The 3x3 sub-block is assumed to be the rotation part and the translations vector
are described by the 4-th column
*/
template<class ForeignMatrix>
void
SetTransformMatrix (const ForeignMatrix & m) {
fM[kXX]=m(0,0);  fM[kXY]=m(0,1);  fM[kXZ]=m(0,2); fM[kDX]=m(0,3);
fM[kYX]=m(1,0);  fM[kYY]=m(1,1);  fM[kYZ]=m(1,2); fM[kDY]=m(1,3);
fM[kZX]=m(2,0);  fM[kZY]=m(2,1);  fM[kZZ]=m(2,2); fM[kDZ]=m(2,3);
}

/**
Get components into a linear algebra matrix of size at least 3x4,
(0,0) thru (2,3).
*/
template<class ForeignMatrix>
void
GetTransformMatrix (ForeignMatrix & m) const {
m(0,0)=fM[kXX];  m(0,1)=fM[kXY];  m(0,2)=fM[kXZ];  m(0,3)=fM[kDX];
m(1,0)=fM[kYX];  m(1,1)=fM[kYY];  m(1,2)=fM[kYZ];  m(1,3)=fM[kDY];
m(2,0)=fM[kZX];  m(2,1)=fM[kZY];  m(2,2)=fM[kZZ];  m(2,3)=fM[kDZ];
}

/**
Set the components from 12 scalars
*/
void
SetComponents (double  xx, double  xy, double  xz, double dx,
double  yx, double  yy, double  yz, double dy,
double  zx, double  zy, double  zz, double dz) {
fM[kXX]=xx;  fM[kXY]=xy;  fM[kXZ]=xz;  fM[kDX]=dx;
fM[kYX]=yx;  fM[kYY]=yy;  fM[kYZ]=yz;  fM[kDY]=dy;
fM[kZX]=zx;  fM[kZY]=zy;  fM[kZZ]=zz;  fM[kDZ]=dz;
}

/**
Get the components into 12 scalars
*/
void
GetComponents (double &xx, double &xy, double &xz, double &dx,
double &yx, double &yy, double &yz, double &dy,
double &zx, double &zy, double &zz, double &dz) const {
xx=fM[kXX];  xy=fM[kXY];  xz=fM[kXZ];  dx=fM[kDX];
yx=fM[kYX];  yy=fM[kYY];  yz=fM[kYZ];  dy=fM[kDY];
zx=fM[kZX];  zy=fM[kZY];  zz=fM[kZZ];  dz=fM[kDZ];
}

/**
Get the rotation and translation vector representing the 3D transformation
in any rotation and any vector (the Translation class could also be used)
*/
template<class AnyRotation, class V>
void GetDecomposition(AnyRotation &r, V &v) const {
GetRotation(r);
GetTranslation(v);
}

/**
Get the rotation and translation vector representing the 3D transformation
*/
void GetDecomposition(Rotation3D &r, Vector &v) const {
GetRotation(r);
GetTranslation(v);
}

/**
Get the 3D rotation representing the 3D transformation
*/
Rotation3D Rotation() const {
return Rotation3D( fM[kXX], fM[kXY], fM[kXZ],
fM[kYX], fM[kYY], fM[kYZ],
fM[kZX], fM[kZY], fM[kZZ] );
}

/**
Get the rotation representing the 3D transformation
*/
template <class AnyRotation>
AnyRotation Rotation() const {
return AnyRotation(Rotation3D(fM[kXX], fM[kXY], fM[kXZ],
fM[kYX], fM[kYY], fM[kYZ],
fM[kZX], fM[kZY], fM[kZZ] ) );
}

/**
Get the  rotation (any type) representing the 3D transformation
*/
template <class AnyRotation>
void GetRotation(AnyRotation &r) const {
r = Rotation();
}

/**
Get the translation representing the 3D transformation in a Cartesian vector
*/
Translation3D Translation() const {
return Translation3D( fM[kDX], fM[kDY], fM[kDZ] );
}

/**
Get the translation representing the 3D transformation in any vector
which implements the SetXYZ method
*/
template <class AnyVector>
void GetTranslation(AnyVector &v) const {
v.SetXYZ(fM[kDX], fM[kDY], fM[kDZ]);
}

// operations on points and vectors

/**
Transformation operation for Position Vector in Cartesian coordinate
For a Position Vector first a rotation and then a translation is applied
*/
Point operator() (const Point & p) const {
return Point ( fM[kXX]*p.X() + fM[kXY]*p.Y() + fM[kXZ]*p.Z() + fM[kDX],
fM[kYX]*p.X() + fM[kYY]*p.Y() + fM[kYZ]*p.Z() + fM[kDY],
fM[kZX]*p.X() + fM[kZY]*p.Y() + fM[kZZ]*p.Z() + fM[kDZ] );
}

/**
Transformation operation for Displacement Vectors in Cartesian coordinate
For the Displacement Vectors only the rotation applies - no translations
*/
Vector operator() (const Vector & v) const {
return Vector( fM[kXX]*v.X() + fM[kXY]*v.Y() + fM[kXZ]*v.Z() ,
fM[kYX]*v.X() + fM[kYY]*v.Y() + fM[kYZ]*v.Z() ,
fM[kZX]*v.X() + fM[kZY]*v.Y() + fM[kZZ]*v.Z()  );
}

/**
Transformation operation for Position Vector in any coordinate system
*/
template<class CoordSystem >
PositionVector3D<CoordSystem> operator() (const PositionVector3D <CoordSystem> & p) const {
Point xyzNew = operator() ( Point(p) );
return  PositionVector3D<CoordSystem> (xyzNew);
}

/**
Transformation operation for Displacement Vector in any coordinate system
*/
template<class CoordSystem >
DisplacementVector3D<CoordSystem> operator() (const DisplacementVector3D <CoordSystem> & v) const {
Vector xyzNew = operator() ( Vector(v) );
return  DisplacementVector3D<CoordSystem> (xyzNew);
}

/**
Transformation operation for points between different coordinate system tags
*/
template<class CoordSystem, class Tag1, class Tag2 >
void Transform (const PositionVector3D <CoordSystem,Tag1> & p1, PositionVector3D <CoordSystem,Tag2> & p2  ) const {
Point xyzNew = operator() ( Point(p1.X(), p1.Y(), p1.Z()) );
p2.SetXYZ( xyzNew.X(), xyzNew.Y(), xyzNew.Z() );
}

/**
Transformation operation for Displacement Vector of different coordinate systems
*/
template<class CoordSystem,  class Tag1, class Tag2 >
void Transform (const DisplacementVector3D <CoordSystem,Tag1> & v1, DisplacementVector3D <CoordSystem,Tag2> & v2  ) const {
Vector xyzNew = operator() ( Vector(v1.X(), v1.Y(), v1.Z() ) );
v2.SetXYZ( xyzNew.X(), xyzNew.Y(), xyzNew.Z() );
}

/**
Transformation operation for a Lorentz Vector in any  coordinate system
*/
template <class CoordSystem >
LorentzVector<CoordSystem> operator() (const LorentzVector<CoordSystem> & q) const {
Vector xyzNew = operator() ( Vector(q.Vect() ) );
return  LorentzVector<CoordSystem> (xyzNew.X(), xyzNew.Y(), xyzNew.Z(), q.E() );
}

/**
Transformation on a 3D plane
*/
Plane3D operator() (const Plane3D & plane) const;

// skip transformation for arbitrary vectors - not really defined if point or displacement vectors

// same but with operator *
/**
Transformation operation for Vectors. Apply same rules as operator()
depending on type of vector.
Will work only for DisplacementVector3D, PositionVector3D and LorentzVector
*/
template<class AVector >
AVector operator * (const AVector & v) const {
return operator() (v);
}

/**
multiply (combine) with another transformation in place
*/
inline Transform3D & operator *= (const Transform3D  & t);

/**
multiply (combine) two transformations
*/
inline Transform3D operator * (const Transform3D  & t) const;

/**
Invert the transformation in place
*/
void Invert();

/**
Return the inverse of the transformation.
*/
Transform3D Inverse() const {
Transform3D t(*this);
t.Invert();
return t;
}

/**
Equality operator. Check equality for each element
To do: use double tolerance
*/
bool operator == (const Transform3D & rhs) const {
if( fM[0] != rhs.fM[0] )  return false;
if( fM[1] != rhs.fM[1] )  return false;
if( fM[2] != rhs.fM[2] )  return false;
if( fM[3] != rhs.fM[3] )  return false;
if( fM[4] != rhs.fM[4] )  return false;
if( fM[5] != rhs.fM[5] )  return false;
if( fM[6] != rhs.fM[6] )  return false;
if( fM[7] != rhs.fM[7] )  return false;
if( fM[8] != rhs.fM[8] )  return false;
if( fM[9] != rhs.fM[9] )  return false;
if( fM[10]!= rhs.fM[10] ) return false;
if( fM[11]!= rhs.fM[11] ) return false;
return true;
}

/**
Inequality operator. Check equality for each element
To do: use double tolerance
*/
bool operator != (const Transform3D & rhs) const {
return ! operator==(rhs);
}

protected:

/**
make transformation from first a rotation then a translation
*/
void  AssignFrom( const Rotation3D & r, const Vector & v);

/**
make transformation from only rotations (zero translation)
*/
void  AssignFrom( const Rotation3D & r);

/**
make transformation from only translation (identity rotations)
*/
void  AssignFrom( const Vector & v);

/**
Set identity transformation (identity rotation , zero translation)
*/
void SetIdentity() ;

private:

double fM[12];    // transformation elements (3x4 matrix)

};

// inline functions (combination of transformations)

inline Transform3D & Transform3D::operator *= (const Transform3D  & t)
{
// combination of transformations

SetComponents(fM[kXX]*t.fM[kXX]+fM[kXY]*t.fM[kYX]+fM[kXZ]*t.fM[kZX],
fM[kXX]*t.fM[kXY]+fM[kXY]*t.fM[kYY]+fM[kXZ]*t.fM[kZY],
fM[kXX]*t.fM[kXZ]+fM[kXY]*t.fM[kYZ]+fM[kXZ]*t.fM[kZZ],
fM[kXX]*t.fM[kDX]+fM[kXY]*t.fM[kDY]+fM[kXZ]*t.fM[kDZ]+fM[kDX],

fM[kYX]*t.fM[kXX]+fM[kYY]*t.fM[kYX]+fM[kYZ]*t.fM[kZX],
fM[kYX]*t.fM[kXY]+fM[kYY]*t.fM[kYY]+fM[kYZ]*t.fM[kZY],
fM[kYX]*t.fM[kXZ]+fM[kYY]*t.fM[kYZ]+fM[kYZ]*t.fM[kZZ],
fM[kYX]*t.fM[kDX]+fM[kYY]*t.fM[kDY]+fM[kYZ]*t.fM[kDZ]+fM[kDY],

fM[kZX]*t.fM[kXX]+fM[kZY]*t.fM[kYX]+fM[kZZ]*t.fM[kZX],
fM[kZX]*t.fM[kXY]+fM[kZY]*t.fM[kYY]+fM[kZZ]*t.fM[kZY],
fM[kZX]*t.fM[kXZ]+fM[kZY]*t.fM[kYZ]+fM[kZZ]*t.fM[kZZ],
fM[kZX]*t.fM[kDX]+fM[kZY]*t.fM[kDY]+fM[kZZ]*t.fM[kDZ]+fM[kDZ]);

return *this;
}

inline Transform3D Transform3D::operator * (const Transform3D  & t) const
{
// combination of transformations

return Transform3D(fM[kXX]*t.fM[kXX]+fM[kXY]*t.fM[kYX]+fM[kXZ]*t.fM[kZX],
fM[kXX]*t.fM[kXY]+fM[kXY]*t.fM[kYY]+fM[kXZ]*t.fM[kZY],
fM[kXX]*t.fM[kXZ]+fM[kXY]*t.fM[kYZ]+fM[kXZ]*t.fM[kZZ],
fM[kXX]*t.fM[kDX]+fM[kXY]*t.fM[kDY]+fM[kXZ]*t.fM[kDZ]+fM[kDX],

fM[kYX]*t.fM[kXX]+fM[kYY]*t.fM[kYX]+fM[kYZ]*t.fM[kZX],
fM[kYX]*t.fM[kXY]+fM[kYY]*t.fM[kYY]+fM[kYZ]*t.fM[kZY],
fM[kYX]*t.fM[kXZ]+fM[kYY]*t.fM[kYZ]+fM[kYZ]*t.fM[kZZ],
fM[kYX]*t.fM[kDX]+fM[kYY]*t.fM[kDY]+fM[kYZ]*t.fM[kDZ]+fM[kDY],

fM[kZX]*t.fM[kXX]+fM[kZY]*t.fM[kYX]+fM[kZZ]*t.fM[kZX],
fM[kZX]*t.fM[kXY]+fM[kZY]*t.fM[kYY]+fM[kZZ]*t.fM[kZY],
fM[kZX]*t.fM[kXZ]+fM[kZY]*t.fM[kYZ]+fM[kZZ]*t.fM[kZZ],
fM[kZX]*t.fM[kDX]+fM[kZY]*t.fM[kDY]+fM[kZZ]*t.fM[kDZ]+fM[kDZ]  );

}

//--- global functions resulting in Transform3D -------

// ------ combination of a  translation (first)  and a rotation ------

/**
combine a translation and a rotation to give a transform3d
First the translation then the rotation
*/
inline Transform3D operator * (const Rotation3D & r, const Translation3D & t) {
return Transform3D( r, r(t.Vect()) );
}
inline Transform3D operator * (const RotationX & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const RotationY & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const RotationZ & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const RotationZYX & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const AxisAngle & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const EulerAngles & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}
inline Transform3D operator * (const Quaternion & r, const Translation3D & t) {
Rotation3D r3(r);
return Transform3D( r3, r3(t.Vect()) );
}

// ------ combination of a  rotation (first)  and then a translation ------

/**
combine a rotation and a translation to give a transform3d
First a rotation then the translation
*/
inline Transform3D operator * (const Translation3D & t, const Rotation3D & r) {
return Transform3D( r, t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const RotationX & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const RotationY & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const RotationZ & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const RotationZYX & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const EulerAngles & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const Quaternion & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}
inline Transform3D operator * (const Translation3D & t, const AxisAngle & r) {
return Transform3D( Rotation3D(r) , t.Vect());
}

// ------ combination of a Transform3D and a pure translation------

/**
combine a transformation and a translation to give a transform3d
First the translation then the transform3D
*/
inline Transform3D operator * (const Transform3D & t, const Translation3D & d) {
Rotation3D r = t.Rotation();
return Transform3D( r, r( d.Vect() ) + t.Translation().Vect()  );
}

/**
combine a translation and a transformation to give a transform3d
First the transformation then the translation
*/
inline Transform3D operator * (const Translation3D & d, const Transform3D & t) {
return Transform3D( t.Rotation(), t.Translation().Vect() + d.Vect());
}

// ------ combination of a Transform3D and any rotation------

/**
combine a transformation and a rotation to give a transform3d
First the rotation then the transform3D
*/
inline Transform3D operator * (const Transform3D & t, const Rotation3D & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const RotationX & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const RotationY & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const RotationZ & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const RotationZYX & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const EulerAngles & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const AxisAngle & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}
inline Transform3D operator * (const Transform3D & t, const Quaternion & r) {
return Transform3D( t.Rotation()*r ,  t.Translation()  );
}

/**
combine a rotation and a transformation to give a transform3d
First the transformation then the rotation
*/
inline Transform3D operator * (const Rotation3D & r, const Transform3D & t) {
return Transform3D( r * t.Rotation(), r * t.Translation().Vect() );
}
inline Transform3D operator * (const RotationX & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const RotationY & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const RotationZ & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const RotationZYX & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const EulerAngles & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const AxisAngle & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}
inline Transform3D operator * (const Quaternion & r, const Transform3D & t) {
Rotation3D r3d(r);
return Transform3D( r3d * t.Rotation(), r3d * t.Translation().Vect() );
}

//---I/O functions
// TODO - I/O should be put in the manipulator form

/**
print the 12 components of the Transform3D
*/
std::ostream & operator<< (std::ostream & os, const Transform3D & t);

} // end namespace Math

} // end namespace ROOT

#endif /* ROOT_Math_GenVector_Transform3D */
```
Transform3D.h:1
Transform3D.h:2
Transform3D.h:3
Transform3D.h:4
Transform3D.h:5
Transform3D.h:6
Transform3D.h:7
Transform3D.h:8
Transform3D.h:9
Transform3D.h:10
Transform3D.h:11
Transform3D.h:12
Transform3D.h:13
Transform3D.h:14
Transform3D.h:15
Transform3D.h:16
Transform3D.h:17
Transform3D.h:18
Transform3D.h:19
Transform3D.h:20
Transform3D.h:21
Transform3D.h:22
Transform3D.h:23
Transform3D.h:24
Transform3D.h:25
Transform3D.h:26
Transform3D.h:27
Transform3D.h:28
Transform3D.h:29
Transform3D.h:30
Transform3D.h:31
Transform3D.h:32
Transform3D.h:33
Transform3D.h:34
Transform3D.h:35
Transform3D.h:36
Transform3D.h:37
Transform3D.h:38
Transform3D.h:39
Transform3D.h:40
Transform3D.h:41
Transform3D.h:42
Transform3D.h:43
Transform3D.h:44
Transform3D.h:45
Transform3D.h:46
Transform3D.h:47
Transform3D.h:48
Transform3D.h:49
Transform3D.h:50
Transform3D.h:51
Transform3D.h:52
Transform3D.h:53
Transform3D.h:54
Transform3D.h:55
Transform3D.h:56
Transform3D.h:57
Transform3D.h:58
Transform3D.h:59
Transform3D.h:60
Transform3D.h:61
Transform3D.h:62
Transform3D.h:63
Transform3D.h:64
Transform3D.h:65
Transform3D.h:66
Transform3D.h:67
Transform3D.h:68
Transform3D.h:69
Transform3D.h:70
Transform3D.h:71
Transform3D.h:72
Transform3D.h:73
Transform3D.h:74
Transform3D.h:75
Transform3D.h:76
Transform3D.h:77
Transform3D.h:78
Transform3D.h:79
Transform3D.h:80
Transform3D.h:81
Transform3D.h:82
Transform3D.h:83
Transform3D.h:84
Transform3D.h:85
Transform3D.h:86
Transform3D.h:87
Transform3D.h:88
Transform3D.h:89
Transform3D.h:90
Transform3D.h:91
Transform3D.h:92
Transform3D.h:93
Transform3D.h:94
Transform3D.h:95
Transform3D.h:96
Transform3D.h:97
Transform3D.h:98
Transform3D.h:99
Transform3D.h:100
Transform3D.h:101
Transform3D.h:102
Transform3D.h:103
Transform3D.h:104
Transform3D.h:105
Transform3D.h:106
Transform3D.h:107
Transform3D.h:108
Transform3D.h:109
Transform3D.h:110
Transform3D.h:111
Transform3D.h:112
Transform3D.h:113
Transform3D.h:114
Transform3D.h:115
Transform3D.h:116
Transform3D.h:117
Transform3D.h:118
Transform3D.h:119
Transform3D.h:120
Transform3D.h:121
Transform3D.h:122
Transform3D.h:123
Transform3D.h:124
Transform3D.h:125
Transform3D.h:126
Transform3D.h:127
Transform3D.h:128
Transform3D.h:129
Transform3D.h:130
Transform3D.h:131
Transform3D.h:132
Transform3D.h:133
Transform3D.h:134
Transform3D.h:135
Transform3D.h:136
Transform3D.h:137
Transform3D.h:138
Transform3D.h:139
Transform3D.h:140
Transform3D.h:141
Transform3D.h:142
Transform3D.h:143
Transform3D.h:144
Transform3D.h:145
Transform3D.h:146
Transform3D.h:147
Transform3D.h:148
Transform3D.h:149
Transform3D.h:150
Transform3D.h:151
Transform3D.h:152
Transform3D.h:153
Transform3D.h:154
Transform3D.h:155
Transform3D.h:156
Transform3D.h:157
Transform3D.h:158
Transform3D.h:159
Transform3D.h:160
Transform3D.h:161
Transform3D.h:162
Transform3D.h:163
Transform3D.h:164
Transform3D.h:165
Transform3D.h:166
Transform3D.h:167
Transform3D.h:168
Transform3D.h:169
Transform3D.h:170
Transform3D.h:171
Transform3D.h:172
Transform3D.h:173
Transform3D.h:174
Transform3D.h:175
Transform3D.h:176
Transform3D.h:177
Transform3D.h:178
Transform3D.h:179
Transform3D.h:180
Transform3D.h:181
Transform3D.h:182
Transform3D.h:183
Transform3D.h:184
Transform3D.h:185
Transform3D.h:186
Transform3D.h:187
Transform3D.h:188
Transform3D.h:189
Transform3D.h:190
Transform3D.h:191
Transform3D.h:192
Transform3D.h:193
Transform3D.h:194
Transform3D.h:195
Transform3D.h:196
Transform3D.h:197
Transform3D.h:198
Transform3D.h:199
Transform3D.h:200
Transform3D.h:201
Transform3D.h:202
Transform3D.h:203
Transform3D.h:204
Transform3D.h:205
Transform3D.h:206
Transform3D.h:207
Transform3D.h:208
Transform3D.h:209
Transform3D.h:210
Transform3D.h:211
Transform3D.h:212
Transform3D.h:213
Transform3D.h:214
Transform3D.h:215
Transform3D.h:216
Transform3D.h:217
Transform3D.h:218
Transform3D.h:219
Transform3D.h:220
Transform3D.h:221
Transform3D.h:222
Transform3D.h:223
Transform3D.h:224
Transform3D.h:225
Transform3D.h:226
Transform3D.h:227
Transform3D.h:228
Transform3D.h:229
Transform3D.h:230
Transform3D.h:231
Transform3D.h:232
Transform3D.h:233
Transform3D.h:234
Transform3D.h:235
Transform3D.h:236
Transform3D.h:237
Transform3D.h:238
Transform3D.h:239
Transform3D.h:240
Transform3D.h:241
Transform3D.h:242
Transform3D.h:243
Transform3D.h:244
Transform3D.h:245
Transform3D.h:246
Transform3D.h:247
Transform3D.h:248
Transform3D.h:249
Transform3D.h:250
Transform3D.h:251
Transform3D.h:252
Transform3D.h:253
Transform3D.h:254
Transform3D.h:255
Transform3D.h:256
Transform3D.h:257
Transform3D.h:258
Transform3D.h:259
Transform3D.h:260
Transform3D.h:261
Transform3D.h:262
Transform3D.h:263
Transform3D.h:264
Transform3D.h:265
Transform3D.h:266
Transform3D.h:267
Transform3D.h:268
Transform3D.h:269
Transform3D.h:270
Transform3D.h:271
Transform3D.h:272
Transform3D.h:273
Transform3D.h:274
Transform3D.h:275
Transform3D.h:276
Transform3D.h:277
Transform3D.h:278
Transform3D.h:279
Transform3D.h:280
Transform3D.h:281
Transform3D.h:282
Transform3D.h:283
Transform3D.h:284
Transform3D.h:285
Transform3D.h:286
Transform3D.h:287
Transform3D.h:288
Transform3D.h:289
Transform3D.h:290
Transform3D.h:291
Transform3D.h:292
Transform3D.h:293
Transform3D.h:294
Transform3D.h:295
Transform3D.h:296
Transform3D.h:297
Transform3D.h:298
Transform3D.h:299
Transform3D.h:300
Transform3D.h:301
Transform3D.h:302
Transform3D.h:303
Transform3D.h:304
Transform3D.h:305
Transform3D.h:306
Transform3D.h:307
Transform3D.h:308
Transform3D.h:309
Transform3D.h:310
Transform3D.h:311
Transform3D.h:312
Transform3D.h:313
Transform3D.h:314
Transform3D.h:315
Transform3D.h:316
Transform3D.h:317
Transform3D.h:318
Transform3D.h:319
Transform3D.h:320
Transform3D.h:321
Transform3D.h:322
Transform3D.h:323
Transform3D.h:324
Transform3D.h:325
Transform3D.h:326
Transform3D.h:327
Transform3D.h:328
Transform3D.h:329
Transform3D.h:330
Transform3D.h:331
Transform3D.h:332
Transform3D.h:333
Transform3D.h:334
Transform3D.h:335
Transform3D.h:336
Transform3D.h:337
Transform3D.h:338
Transform3D.h:339
Transform3D.h:340
Transform3D.h:341
Transform3D.h:342
Transform3D.h:343
Transform3D.h:344
Transform3D.h:345
Transform3D.h:346
Transform3D.h:347
Transform3D.h:348
Transform3D.h:349
Transform3D.h:350
Transform3D.h:351
Transform3D.h:352
Transform3D.h:353
Transform3D.h:354
Transform3D.h:355
Transform3D.h:356
Transform3D.h:357
Transform3D.h:358
Transform3D.h:359
Transform3D.h:360
Transform3D.h:361
Transform3D.h:362
Transform3D.h:363
Transform3D.h:364
Transform3D.h:365
Transform3D.h:366
Transform3D.h:367
Transform3D.h:368
Transform3D.h:369
Transform3D.h:370
Transform3D.h:371
Transform3D.h:372
Transform3D.h:373
Transform3D.h:374
Transform3D.h:375
Transform3D.h:376
Transform3D.h:377
Transform3D.h:378
Transform3D.h:379
Transform3D.h:380
Transform3D.h:381
Transform3D.h:382
Transform3D.h:383
Transform3D.h:384
Transform3D.h:385
Transform3D.h:386
Transform3D.h:387
Transform3D.h:388
Transform3D.h:389
Transform3D.h:390
Transform3D.h:391
Transform3D.h:392
Transform3D.h:393
Transform3D.h:394
Transform3D.h:395
Transform3D.h:396
Transform3D.h:397
Transform3D.h:398
Transform3D.h:399
Transform3D.h:400
Transform3D.h:401
Transform3D.h:402
Transform3D.h:403
Transform3D.h:404
Transform3D.h:405
Transform3D.h:406
Transform3D.h:407
Transform3D.h:408
Transform3D.h:409
Transform3D.h:410
Transform3D.h:411
Transform3D.h:412
Transform3D.h:413
Transform3D.h:414
Transform3D.h:415
Transform3D.h:416
Transform3D.h:417
Transform3D.h:418
Transform3D.h:419
Transform3D.h:420
Transform3D.h:421
Transform3D.h:422
Transform3D.h:423
Transform3D.h:424
Transform3D.h:425
Transform3D.h:426
Transform3D.h:427
Transform3D.h:428
Transform3D.h:429
Transform3D.h:430
Transform3D.h:431
Transform3D.h:432
Transform3D.h:433
Transform3D.h:434
Transform3D.h:435
Transform3D.h:436
Transform3D.h:437
Transform3D.h:438
Transform3D.h:439
Transform3D.h:440
Transform3D.h:441
Transform3D.h:442
Transform3D.h:443
Transform3D.h:444
Transform3D.h:445
Transform3D.h:446
Transform3D.h:447
Transform3D.h:448
Transform3D.h:449
Transform3D.h:450
Transform3D.h:451
Transform3D.h:452
Transform3D.h:453
Transform3D.h:454
Transform3D.h:455
Transform3D.h:456
Transform3D.h:457
Transform3D.h:458
Transform3D.h:459
Transform3D.h:460
Transform3D.h:461
Transform3D.h:462
Transform3D.h:463
Transform3D.h:464
Transform3D.h:465
Transform3D.h:466
Transform3D.h:467
Transform3D.h:468
Transform3D.h:469
Transform3D.h:470
Transform3D.h:471
Transform3D.h:472
Transform3D.h:473
Transform3D.h:474
Transform3D.h:475
Transform3D.h:476
Transform3D.h:477
Transform3D.h:478
Transform3D.h:479
Transform3D.h:480
Transform3D.h:481
Transform3D.h:482
Transform3D.h:483
Transform3D.h:484
Transform3D.h:485
Transform3D.h:486
Transform3D.h:487
Transform3D.h:488
Transform3D.h:489
Transform3D.h:490
Transform3D.h:491
Transform3D.h:492
Transform3D.h:493
Transform3D.h:494
Transform3D.h:495
Transform3D.h:496
Transform3D.h:497
Transform3D.h:498
Transform3D.h:499
Transform3D.h:500
Transform3D.h:501
Transform3D.h:502
Transform3D.h:503
Transform3D.h:504
Transform3D.h:505
Transform3D.h:506
Transform3D.h:507
Transform3D.h:508
Transform3D.h:509
Transform3D.h:510
Transform3D.h:511
Transform3D.h:512
Transform3D.h:513
Transform3D.h:514
Transform3D.h:515
Transform3D.h:516
Transform3D.h:517
Transform3D.h:518
Transform3D.h:519
Transform3D.h:520
Transform3D.h:521
Transform3D.h:522
Transform3D.h:523
Transform3D.h:524
Transform3D.h:525
Transform3D.h:526
Transform3D.h:527
Transform3D.h:528
Transform3D.h:529
Transform3D.h:530
Transform3D.h:531
Transform3D.h:532
Transform3D.h:533
Transform3D.h:534
Transform3D.h:535
Transform3D.h:536
Transform3D.h:537
Transform3D.h:538
Transform3D.h:539
Transform3D.h:540
Transform3D.h:541
Transform3D.h:542
Transform3D.h:543
Transform3D.h:544
Transform3D.h:545
Transform3D.h:546
Transform3D.h:547
Transform3D.h:548
Transform3D.h:549
Transform3D.h:550
Transform3D.h:551
Transform3D.h:552
Transform3D.h:553
Transform3D.h:554
Transform3D.h:555
Transform3D.h:556
Transform3D.h:557
Transform3D.h:558
Transform3D.h:559
Transform3D.h:560
Transform3D.h:561
Transform3D.h:562
Transform3D.h:563
Transform3D.h:564
Transform3D.h:565
Transform3D.h:566
Transform3D.h:567
Transform3D.h:568
Transform3D.h:569
Transform3D.h:570
Transform3D.h:571
Transform3D.h:572
Transform3D.h:573
Transform3D.h:574
Transform3D.h:575
Transform3D.h:576
Transform3D.h:577
Transform3D.h:578
Transform3D.h:579
Transform3D.h:580
Transform3D.h:581
Transform3D.h:582
Transform3D.h:583
Transform3D.h:584
Transform3D.h:585
Transform3D.h:586
Transform3D.h:587
Transform3D.h:588
Transform3D.h:589
Transform3D.h:590
Transform3D.h:591
Transform3D.h:592
Transform3D.h:593
Transform3D.h:594
Transform3D.h:595
Transform3D.h:596
Transform3D.h:597
Transform3D.h:598
Transform3D.h:599
Transform3D.h:600
Transform3D.h:601
Transform3D.h:602
Transform3D.h:603
Transform3D.h:604
Transform3D.h:605
Transform3D.h:606
Transform3D.h:607
Transform3D.h:608
Transform3D.h:609
Transform3D.h:610
Transform3D.h:611
Transform3D.h:612
Transform3D.h:613
Transform3D.h:614
Transform3D.h:615
Transform3D.h:616
Transform3D.h:617
Transform3D.h:618
Transform3D.h:619
Transform3D.h:620
Transform3D.h:621
Transform3D.h:622
Transform3D.h:623
Transform3D.h:624
Transform3D.h:625
Transform3D.h:626
Transform3D.h:627
Transform3D.h:628
Transform3D.h:629
Transform3D.h:630
Transform3D.h:631
Transform3D.h:632
Transform3D.h:633
Transform3D.h:634
Transform3D.h:635
Transform3D.h:636
Transform3D.h:637
Transform3D.h:638
Transform3D.h:639
Transform3D.h:640
Transform3D.h:641
Transform3D.h:642
Transform3D.h:643
Transform3D.h:644
Transform3D.h:645
Transform3D.h:646
Transform3D.h:647
Transform3D.h:648
Transform3D.h:649
Transform3D.h:650
Transform3D.h:651
Transform3D.h:652
Transform3D.h:653
Transform3D.h:654
Transform3D.h:655
Transform3D.h:656
Transform3D.h:657
Transform3D.h:658
Transform3D.h:659
Transform3D.h:660
Transform3D.h:661
Transform3D.h:662
Transform3D.h:663
Transform3D.h:664
Transform3D.h:665
Transform3D.h:666
Transform3D.h:667
Transform3D.h:668
Transform3D.h:669
Transform3D.h:670
Transform3D.h:671
Transform3D.h:672
Transform3D.h:673
Transform3D.h:674
Transform3D.h:675
Transform3D.h:676
Transform3D.h:677
Transform3D.h:678
Transform3D.h:679
Transform3D.h:680
Transform3D.h:681
Transform3D.h:682
Transform3D.h:683
Transform3D.h:684
Transform3D.h:685
Transform3D.h:686
Transform3D.h:687
Transform3D.h:688
Transform3D.h:689
Transform3D.h:690
Transform3D.h:691
Transform3D.h:692
Transform3D.h:693
Transform3D.h:694
Transform3D.h:695
Transform3D.h:696
Transform3D.h:697
Transform3D.h:698
Transform3D.h:699
Transform3D.h:700
Transform3D.h:701
Transform3D.h:702
Transform3D.h:703
Transform3D.h:704
Transform3D.h:705
Transform3D.h:706
Transform3D.h:707
Transform3D.h:708
Transform3D.h:709
Transform3D.h:710
Transform3D.h:711
Transform3D.h:712
Transform3D.h:713
Transform3D.h:714
Transform3D.h:715
Transform3D.h:716
Transform3D.h:717
Transform3D.h:718
Transform3D.h:719
Transform3D.h:720
Transform3D.h:721
Transform3D.h:722
Transform3D.h:723
Transform3D.h:724
Transform3D.h:725
Transform3D.h:726
Transform3D.h:727
Transform3D.h:728
Transform3D.h:729
Transform3D.h:730
Transform3D.h:731
Transform3D.h:732
Transform3D.h:733
Transform3D.h:734
Transform3D.h:735
Transform3D.h:736
Transform3D.h:737
Transform3D.h:738
Transform3D.h:739
Transform3D.h:740
Transform3D.h:741
Transform3D.h:742
Transform3D.h:743
Transform3D.h:744
Transform3D.h:745
Transform3D.h:746
Transform3D.h:747
Transform3D.h:748
Transform3D.h:749
Transform3D.h:750
Transform3D.h:751
Transform3D.h:752
Transform3D.h:753
Transform3D.h:754
Transform3D.h:755
Transform3D.h:756
Transform3D.h:757
Transform3D.h:758
Transform3D.h:759
Transform3D.h:760
Transform3D.h:761
Transform3D.h:762
Transform3D.h:763
Transform3D.h:764
Transform3D.h:765
Transform3D.h:766
Transform3D.h:767
Transform3D.h:768
Transform3D.h:769
Transform3D.h:770
Transform3D.h:771
Transform3D.h:772
Transform3D.h:773
Transform3D.h:774
Transform3D.h:775
Transform3D.h:776
Transform3D.h:777
Transform3D.h:778
Transform3D.h:779
Transform3D.h:780
Transform3D.h:781
Transform3D.h:782
Transform3D.h:783
Transform3D.h:784
Transform3D.h:785
Transform3D.h:786
Transform3D.h:787
Transform3D.h:788
Transform3D.h:789
Transform3D.h:790
Transform3D.h:791
Transform3D.h:792
Transform3D.h:793
Transform3D.h:794
Transform3D.h:795
Transform3D.h:796
Transform3D.h:797
Transform3D.h:798
Transform3D.h:799
Transform3D.h:800
Transform3D.h:801
Transform3D.h:802
Transform3D.h:803
Transform3D.h:804
Transform3D.h:805
Transform3D.h:806
Transform3D.h:807
Transform3D.h:808
Transform3D.h:809
Transform3D.h:810
Transform3D.h:811
Transform3D.h:812
Transform3D.h:813
Transform3D.h:814
Transform3D.h:815
Transform3D.h:816
Transform3D.h:817
Transform3D.h:818
Transform3D.h:819
Transform3D.h:820
Transform3D.h:821
Transform3D.h:822
Transform3D.h:823
Transform3D.h:824
Transform3D.h:825
Transform3D.h:826
Transform3D.h:827
Transform3D.h:828
Transform3D.h:829
Transform3D.h:830
Transform3D.h:831
Transform3D.h:832
Transform3D.h:833
Transform3D.h:834
Transform3D.h:835
Transform3D.h:836
Transform3D.h:837
Transform3D.h:838
Transform3D.h:839
Transform3D.h:840
Transform3D.h:841
Transform3D.h:842
Transform3D.h:843
Transform3D.h:844
Transform3D.h:845
Transform3D.h:846
Transform3D.h:847
Transform3D.h:848
Transform3D.h:849
Transform3D.h:850
Transform3D.h:851
Transform3D.h:852
Transform3D.h:853
Transform3D.h:854
Transform3D.h:855
Transform3D.h:856
Transform3D.h:857
Transform3D.h:858
Transform3D.h:859
Transform3D.h:860
Transform3D.h:861
Transform3D.h:862
Transform3D.h:863
Transform3D.h:864
Transform3D.h:865
Transform3D.h:866
Transform3D.h:867
Transform3D.h:868
Transform3D.h:869
Transform3D.h:870
Transform3D.h:871