mi32/trans3d.h

Go to the documentation of this file.

#ifndef  INC_MI32_TRANS3D_H
#define  INC_MI32_TRANS3D_H

#ifndef INC_MI32_STDDEFNS_H
#include <mi32/stddefns.h>
#endif

#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSIMPORT
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct CTRLPOINT3;
struct CTRLPOINT3D;
#endif // GENERATING_DOXYGEN_OUTPUT

//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

class GEOMLIBCLASSEXPORT TRANS3D {
   public:

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

      enum PLANE {
         PLANE_XY = 0,
         PLANE_XZ = 1,
         PLANE_YZ = 2
         };

      TRANS3D (
         );

      TRANS3D (
         const TRANS3D& rhs
         );

      TRANS3D (
         const TRANS3D& in1,
         const TRANS3D& in2
         );

      ~TRANS3D (
         );

      TRANS3D& operator= (
         const TRANS3D& rhs
         );

      void ApplyMatrices (
         const MAT4X4 fwd,                      
         const MAT4X4 inv                       
         );

      void ApplyOffset (
         double xoffset,                        
         double yoffset,                        
         double zoffset,                        
         bool inverse = false                   
         );

      void ApplyOffset (
         const DPOINT3D& point,                 
         bool inverse = false                   
         );

      void ApplyRotation (
         double angle,                          
         AXIS axis,                             
         bool inverse = false                   
         );

      void ApplyScale (
         double xscale,                         
         double yscale,                         
         double zscale,                         
         bool inverse = false                   
         );



      void ApplyShear (
         double shear1,                         
         double shear2,                         
         PLANE plane,                           
         bool inverse = false                   
         );

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

      DPOINT3D ConvertForward (
         const DPOINT3D ipoint                  
         ) const;                               

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

      DPOINT3D ConvertInverse (
         const DPOINT3D ipoint                  
         ) const;                               

      void ConvertForward (
         const DPOINT3DH *ipoints,              
         DPOINT3DH *opoints,                    
         INT32 numpoints                        
         ) const;

      DPOINT3DH ConvertForward (
         const DPOINT3DH ipoint                 
         ) const;                               

      void ConvertInverse (
         const DPOINT3DH *ipoints,              
         DPOINT3DH *opoints,                    
         INT32 numpoints                        
         ) const;

      DPOINT3DH ConvertInverse (
         const DPOINT3DH ipoint                 
         ) const;                               

      void ConvertForward (
         const FPOINT3D *ipoints,               
         FPOINT3D *opoints,                     
         INT32 numpoints                        
         ) const;

      FPOINT3D ConvertForward (
         const FPOINT3D ipoint                  
         ) const;                               

      void ConvertInverse (
         const FPOINT3D *ipoints,               
         FPOINT3D *opoints,                     
         INT32 numpoints                        
         ) const;

      FPOINT3D ConvertInverse (
         const FPOINT3D ipoint                  
         ) const;                               

      void ConvertForward (
         const FPOINT3DH *ipoints,              
         FPOINT3DH *opoints,                    
         INT32 numpoints                        
         ) const;

      FPOINT3DH ConvertForward (
         const FPOINT3DH ipoint                 
         ) const;                               

      void ConvertInverse (
         const FPOINT3DH *ipoints,              
         FPOINT3DH *opoints,                    
         INT32 numpoints                        
         ) const;

      FPOINT3DH ConvertInverse (
         const FPOINT3DH ipoint                 
         ) const;                               

      void SetIdentity (
         );

      const MAT4X4& GetForward (
         ) const;

      const MAT4X4& GetInverse (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MAT4X4 m_fwd;
      MAT4X4 m_inv;
      bool m_DoHomogeneous;      

      void ApplyMatrix (
         const MAT4X4 mat,                
         bool inverse                     
         );
      void ChkNeedHomo ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-----------------------------------------------------------------------------
//-----------------------------------------------------------------------------

extern "C" {
   GEOMLIBEXPORT int FindBestTrans3D (
      int NumPoints,                   
      const CTRLPOINT3D* cp,           
      MAT4X4 forward,                  
      MAT4X4 inverse
      );
   
   GEOMLIBEXPORT int FindBestTrans3D3 (
      int NumPoints,                   
      const CTRLPOINT3 *cp3,           
      MAT4X4 forward,                  
      MAT4X4 inverse
      );

   GEOMLIBEXPORT void trans3dinit (
      MAT4X4,                          
      MAT4X4
      );
   
   GEOMLIBEXPORT void trans3d (
      double ix,                       
      double iy,                       
      double iz,                       
      MAT4X4 TransMat,                 
      double *ox,                      
      double *oy,                      
      double *oz                       
      );
   
   GEOMLIBEXPORT void trans3dshift (
      MAT4X4 m,                        
      MAT4X4 n,
      double dx,                       
      double dy,                       
      double dz                        
      );
   
   GEOMLIBEXPORT void trans3dscale (
      MAT4X4 m,                        
      MAT4X4 n,
      double sx,                       
      double sy,                       
      double sz                        
      );

   GEOMLIBEXPORT void trans3drot (
      MAT4X4 m,                        
      MAT4X4 n,
      double z_axis,                   
      double x_axis,                   
      double y_axis                    
      );
   }

#endif

---