dtk_transfo.hpp

Go to the documentation of this file.

#ifndef __DTK_TRANSFO_HPP__
#define __DTK_TRANSFO_HPP__
 
#include "struct/str_def.h"
#include "util/BaseTypes/dtk_object.hpp"
#include "util/BaseTypes/dtk_pnt.hpp"
#include "util/BaseTypes/dtk_dir.hpp"
#include "util/BaseTypes/dtk_matrix.hpp"
#include "def/define.h"
 
//! \ingroup base_types
//! \class Dtk_transfo 
//! \brief This is the Transformation dedicated class.
//! \brief A transformation a matrix is a basis : it contain a point, 3 vectors X,Y,Z, and a global scale.
//! \brief Note that the implementation allow you to unnormalize the vectors if really needed (distortion matrix), but it is suggested that the X,Y,Z vectors are normalized, and the scale parameter define the global scale
//!
//!  This class lets you use transformation.
class Dtk_transfo:public Dtk_Object
{
protected:
     //enum { _typeID = DTK_TYPE_TRANSFO }; 
     Dtk_dir v[ 3 ];
     Dtk_pnt o;
     double sc;
     void _init();
     void _copy( const Dtk_transfo& s );
     void _reset();
public:
 
     //downcasting
     Dtk_Int32 DtkDynamicType( const Dtk_Int32& inId );
     static Dtk_transfo* DtkDynamicCast( Dtk_Object * s );
 
     //! \CreateBase
     static Dtk_SmartPtr<Dtk_transfo> Create();
     //! \deprecated use Create instead
     SetAsDeprecated( "2026.4", "Use Create instead" )
     static Dtk_SmartPtr<Dtk_transfo> create();
     //! \CreateCopy
     static Dtk_SmartPtr<Dtk_transfo> Create( const Dtk_transfo& );
     //! \deprecated use Create instead
     SetAsDeprecated( "2026.4", "Use Create instead" )
     static Dtk_SmartPtr<Dtk_transfo> create( const Dtk_transfo& );
     //! \brief default constructor
     Dtk_transfo();
     //! \brief create a transfo from a double*
     //! \param[in] d array of double
     //! \param[in] typefill method to fill (see below)
     //! \brief 0 (default) : 13 elements : Xx,Xy,Xz,Yx,Yy,Yz,Zx,Zy,Zz,Ox,Oy,Oz,GlobalScale
     Dtk_transfo( Dtk_Double64* d, Dtk_Int32 typefill = 0 );
     //! \brief copy constructor
     //! \param[in] m the matrix to be copied
     //!
     //! \warning m must be a 4x4 or 4x3 Dtk_matrix
     Dtk_transfo( const Dtk_matrix& m );
     //! \brief Full featured constructor
     //! \param[in] X the X direction.
     //! \param[in] Y the Y direction.
     //! \param[in] Z the Z direction.
     //! \param[in] O the Origin.
     //! \param[in] scale the scale factor : default is 1.0
     Dtk_transfo( const Dtk_dir& X, const Dtk_dir& Y, const Dtk_dir& Z, const Dtk_pnt& O, const Dtk_Double64& scale = 1.0 );
     //! \brief Destructor
     //!
     ~Dtk_transfo();
     //! \brief Compare 2 Dtk_transfo matrix
     //! \param[in] in the Dtk_transfo to test with this.
     //! \return 1 if equal, 0 if not.
     //!
     int operator ==( const Dtk_transfo& in ) const;
     //! \brief Is transformation Identity
     //! \return 1 if is identity 0 if not.
     //!
     int is_identity() const;
 
     //! \brief Is normalized
     //! \return 1 if rotation vector are normalized 0 if not.
     //!
     Dtk_bool IsNormalized( const Dtk_Double64 &inTol = DTK_TOLERANCE ) const;
 
     //! \brief Is direct
     //! \return 1 if transformation is direct 0 if not.
     //!
     Dtk_bool IsDirect() const;
 
     //! \brief Obsolete : use getScale instead.
     //!
     double scale() const;
     //! \brief Retrieves the scale factor.
     //! \return the scale factor.
     //!
     const double& getScale() const;
     //! \brief Set a new scale
     //! \param[in] scale the new scale.
     //! \return the scale factor (get/set).
     //!
     void setScale( Dtk_Double64 scale );
     //Dtk_pnt getO(); // deprecated.
     //Dtk_dir getVect(int n,bool normalize=false);  // deprecated.
     //! \brief Return the X vector
     //! \return the X Dtk_dir
     //!
     const Dtk_dir& getXdir() const;
     //! \brief Return the Y vector
     //! \return the Y Dtk_dir
     //!
     const Dtk_dir& getYdir() const;
     //! \brief Return the Z vector
     //! \return the Z Dtk_dir
     //!
     const Dtk_dir& getZdir() const;
     //! \brief Return the O center point of the Dtk_transfo (the center O of the basis)
     //! \return the O Dtk_pnt
     //!
     const Dtk_pnt& getOrigin() const;
     //! \brief Return the n component of the X vector
     //! \param[in] n coordinate of the X vector to return.
     //! \return the n component of the X vector
     //!
     const double& getXcomponent( Dtk_Int32 n ) const;
     //! \brief Return the n component of the Y vector
     //! \param[in] n coordinate of the Y vector to return.
     //! \return the n component of the Y vector
     //!
     const double& getYcomponent( Dtk_Int32 n ) const;
     //! \brief Return the n component of the Z vector
     //! \param[in] n coordinate of the Z vector to return.
     //! \return the n component of the Z vector
     //!
     const double& getZcomponent( Dtk_Int32 n ) const;
     //! \brief Return the n component of the O center point
     //! \param[in] n coordinate of the O center point
     //! \return the n component of the O center point
     //!
     const double& getOcomponent( Dtk_Int32 n ) const;
     //! \brief Set a new X vector
     //! \param[in] X the new X vector
     //!
     void setXdir( const Dtk_dir& X );
     //! \brief Set a new Y vector
     //! \param[in] Y the new Y vector
     //!
     void setYdir( const Dtk_dir& Y );
     //! \brief Set a new Z vector
     //! \param[in] Z the new Z vector
     //!
     void setZdir( const Dtk_dir& Z );
     //! \brief Set a new O center point
     //! \param[in] O the new O point
     //!
     void setOrigin( const Dtk_pnt& O );
     //! \brief Set a new X vector by giving its components
     //! \param[in] x the x component of the X vector
     //! \param[in] y the y component of the X vector
     //! \param[in] z the z component of the X vector
     //!
     void setXdir( Dtk_Double64 x, Dtk_Double64 y, Dtk_Double64 z );
     //! \brief Set a new Y vector by giving its components
     //! \param[in] x the x component of the Y vector
     //! \param[in] y the y component of the Y vector
     //! \param[in] z the z component of the Y vector
     //!
     void setYdir( Dtk_Double64 x, Dtk_Double64 y, Dtk_Double64 z );
     //! \brief Set a new Z vector by giving its components
     //! \param[in] x the x component of the Z vector
     //! \param[in] y the y component of the Z vector
     //! \param[in] z the z component of the Z vector
     //!
     void setZdir( Dtk_Double64 x, Dtk_Double64 y, Dtk_Double64 z );
     //! \brief Set a new O center point by giving its components
     //! \param[in] x the x component of the O center point
     //! \param[in] y the y component of the O center point
     //! \param[in] z the z component of the O center point
     //!
     void setOrigin( Dtk_Double64 x, Dtk_Double64 y, Dtk_Double64 z );
     //! \brief Inverse the current Matrix
     //! \return 0 is success, -1 otherwise
     //!
     int inverse();
     //! \brief Allow to multiply 2 Dtk_transfo (matrix multiplication)
     //! \param[in] t1 first matrix to multiply
     //! \param[in] t2 second matrix to multiply
     //! \return the product t1*t2
     //!
     friend Dtk_transfo operator*( const Dtk_transfo&, const Dtk_transfo& );
     //! \brief Allow to multiply a Dtk_transfo by a point
     //! \param[in] M matrix to multiply
     //! \param[in] P point to multiply by
     //! \return the point M*P
     //!
     friend Dtk_pnt operator*( const Dtk_transfo& M, const Dtk_pnt& P );
     //! \brief Allow to multiply a Dtk_transfo by a vector
     //! \param[in] M matrix to multiply
     //! \param[in] P vector to multiply by
     //! \return the vector M*P
     //!
     friend Dtk_dir operator*( const Dtk_transfo& M, const Dtk_dir& P );
     //! \brief Multiply a matrix by a scalar number
     //! \brief whole datas are multiplied.
     //! \param[in] M matrix to multiply
     //! \param[in] d scalar
     //! \return the vector M*d
     //!
     friend Dtk_transfo operator*( const Dtk_transfo& M, const Dtk_Double64 d );
     //! \brief Divide a matrix by a scalar number
     //! \brief whole datas are divided.
     //! \param[in] M matrix to divide
     //! \param[in] d scalar
     //! \return the vector M/d
     //!
     friend Dtk_transfo operator/( Dtk_transfo& M, Dtk_Double64 d );
     //! \brief Allow to add 2 Dtk_transfo (matrix addition)
     //! \param[in] t1 first matrix to add
     //! \param[in] t2 second matrix to add
     //! \return the sum t1+t2
     //!
     friend Dtk_transfo operator+( const Dtk_transfo& t1, const Dtk_transfo& t2 );
     //! \brief Allow to substracte 2 Dtk_transfo (matrix difference)
     //! \param[in] t1 first matrix to substracte
     //! \param[in] t2 second matrix to substracte
     //! \return the difference t1-t2
     //!
     friend Dtk_transfo operator-( const Dtk_transfo& t1, const Dtk_transfo& t2 );
     //friend Dtk_transfo operator+=(Dtk_transfo& t1,const Dtk_transfo& t2);  // deprecated
     //friend Dtk_transfo operator-=(Dtk_transfo& t1,const Dtk_transfo& t2);  // deprecated
 
     //void Decompose_TS(Dtk_transfo& T,Dtk_transfo& S);  // deprecated
     //void Decompose_ST(Dtk_transfo& S,Dtk_transfo& T);  // deprecated
 
     //! \brief Translate the Dtk_transfo
     //! \brief Mathematics : just sum the given vector to the O center point.
     //! \param[in] V vector
     //!
     void addTranslate( const Dtk_dir& V );
     //! \brief Add a scale
     //! \brief Mathematics : just multiply the current scale by the given scale
     //! \param[in] scale scale to add.
     //!
     void addScale( Dtk_Double64 );
 
     //! \brief turn the basis represented by Dtk_transfo around a given vector with origin on (0.0, 0.0, 0.0) and scale equal to 1.0 
     //! \param[in] axis  axis of the ratation
     //! \param[in] angle angle of rotation (radian)
     //!
     void setAxisRotation( Dtk_dir axis, Dtk_Double64 angle );
 
     //void addRotate_axeX(double angle);
     //void addRotate_axeY(double angle);
     //! \brief 2D operation, not yet generalized but soon
     //! \brief turn the basis represented by Dtk_transfo around Z vector
     //! \param[in] angle angle of rotation (radian)
     //!
     void addRotate_axeZ( Dtk_Double64 angle );
 
     //! \brief Dtk_matrix conversion
     //! \return Dtk_matrix corresponding
     //!
     Dtk_matrix * GetDtkMatrix();
 
     void Normalize()
     {
          v[ 0 ].normalize();
          v[ 1 ].normalize();
          v[ 2 ].normalize();
 
     }
 
 
 
private:
     friend class Dtk_SmartPtr<Dtk_transfo>;
     friend std::ostream& operator<<( std::ostream& o, const Dtk_transfo& d );
     friend Dtk_transfo Dtk_transfoPtr_to_Dtk_transfo( Dtk_SmartPtr<Dtk_transfo>& t );
};
 
 
#endif //#ifndef __DTK_TRANSFO_HPP__