library: libMathCore
#include "Transform3D.h"

ROOT::Math::Transform3D

class description - header file - source file - inheritance tree (.pdf)

class ROOT::Math::Transform3D

Inheritance Chart:
ROOT::Math::Transform3D
 

    protected:

      void AssignFrom(const ROOT::Math::Rotation3D& r, const ROOT::Math::Transform3D::Vector& v)
      void AssignFrom(const ROOT::Math::Rotation3D& r)
      void AssignFrom(const ROOT::Math::Transform3D::Vector& v)
      void SetIdentity()

    public:

                                                                                                               Transform3D()
                                                                                                               Transform3D(const ROOT::Math::Rotation3D& r, const ROOT::Math::Transform3D::Vector& v)
                                                                                                               Transform3D(const ROOT::Math::Transform3D::Vector& v, const ROOT::Math::Rotation3D& r)
                                                                                                               Transform3D(const ROOT::Math::Rotation3D& r)
                                                                                                               Transform3D(const ROOT::Math::AxisAngle& r)
                                                                                                               Transform3D(const ROOT::Math::EulerAngles& r)
                                                                                                               Transform3D(const ROOT::Math::Quaternion& r)
                                                                                                               Transform3D(const ROOT::Math::RotationX& r)
                                                                                                               Transform3D(const ROOT::Math::RotationY& r)
                                                                                                               Transform3D(const ROOT::Math::RotationZ& r)
                                                                                                               Transform3D(const ROOT::Math::Transform3D::Vector& v)
                                                                                                               Transform3D(const ROOT::Math::Transform3D::Point& fr0, const ROOT::Math::Transform3D::Point& fr1, const ROOT::Math::Transform3D::Point& fr2, const ROOT::Math::Transform3D::Point& to0, const ROOT::Math::Transform3D::Point& to1, const ROOT::Math::Transform3D::Point& to2)
                                                                                                               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)
                                                                                       ROOT::Math::Transform3D operator*(const ROOT::Math::Transform3D& t) const
                                                                                       ROOT::Math::Transform3D Inverse() const
                                                                                                               Transform3D(double* begin, double* end)
                                                                                                               Transform3D(const ROOT::Math::Transform3D&)
                                                                                                               ~Transform3D()
                                                                                                          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
                                                                                                          void GetComponents(double* begin, double* end) const
                                                                                                          void GetDecomposition(ROOT::Math::Rotation3D& r, ROOT::Math::Transform3D::Vector& v) const
                                                                                                          void Invert()
                                                                                                          bool operator!=(const ROOT::Math::Transform3D& rhs)
                                                                                ROOT::Math::Transform3D::Point operator()(const ROOT::Math::Transform3D::Point& p) const
                                                                               ROOT::Math::Transform3D::Vector operator()(const ROOT::Math::Transform3D::Vector& v) const
                                                                                           ROOT::Math::Plane3D operator()(const ROOT::Math::Plane3D& plane) const
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator()(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& q) const
          ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::PositionVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
      ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag> operator*(const ROOT::Math::DisplacementVector3D<ROOT::Math::Cartesian3D<double>,ROOT::Math::DefaultCoordinateSystemTag>& v) const
                                                     ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> > operator*(const ROOT::Math::LorentzVector<ROOT::Math::PxPyPzE4D<double> >& v) const
                                                                                      ROOT::Math::Transform3D& operator*=(const ROOT::Math::Transform3D& t)
                                                                                      ROOT::Math::Transform3D& operator=(const ROOT::Math::Transform3D&)
                                                                                                          bool operator==(const ROOT::Math::Transform3D& rhs)
                                                                                                          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)
                                                                                                          void SetComponents(double* begin, double* end)

Data Members

    private:

      double fM[12]  

    public:

      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kXX  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kXY  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kXZ  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kDX  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kYX  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kYY  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kYZ  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kDY  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kZX  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kZY  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kZZ  
      static const ROOT::Math::Transform3D::ETransform3DMatrixIndex kDZ

Class Description

Transform3D()


 SetIdentity()




 Transform3D(IT begin, IT end)




 SetComponents(begin,end)




 Transform3D( const Rotation3D & r, const Vector & v)




 AssignFrom( r, v )




 Transform3D( const Vector & v, const Rotation3D & r)




 AssignFrom( r, r(v) )


 is equivalent from having first the rotation and then the translation vector rotated



explicit Transform3D( const Rotation3D & r)




 AssignFrom(r)




explicit Transform3D( const AxisAngle & r)


 convenience methods for the other rotations (cannot use templates for conflict with LA)



explicit Transform3D( const EulerAngles & r)




explicit Transform3D( const Quaternion & r)




explicit Transform3D( const RotationX & r)


 TO DO: implement direct methods for axial rotations without going through Rotation3D



explicit Transform3D( const RotationY & r)




explicit Transform3D( const RotationZ & r)




explicit Transform3D( const DisplacementVector3D<CoordSystem,Tag> & v)




explicit Transform3D( const Vector & v)




 Transform3D( const ARotation & r, const DisplacementVector3D<CoordSystem,Tag> & v)




 Transform3D(const DisplacementVector3D<CoordSystem,Tag> & v , const ARotation & r)




 SetComponents(m)




void GetComponents(IT begin, IT end)




void GetDecomposition(Rotation3D &r, Vector &v)




void Invert()




Transform3D Inverse()




return ! operator==(rhs)







Last update: Tue Jul 11 11:47:24 2006









ROOT page - Class index - Class Hierarchy - Top of the page









This page has been automatically generated. If you have any comments or suggestions about the page layout send a mail to ROOT support, or contact the developers with any questions or problems regarding ROOT.