trans3d.h

Go to the documentation of this file.

/**
 * \file trans3d.h <mi32/trans3d.h>
 * \brief Definitions for 3-D transformation functions
 *
 *    This header file requires C++
 *
 * \if NODOC
 * $Id: trans3d.h_v 1.18 2004/06/14 16:36:01 mju Exp $
 *
 * $Log: trans3d.h_v $
 * Revision 1.18  2004/06/14 16:36:01  mju
 * Use const in findBestTrans3D.
 *
 * Revision 1.17  2004/01/08 18:18:52  scowan
 * Moved trans3d class to geom.dll.
 *
 * Revision 1.16  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.15  2003/03/12 20:45:01  vdronov
 * added GetForward and GetInverse
 *
 * Revision 1.14  2002/11/27 21:40:02  vdronov
 * converrsion for FPOINT3D and FPOINT3DH added
 *
 * Revision 1.13  2002/11/20 22:02:44  vdronov
 * methods for  DPOINT3DH added
 *
 * Revision 1.12  2000/10/04 20:36:38  msmith
 * Genitor documentation.
 *
 * Revision 1.11  2000/10/03 21:39:42  mju
 * Include string.h for memcpy() prototype.
 *
 * Revision 1.10  1999/08/23 15:33:02  dwilliss
 * Don't leave dangling commas in enums.  Macintosh will hate you if you do.
 *
 * Revision 1.9  1999/08/18 15:07:43  mju
 * Comment out unused ApplyScale methods so will hopefully work on HP.
 *
 * Revision 1.8  1999/04/29  21:42:19  mju
 * Change TRANS3D to class.
 *
 * \endif
**/

#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

//-----------------------------------------------------------------------------
//!      TRANS3D class
//-----------------------------------------------------------------------------

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
         };

      //! Default constructor
      TRANS3D (
         );

      //! Copy constructor
      TRANS3D (
         const TRANS3D& rhs
         );

      //! Construct as combination of two transformations
      TRANS3D (
         const TRANS3D& in1,
         const TRANS3D& in2
         );

      //! Destructor
      ~TRANS3D (
         );

      //! Assignment
      TRANS3D& operator= (
         const TRANS3D& rhs
         );

      //! Apply forward/inverse 3D matrices to transformation
      void ApplyMatrices (
         const MAT4X4 fwd,                      //!< Forward transformation matrix
         const MAT4X4 inv                       //!< Inverse transformation matrix
         );

      //! Apply coordinate offset
      void ApplyOffset (
         double xoffset,                        //!< X offset
         double yoffset,                        //!< Y offset
         double zoffset,                        //!< Z offset
         bool inverse = false                   //!< Apply in inverse direction
         );

      //! Apply coordinate offset
      void ApplyOffset (
         const DPOINT3D& point,                 //!< Offset as X/Y/Z
         bool inverse = false                   //!< Apply in inverse direction
         );

      //! Apply rotation
      void ApplyRotation (
         double angle,                          //!< Angle in radians
         AXIS axis,                             //!< Axis of rotation
         bool inverse = false                   //!< Apply in inverse direction
         );

      //! Apply scale
      void ApplyScale (
         double xscale,                         //!< X scale
         double yscale,                         //!< Y scale
         double zscale,                         //!< Z scale
         bool inverse = false                   //!< Apply in inverse direction
         );

      //! Apply equal scale to all axes
   //!   void ApplyScale (
   //!      double scale,                          // Scale
   //!      bool inverse = false                   // Apply in inverse direction
   //!      ) {
   //!      ApplyScale(scale,scale,scale,inverse);
   //!      return;
   //!      }

      //! Apply scale
   //!   void ApplyScale (
   //!      const DPOINT3D& point,                 // X/Y/Z scale
   //!      bool inverse = false                   // Apply in inverse direction
   //!      ) {
   //!      ApplyScale(point.x,point.y,point.z,inverse);
   //!      return;
   //!      }

      //! Apply shear in given plane
      void ApplyShear (
         double shear1,                         //!< First axis shear in radians
         double shear2,                         //!< Second axis shear in radians
         PLANE plane,                           //!< Shear plane
         bool inverse = false                   //!< Apply in inverse direction
         );

      //! Perform forward conversion on DPOINT3D array
      void ConvertForward (
         const DPOINT3D *ipoints,               //!< Source point array
         DPOINT3D *opoints,                     //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform forward conversion on single 3D point
      DPOINT3D ConvertForward (
         const DPOINT3D ipoint                  //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform inverse conversion on DPOINT3D array
      void ConvertInverse (
         const DPOINT3D *ipoints,               //!< Source point array
         DPOINT3D *opoints,                     //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform inverse conversion on single 3D point
      DPOINT3D ConvertInverse (
         const DPOINT3D ipoint                  //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform forward conversion on DPOINT3DH array
      void ConvertForward (
         const DPOINT3DH *ipoints,              //!< Source point array
         DPOINT3DH *opoints,                    //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform forward conversion on single 3DH point
      DPOINT3DH ConvertForward (
         const DPOINT3DH ipoint                 //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform inverse conversion on DPOINT3DH array
      void ConvertInverse (
         const DPOINT3DH *ipoints,              //!< Source point array
         DPOINT3DH *opoints,                    //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform inverse conversion on single 3DH point
      DPOINT3DH ConvertInverse (
         const DPOINT3DH ipoint                 //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform forward conversion on FPOINT3D array
      void ConvertForward (
         const FPOINT3D *ipoints,               //!< Source point array
         FPOINT3D *opoints,                     //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform forward conversion on single 3D point
      FPOINT3D ConvertForward (
         const FPOINT3D ipoint                  //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform inverse conversion on FPOINT3D array
      void ConvertInverse (
         const FPOINT3D *ipoints,               //!< Source point array
         FPOINT3D *opoints,                     //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform inverse conversion on single 3D point
      FPOINT3D ConvertInverse (
         const FPOINT3D ipoint                  //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform forward conversion on FPOINT3DH array
      void ConvertForward (
         const FPOINT3DH *ipoints,              //!< Source point array
         FPOINT3DH *opoints,                    //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform forward conversion on single 3DH point
      FPOINT3DH ConvertForward (
         const FPOINT3DH ipoint                 //!< Point to convert
         ) const;                               //! Returns converted point

      //! Perform inverse conversion on FPOINT3DH array
      void ConvertInverse (
         const FPOINT3DH *ipoints,              //!< Source point array
         FPOINT3DH *opoints,                    //!< Destination point array
         INT32 numpoints                        //!< Number of points to convert
         ) const;

      //! Perform inverse conversion on single 3DH point
      FPOINT3DH ConvertInverse (
         const FPOINT3DH ipoint                 //!< Point to convert
         ) const;                               //! Returns converted point

      //! Set transformation to identity
      void SetIdentity (
         );

      const MAT4X4& GetForward (
         ) const;

      const MAT4X4& GetInverse (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MAT4X4 m_fwd;
      MAT4X4 m_inv;
      bool m_DoHomogeneous;      //!< Need to perform homogenous transformation

      //! Apply general matrix
      void ApplyMatrix (
         const MAT4X4 mat,                //!< Matrix to apply
         bool inverse                     //!< Inverse flag
         );
      //! Check if need to do homogenous transformation
      void ChkNeedHomo ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-----------------------------------------------------------------------------
//!      Function prototypes
//-----------------------------------------------------------------------------

extern "C" {
   //! FindBestTrans3D - Find "best" 3-D affine transformation given set of control points
   GEOMLIBEXPORT int FindBestTrans3D (
      int NumPoints,                   //!< Number of control points
      const CTRLPOINT3D* cp,           //!< Set of control points
      MAT4X4 forward,                  //!< Transformation matrices
      MAT4X4 inverse
      );
   
   //! FindBestTrans3D3 - Find "best" 3-D affine transformation given a CTRLPOINT array
   GEOMLIBEXPORT int FindBestTrans3D3 (
      int NumPoints,                   //!< Number of control points
      const CTRLPOINT3 *cp3,           //!< Array of control points
      MAT4X4 forward,                  //!< Transformation matrices
      MAT4X4 inverse
      );

   //! Initialize 3-D affine transformation
   GEOMLIBEXPORT void trans3dinit (
      MAT4X4,                          //!< Transformation matrices
      MAT4X4
      );
   
   //! Perform 3-D affine transformation on a point
   GEOMLIBEXPORT void trans3d (
      double ix,                       //!< Input x
      double iy,                       //!< Input y
      double iz,                       //!< Input z
      MAT4X4 TransMat,                 //!< Transformation matrix
      double *ox,                      //!< Output x
      double *oy,                      //!< Output y
      double *oz                       //!< Output z
      );
   
   //! Apply offsets to a 3-D affine transformation
   GEOMLIBEXPORT void trans3dshift (
      MAT4X4 m,                        //!< Matrices of transformation
      MAT4X4 n,
      double dx,                       //!< X offset
      double dy,                       //!< Y offset
      double dz                        //!< Z offset
      );
   
   //! Apply a scale change to a 3-D affine transformation
   GEOMLIBEXPORT void trans3dscale (
      MAT4X4 m,                        //!< Matrices of transformation
      MAT4X4 n,
      double sx,                       //!< X scale
      double sy,                       //!< Y scale
      double sz                        //!< Z scale
      );

   //! Apply rotation to a 3-D affine transformation
   GEOMLIBEXPORT void trans3drot (
      MAT4X4 m,                        //!< Matrices of transformation
      MAT4X4 n,
      double z_axis,                   //!< X axis
      double x_axis,                   //!< Y axis
      double y_axis                    //!< Z axis
      );
   }

#endif

---