mi32/trans2daffine.h

Go to the documentation of this file.

#ifndef  INC_MI32_TRANS2DAFFINE_H
#define  INC_MI32_TRANS2DAFFINE_H

#ifndef  INC_MI32_TRANS2D_H
#include <mi32/trans2d.h>
#endif

#ifndef  INC__MI32_RECT_H
#include <mi32/rect.h>
#endif

#ifndef  INC_MEMORY_H
#include <memory.h>           // For memset/memcpy
#define  INC_MEMORY_H
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
#ifdef GEOMDLL
   #define LIBEXPORT MI_DLLEXPORT
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define LIBEXPORT MI_DLLIMPORT
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

// Forward declarations
class TRANS2D_MAPGEN;
class FILEPATH;

#endif // GENERATING_DOXYGEN_OUTPUT


//-------------------------------------------------------------------------------------------------------------------
class CLASSLIBEXPORT TRANS2D_AFFINE {

   public:

      enum AXIS {
         AXIS_X = 0,
         AXIS_Y = 1
         };

      TRANS2D_AFFINE (
         ) { trans2dinit(m_fwd,m_inv); }

      TRANS2D_AFFINE (
         const TRANS2D_AFFINE& rhs
         ) {
         memcpy(m_fwd,rhs.m_fwd,sizeof(MAT3X3));
         memcpy(m_inv,rhs.m_inv,sizeof(MAT3X3));
         }

      TRANS2D_AFFINE (
         const MAT3X3 matrix,             
         bool IsForward = true            
         ) {
         if (IsForward) {
            memcpy(m_fwd,matrix,sizeof(MAT3X3));
            trans2dfindinverse(m_fwd,m_inv);
            } 
         else {
            memcpy(m_inv,matrix,sizeof(MAT3X3));
            trans2dfindinverse(m_inv,m_fwd);
            }
         }

      TRANS2D_AFFINE (
         const MAT3X3 fwd,                
         const MAT3X3 inv                 
         ) {
         memcpy(m_fwd,fwd,sizeof(MAT3X3));
         memcpy(m_inv,inv,sizeof(MAT3X3));
         }

      TRANS2D_AFFINE (
         const TRANS2D_AFFINE& trans1,    
         const TRANS2D_AFFINE& trans2     
         ) { trans2dmatrix2(m_fwd,m_inv,trans1.m_fwd,trans1.m_inv,trans2.m_fwd,trans2.m_inv); }

      TRANS2D_AFFINE (
         const CTRLPOINT *cp,             
         int numpoints,                   
         bool invert = false              
         ) { FindBestTrans2DA(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0); }

      TRANS2D_AFFINE (
         const CTRLPOINT3 *cp,            
         int numpoints,                   
         bool invert = false              
         ) { FindBestTrans2D3A(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0); }

      ~TRANS2D_AFFINE (
         ) {}

      TRANS2D_AFFINE& operator= (
         const TRANS2D_AFFINE& rhs
         ) {
         if (this != &rhs) {
            memcpy(m_fwd,rhs.m_fwd,sizeof(MAT3X3));
            memcpy(m_inv,rhs.m_inv,sizeof(MAT3X3));
            }
         return (*this);
         }

      void ApplyOffset (
         double xoffset,                  
         double yoffset                   
         ) { trans2dshift(m_fwd,m_inv,xoffset,yoffset); }

      void ApplyOffset (
         const DPOINT2D& offset           
         ) { trans2dshift(m_fwd,m_inv,offset.x,offset.y); }

      void ApplyOffsetReverse (
         double xoffset,                  
         double yoffset                   
         ) { trans2dshift(m_inv,m_fwd,xoffset,yoffset); }

      void ApplyOffsetReverse (
         const DPOINT2D& offset           
         ) { trans2dshift(m_inv,m_fwd,offset.x,offset.y); }

      void ApplyRotation (
         double angle                     
         ) { trans2drot(m_fwd,m_inv,angle); }

      void ApplyScale (
         double scale                     
         ) { trans2dscale(m_fwd,m_inv,scale,scale); }

      void ApplyScale (
         double xscale,                   
         double yscale                    
         ) { trans2dscale(m_fwd,m_inv,xscale,yscale); }

      void ApplyScale (
         const DPOINT2D &scale            
         ) { trans2dscale(m_fwd,m_inv,scale.x,scale.y); }

      void ApplyScaleReverse (
         double xscale,                   
         double yscale                    
         ) { trans2dscale(m_inv,m_fwd,xscale,yscale); }

      void ApplyScaleReverse (
         const DPOINT2D &scale            
         ) { trans2dscale(m_inv,m_fwd,scale.x,scale.y); }

      void ApplyShear (
         double angle,                    
         AXIS axis                        
         ) { trans2dshear(m_fwd,m_inv,angle,static_cast<int>(axis)); }

      void Combine (
         const TRANS2D_AFFINE& trans1     
         ) {
         trans2dmatrix(m_fwd,trans1.m_fwd);
         trans2dmatrix(m_inv,trans1.m_inv);
         }

      void Combine (
         const TRANS2D_AFFINE& trans1,    
         const TRANS2D_AFFINE& trans2     
         ) { trans2dmatrix2(m_fwd,m_inv,trans1.m_fwd,trans1.m_inv,trans2.m_fwd,trans2.m_inv); }

      void CombineForwardReverse (
         const TRANS2D_AFFINE& trans1,    
         const TRANS2D_AFFINE& trans2     
         ) { trans2dmatrix2(m_fwd,m_inv,trans1.m_fwd,trans1.m_inv,trans2.m_inv,trans2.m_fwd); }

      DPOINT2D ConvertForward (
         double x,                        
         double y                         
         ) const { return (DPOINT2D(trans2dx(x,y,m_fwd),trans2dy(x,y,m_fwd))); }

      void ConvertForward (
         double x,                        
         double y,                        
         double& ox,                      
         double& oy                       
         ) const { ox = trans2dx(x,y,m_fwd); oy = trans2dy(x,y,m_fwd); }

      DPOINT2D ConvertForward (
         const DPOINT2D& ipoint           
         ) const { return (DPOINT2D(trans2dx(ipoint.x,ipoint.y,m_fwd),trans2dy(ipoint.x,ipoint.y,m_fwd))); }

      DPOINT3D ConvertForward (
         const DPOINT3D& ipoint           
         ) const { return (DPOINT3D(trans2dx(ipoint.x,ipoint.y,m_fwd),trans2dy(ipoint.x,ipoint.y,m_fwd),ipoint.z)); }

      void ConvertForward (
         const DPOINT2D *ipoints,         
         DPOINT2D *opoints,               
         INT32 NumPoints                  
         ) const;

      void ConvertForward (
         const DPOINT3D *ipoints,         
         DPOINT3D *opoints,               
         INT32 NumPoints                  
         ) const;

      void ConvertForward (
         const double *ipoints,           
         double *opoints,                 
         INT32 NumPoints,                 
         int NumDim                       
         ) const;

      DRECT2D ConvertForward (
         const DRECT2D& irect             
         ) const {
         DRECT2D orect;
         ConvertForward(irect,orect);
         return (orect);
         }

      void ConvertForward (
         const DRECT2D& irect,            
         DRECT2D& orect                   
         ) const;

      DPOINT2D ConvertInverse (
         double x,                        
         double y                         
         ) const { return (DPOINT2D(trans2dx(x,y,m_inv),trans2dy(x,y,m_inv))); }

      void ConvertInverse (
         double x,                        
         double y,                        
         double& ox,                      
         double& oy                       
         ) const { ox = trans2dx(x,y,m_inv); oy = trans2dy(x,y,m_inv); }

      DPOINT2D ConvertInverse (
         const DPOINT2D& ipoint           
         ) const { return (DPOINT2D(trans2dx(ipoint.x,ipoint.y,m_inv),trans2dy(ipoint.x,ipoint.y,m_inv))); }

      DPOINT3D ConvertInverse (
         const DPOINT3D& ipoint           
         ) const { return (DPOINT3D(trans2dx(ipoint.x,ipoint.y,m_inv),trans2dy(ipoint.x,ipoint.y,m_inv),ipoint.z)); }

      void ConvertInverse (
         const DPOINT2D *ipoints,         
         DPOINT2D *opoints,               
         INT32 NumPoints                  
         ) const;

      void ConvertInverse (
         const DPOINT3D *ipoints,         
         DPOINT3D *opoints,               
         INT32 NumPoints                  
         ) const;

      void ConvertInverse (
         const double *ipoints,           
         double *opoints,                 
         INT32 NumPoints,                 
         int NumDim                       
         ) const;

      DRECT2D ConvertInverse (
         const DRECT2D& irect             
         ) const {
         DRECT2D orect;
         ConvertInverse(irect,orect);
         return (orect);
         }

      void ConvertInverse (
         const DRECT2D& irect,            
         DRECT2D& orect                   
         ) const;

      void DisectForward (
         double *xscale,                  
         double *yscale,                  
         double *rotangle = 0,            
         double *shearangle = 0           
         ) const { DisectTrans2D(m_fwd,xscale,yscale,rotangle,shearangle); }
         
      void DisectInverse (
         double *xscale,                  
         double *yscale,                  
         double *rotangle = 0,            
         double *shearangle = 0           
         ) const { DisectTrans2D(m_inv,xscale,yscale,rotangle,shearangle); }

      void GetMatrices (
         MAT3X3 fwd,                      
         MAT3X3 inv                       
         ) const { memcpy(fwd,m_fwd,sizeof(MAT3X3)); memcpy(inv,m_inv,sizeof(MAT3X3)); }

      void GetValuesForward (
         double& xscale,                  
         double& xrot,                    
         double& xpos,                    
         double& yscale,                  
         double& yrot,                    
         double& ypos                     
         ) const {
         xscale = m_fwd[0][0]; xrot = m_fwd[0][1]; xpos = m_fwd[0][2];
         yscale = m_fwd[1][1]; yrot = m_fwd[1][0]; ypos = m_fwd[1][2];
         }

      bool HasReverseOrientation (
         ) const { return ((m_fwd[0][0]*m_fwd[1][1]-m_fwd[0][1]*m_fwd[1][0]) < 0); }

      bool IsEqual (
         const TRANS2D_AFFINE& rhs
         ) const {
         return (!memcmp(m_fwd,rhs.m_fwd,sizeof(MAT3X3)) && !memcmp(m_inv,rhs.m_inv,sizeof(MAT3X3)));
         }

      bool IsEquivalentTo (
         const TRANS2D_AFFINE& rhs
         ) const {
         for (int i = 0;(i < 3);++i) {
            for (int j = 0;(j < 3);++j) {
               if (fabs(m_fwd[i][j] - rhs.m_fwd[i][j]) > 0.0000001) return (false);
               }
            }
         return (true);
         }

      bool IsIdentity (
         ) const {
         return (m_fwd[0][0] == 1.0 && m_fwd[1][1] == 1.0 && m_fwd[0][1] == 0.0 && m_fwd[0][2] == 0.0 && m_fwd[1][0] == 0.0 && m_fwd[1][2] == 0.0);
         }

      void ReverseDirection (
         ) {
         MAT3X3 temp;
         memcpy(temp,m_fwd,sizeof(MAT3X3));
         memcpy(m_fwd,m_inv,sizeof(MAT3X3));
         memcpy(m_inv,temp,sizeof(MAT3X3));
         }

      ERRVALUE SetCtrlPoint (
         const CTRLPOINT *cp,             
         int numpoints,                   
         bool invert = false              
         ) { return (FindBestTrans2DA(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0)); }
         
      ERRVALUE SetCtrlPoint (
         const CTRLPOINT3 *cp,            
         int numpoints,                   
         bool invert = false              
         ) { return (FindBestTrans2D3A(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0)); }
         
      void SetIdentity (
         ) { trans2dinit(m_fwd,m_inv); }

      void SetMatrices (
         const MAT3X3 fwd,                
         const MAT3X3 inv                 
         ) { memcpy(m_fwd,fwd,sizeof(MAT3X3)); memcpy(m_inv,inv,sizeof(MAT3X3)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MAT3X3 m_fwd;                       
      MAT3X3 m_inv;                       

      friend class TRANS2D_MAPGEN;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

inline bool operator== (
   const TRANS2D_AFFINE& lhs,
   const TRANS2D_AFFINE& rhs
   ) { return (lhs.IsEqual(rhs)); }

inline bool operator!= (
   const TRANS2D_AFFINE& lhs,
   const TRANS2D_AFFINE& rhs
   ) { return (!lhs.IsEqual(rhs)); }


LIBEXPORT int Trans2DReadArcWorld (
   const FILEPATH& filepath,           
   TRANS2D_AFFINE& Affine              
   );


#undef LIBEXPORT
#undef CLASSLIBEXPORT

#endif   // INC_MI32_TRANS2DAFFINE_H

---