mi32/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.16 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: trans3d.h_v $
 * 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_CTRLPT_H
#include <mi32/ctrlpt.h>
#endif

#ifndef  INC_STRING_H
#include <string.h>     //! Includes defn for memcpy()
#define  INC_STRING_H
#endif

#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
#endif

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

class TRANS3D {

public:

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

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

   //! CONSTRUCTION / DESTRUCTION

   //! Default constructor
   TRANS3D (
      );

   //! Copy constructor
   TRANS3D (
      const TRANS3D& rhs
      ) :
      m_DoHomogeneous(rhs.m_DoHomogeneous)
      {
      memcpy(m_fwd,rhs.m_fwd,sizeof(m_fwd));
      memcpy(m_inv,rhs.m_inv,sizeof(m_inv));
      }

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

   //! Destructor
   ~TRANS3D (
      ) {
      }

   //! OPERATORS

   //! Assignment
   TRANS3D& operator= (
      const TRANS3D& rhs
      ) {
      memcpy(m_fwd,rhs.m_fwd,sizeof(m_fwd));
      memcpy(m_inv,rhs.m_inv,sizeof(m_inv));
      m_DoHomogeneous = rhs.m_DoHomogeneous;
      return (*this);
      }

   //! METHODS

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

   //! 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
      ) {
      ApplyOffset(point.x,point.y,point.z,inverse);
      return;
      }

   //! 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
      DPOINT3D opoint;
      ConvertForward(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      DPOINT3D opoint;
      ConvertInverse(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      DPOINT3DH opoint;
      ConvertForward(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      DPOINT3DH opoint;
      ConvertInverse(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      FPOINT3D opoint;
      ConvertForward(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      FPOINT3D opoint;
      ConvertInverse(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      FPOINT3DH opoint;
      ConvertForward(&ipoint,&opoint,1);
      return (opoint);
      }

   //! 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
      FPOINT3DH opoint;
      ConvertInverse(&ipoint,&opoint,1);
      return (opoint);
      }

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

   const MAT4X4& GetForward (
      ) const {                         
      return m_fwd;
      }

   const MAT4X4& GetInverse (
      ) const {                         
      return m_inv;
      }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   //! MEMBERS

   MAT4X4 m_fwd;
   MAT4X4 m_inv;
   bool m_DoHomogeneous;      //!< Need to perform homogenous transformation

   //! METHODS

   //! 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
      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
      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

---