// @(#)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,
      which must support operator()(i,j) for write access to elements
      (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