trans2dc.h

Go to the documentation of this file.

/**
 * \file trans2dc.h <mi32/trans2dc.h>
 * \brief Classes for 2D coordinate transformation
 *
 * \if NODOC
 * $Id: trans2dc.h_v 1.44 2004/11/15 23:26:48 dwilliss Exp $
 *
 * $Log: trans2dc.h_v $
 * Revision 1.44  2004/11/15 23:26:48  dwilliss
 * TRANS2D_AFFINE now exported from geom.dll.  4 methods no longer inlineable.
 *
 * Revision 1.43  2004/08/30 20:57:56  mju
 * Return error from SetCtrlPoint.
 *
 * Revision 1.42  2004/07/09 20:30:06  mju
 * Add mapgen IsInput/OutputTransIdentity.
 *
 * Revision 1.41  2004/07/07 22:02:07  mju
 * Return errvalue from getaffine.
 *
 * Revision 1.40  2004/06/24 20:39:55  mju
 * Add Apply...Reverse operations for affine.
 *
 * Revision 1.39  2004/06/22 15:30:55  mju
 * remove trans2d_carto as no longer used, replaced by spatref system.
 *
 * Revision 1.38  2004/06/18 21:48:09  mju
 * Remove GCTP references.
 * Support SPATREF.
 *
 * Revision 1.37  2004/03/04 17:55:47  scowan
 * Fixed new compiler warnings.
 *
 * Revision 1.36  2004/01/20 14:30:54  scowan
 * Added is equivalent to method for affine.
 *
 * Revision 1.35  2004/01/19 21:46:53  scowan
 * Added is identity method.
 *
 * Revision 1.34  2004/01/02 20:50:29  vdronov
 * add some methods
 *
 * Revision 1.33  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.32  2003/08/13 20:18:34  scowan
 * Added bool value to disable cancel class.
 *
 * Revision 1.31  2003/06/12 19:33:09  scowan
 * Added set full affine.
 *
 * Revision 1.30  2003/06/11 19:36:32  scowan
 * More const.
 *
 * Revision 1.29  2002/07/30 18:52:52  dwilliss
 * Use 0 instead of NULL
 *
 * Revision 1.28  2002/05/31 22:02:58  dwilliss
 * *** empty log message ***
 *
 * Revision 1.27  2002/04/29 17:39:03  dwilliss
 * Added an ApplyPrescale method to TRANS2D_AFFINE
 *
 * Revision 1.26  2002/04/29 17:00:33  mju
 * Add GetInputTrans methods.
 *
 * Revision 1.25  2002/03/07 15:52:12  mju
 * Add AFFINE::setctrlpoints using CTRLPOINT3.
 *
 * Revision 1.24  2001/08/17 20:36:01  scowan
 * Added method to set affine with control points.
 *
 * Revision 1.23  2001/06/15 21:38:19  scowan
 * Nothing.
 *
 * Revision 1.22  2000/12/06 16:25:32  scowan
 * Fixed conversion warning.
 *
 * Revision 1.21  2000/10/03 22:21:53  msmith
 * Genitor documentation.
 *
 * Revision 1.20  2000/07/18 21:53:11  mju
 * Add ReadGeoreference().
 *
 * Revision 1.19  2000/05/12 16:15:53  scowan
 * Added disect methods
 *
 * Revision 1.18  2000/03/13 16:03:26  mju
 * Add MAPGEN::ConvertForward/Inverse for generic point array.
 *
 * Revision 1.17  2000/03/07 16:52:51  scowan
 * Added method to cast to const trans parm automatically.
 *
 * Revision 1.15  2000/01/26 17:13:44  scowan
 * Added update and clear methods.
 *
 * Revision 1.14  2000/01/26 14:41:05  mju
 * Change CARTO and MAPGEN classes to return converted values in reference parm.
 *
 * Revision 1.10  1999/12/16 23:57:30  scowan
 * Added more methods.
 *
 * Revision 1.9  1999/05/26 14:09:02  mju
 * Add AFFINE.ReverseDirection() method.
 *
 * Revision 1.8  1999/05/20  15:46:45  mju
 * Use INT32 for all "NumPoints" parameters.
 *
 * Revision 1.7  1999/05/19  17:28:41  mju
 * Add MAPGEN.GetTransParm.
 * Include rect.h.
 *
 * Revision 1.6  1999/05/19  17:22:05  mju
 * Use TransGenCopy().
 *
 * Revision 1.5  1999/05/19  13:51:40  mju
 * Add AFFINE.ConvertForward/Inverse for arrays.
 *
 * Revision 1.4  1999/05/06  22:14:48  mju
 * Add Disect methods.
 *
 * Revision 1.3  1999/05/05  13:52:51  mju
 * Add MAPGEN.Disect methods.
 *
 * Revision 1.2  1999/04/28  17:41:26  mju
 * Include ctrlpt.h.
 *
 * Revision 1.1  1999/04/19  14:15:57  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_TRANS2DC_H
#define  INC_MI32_TRANS2DC_H

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

#ifndef  INC_MI32_TRANSGEN_H
#include <mi32/transgen.h>
#endif

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

#ifndef  INC_MI32_MAPPROJ_H
#include <mi32/mapproj.h>
#endif

#ifndef  INC_MI32_CTRLPT_H
#include <mi32/ctrlpt.h>
#endif

#ifndef  INC_MI32_RVCGREF_H
#include <mi32/rvcgref.h>
#endif

#include <memory.h>     //! For memcpy() prototype


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

//! Forward declarations

class TRANS2D_MAPGEN;

#endif // GENERATING_DOXYGEN_OUTPUT

//-------------------------------------------------------------------------------------------------------------------
//! Simple affine X/Y coordinate transformation.
//!
//! All conversion methods are inline for maximum speed.  For single point
//! conversion, no function call will occur (assuming the compiler actually
//! inlines the method).  This class replaces the trans2d...() C functions.
class GEOMLIBCLASSEXPORT TRANS2D_AFFINE {

   public:

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

      //! Default constructor, create identity transformation.
      TRANS2D_AFFINE (
         ) { trans2dinit(m_fwd,m_inv); }

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

      //! Construct from affine matrices.
      TRANS2D_AFFINE (
         const MAT3X3 fwd,                //!< Forward transformation matrix
         const MAT3X3 inv                 //!< Inverse transformation matrix
         ) {
         memcpy(m_fwd,fwd,sizeof(MAT3X3));
         memcpy(m_inv,inv,sizeof(MAT3X3));
         }

      //! Construct from combination of two affine transformations.
      TRANS2D_AFFINE (
         const TRANS2D_AFFINE& trans1,    //!< First transformation
         const TRANS2D_AFFINE& trans2     //!< Second transformation
         ) { trans2dmatrix2(m_fwd,m_inv,trans1.m_fwd,trans1.m_inv,trans2.m_fwd,trans2.m_inv); }

      //! Construct from CTRLPOINT array.
      TRANS2D_AFFINE (
         const CTRLPOINT *cp,             //!< Control point array
         int numpoints,                   //!< Number of control points
         bool invert = false              //!< Invert coordinate system (for images)
         ) { FindBestTrans2DA(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0); }

      //! Construct from CTRLPOINT3 array.
      TRANS2D_AFFINE (
         const CTRLPOINT3 *cp,            //!< Control point array
         int numpoints,                   //!< Number of control points
         bool invert = false              //!< Invert coordinate system (for images)
         ) { FindBestTrans2D3A(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0); }

      //! Destructor.
      ~TRANS2D_AFFINE (
         ) {}

      //! Assignment from 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);
         }

      //! Apply coordinate offset.
      void ApplyOffset (
         double xoffset,                  //!< X offset
         double yoffset                   //!< Y offset
         ) { trans2dshift(m_fwd,m_inv,xoffset,yoffset); }

      //! Apply coordinate offset.
      void ApplyOffset (
         const DPOINT2D& offset           //!< Offset
         ) { trans2dshift(m_fwd,m_inv,offset.x,offset.y); }

      //! Apply coordinate offset relative to reverse direction.
      void ApplyOffsetReverse (
         double xoffset,                  //!< X offset
         double yoffset                   //!< Y offset
         ) { trans2dshift(m_inv,m_fwd,xoffset,yoffset); }

      //! Apply coordinate offset relative to reverse direction.
      void ApplyOffsetReverse (
         const DPOINT2D& offset           //!< Offset
         ) { trans2dshift(m_inv,m_fwd,offset.x,offset.y); }

      //! Apply rotation angle.
      void ApplyRotation (
         double angle                     //!< Rotation angle in radians
         ) { trans2drot(m_fwd,m_inv,angle); }

      //! Apply scale equally to X/Y axes.
      void ApplyScale (
         double scale                     //!< Scale
         ) { trans2dscale(m_fwd,m_inv,scale,scale); }

      //! Apply scale to X/Y axes.
      void ApplyScale (
         double xscale,                   //!< X scale
         double yscale                    //!< Y scale
         ) { trans2dscale(m_fwd,m_inv,xscale,yscale); }

      //! Apply scale to X/Y axes.
      void ApplyScale (
         const DPOINT2D &scale            //!< X/Y scale
         ) { trans2dscale(m_fwd,m_inv,scale.x,scale.y); }

      //! Apply scale to X/Y axes, relative to reverse direction.
      void ApplyScaleReverse (
         double xscale,                   //!< X scale
         double yscale                    //!< Y scale
         ) { trans2dscale(m_inv,m_fwd,xscale,yscale); }

      //! Apply scale to X/Y axes, relative to reverse direction.
      void ApplyScaleReverse (
         const DPOINT2D &scale            //!< X/Y scale
         ) { trans2dscale(m_inv,m_fwd,scale.x,scale.y); }

      //! Apply shear relative to specified axis.
      void ApplyShear (
         double angle,                    //!< Shear angle in radians
         AXIS axis                        //!< Axis to shear (AXIS_X or AXIS_Y)
         ) { trans2dshear(m_fwd,m_inv,angle,static_cast<int>(axis)); }

      //! Combine two affine transformations.
      void Combine (
         const TRANS2D_AFFINE& trans1     //!< First transformation
         ) {
         trans2dmatrix(m_fwd,trans1.m_fwd);
         trans2dmatrix(m_inv,trans1.m_inv);
         }

      //! Combine two affine transformations.
      void Combine (
         const TRANS2D_AFFINE& trans1,    //!< First transformation
         const TRANS2D_AFFINE& trans2     //!< Second transformation
         ) { trans2dmatrix2(m_fwd,m_inv,trans1.m_fwd,trans1.m_inv,trans2.m_fwd,trans2.m_inv); }

      //! Perform forward transformation on X/Y point.
      //! @return Converted point.
      DPOINT2D ConvertForward (
         double x,                        //!< X coordinate
         double y                         //!< Y coordinate
         ) const { return (DPOINT2D(trans2dx(x,y,m_fwd),trans2dy(x,y,m_fwd))); }

      //! Perform forward transformation on X/Y point.
      void ConvertForward (
         double x,                        //!< X coordinate
         double y,                        //!< Y coordinate
         double& ox,                      //!< X coordinate
         double& oy                       //!< Y coordinate
         ) const { ox = trans2dx(x,y,m_fwd); oy = trans2dy(x,y,m_fwd); }

      //! Perform forward transformation on DPOINT2D.
      //! @return Converted point.
      DPOINT2D ConvertForward (
         const DPOINT2D& ipoint           //!< Input point
         ) const { return (DPOINT2D(trans2dx(ipoint.x,ipoint.y,m_fwd),trans2dy(ipoint.x,ipoint.y,m_fwd))); }

      //! Perform forward transformation on DPOINT3D.
      //! @return Converted point.
      DPOINT3D ConvertForward (
         const DPOINT3D& ipoint           //!< Input point
         ) const { return (DPOINT3D(trans2dx(ipoint.x,ipoint.y,m_fwd),trans2dy(ipoint.x,ipoint.y,m_fwd),ipoint.z)); }

      //! Perform forward transformation on DPOINT2D array.
      void ConvertForward (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const;

      //! Perform forward transformation on DPOINT3D array.
      void ConvertForward (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const;

      //! Perform forward transformation on DRECT2D.
      //! @return Converted rectangle.
      DRECT2D ConvertForward (
         const DRECT2D& irect             //!< Input rectangle
         ) const {
         DRECT2D orect;
         Trans2DRect(m_fwd,&irect,&orect);
         return (orect);
         }

      //! Perform forward transformation on DRECT2D.
      void ConvertForward (
         const DRECT2D& irect,            //!< Input rectangle
         DRECT2D& orect                   //!< Output rectangle
         ) const { Trans2DRect(m_fwd,&irect,&orect); }

      //! Perform inverse transformation on X/Y point.
      //! @return Converted point.
      DPOINT2D ConvertInverse (
         double x,                        //!< X coordinate
         double y                         //!< Y coordinate
         ) const { return (DPOINT2D(trans2dx(x,y,m_inv),trans2dy(x,y,m_inv))); }

      //! Perform inverse transformation on DPOINT2D.
      //! @return Converted point.
      DPOINT2D ConvertInverse (
         const DPOINT2D& ipoint           //!< Input point
         ) const { return (DPOINT2D(trans2dx(ipoint.x,ipoint.y,m_inv),trans2dy(ipoint.x,ipoint.y,m_inv))); }

      //! Perform inverse transformation on DPOINT3D.
      //! @return Converted point.
      DPOINT3D ConvertInverse (
         const DPOINT3D& ipoint           //!< Input point
         ) const { return (DPOINT3D(trans2dx(ipoint.x,ipoint.y,m_inv),trans2dy(ipoint.x,ipoint.y,m_inv),ipoint.z)); }

      //! Perform inverse transformation on DPOINT2D array.
      void ConvertInverse (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const;

      //! Perform inverse transformation on DPOINT3D array.
      void ConvertInverse (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const;

      //! Perform inverse transformation on DRECT2D.
      //! @return Converted rectangle.
      DRECT2D ConvertInverse (
         const DRECT2D& irect             //!< Input rectangle
         ) const {
         DRECT2D orect;
         Trans2DRect(m_inv,&irect,&orect);
         return (orect);
         }

      //! Perform inverse transformation on DRECT2D.
      void ConvertInverse (
         const DRECT2D& irect,            //!< Input rectangle
         DRECT2D& orect                   //!< Output rectangle
         ) const { Trans2DRect(m_inv,&irect,&orect); }

      //! Determine scale/rotation/shear for forward transformation
      void DisectForward (
         double *xscale,                  //!< X scale returned (0 if don't need)
         double *yscale,                  //!< Y scale returned (0 if don't need)
         double *rotangle = 0,            //!< Rotation angle in radians returned (0 if don't need)
         double *shearangle = 0           //!< Shear angle in radians returned (0 if don't need)
         ) const { DisectTrans2D(m_fwd,xscale,yscale,rotangle,shearangle); }
         
      //! Determine scale/rotation/shear for inverse transformation
      void DisectInverse (
         double *xscale,                  //!< X scale returned (0 if don't need)
         double *yscale,                  //!< Y scale returned (0 if don't need)
         double *rotangle = 0,            //!< Rotation angle in radians returned (0 if don't need)
         double *shearangle = 0           //!< Shear angle in radians returned (0 if don't need)
         ) const { DisectTrans2D(m_inv,xscale,yscale,rotangle,shearangle); }

      //! Retrieve copy of affine matrices      
      void GetMatrices (
         MAT3X3 fwd,                      //!< Forward matrix returned
         MAT3X3 inv                       //!< Inverse matrix returned
         ) const { memcpy(fwd,m_fwd,sizeof(MAT3X3)); memcpy(inv,m_inv,sizeof(MAT3X3)); }

      //! Determine if the two transformation's are equivalent
      //! @return 'True' if equivalent, 'false' if not         
      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);
         }

      //! Determine if the transformation is an identity
      //! @return 'True' if identity, 'false' if not        
      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);
         }

      //! Reverse direction of transformation.
      void ReverseDirection (
         ) {
         MAT3X3 temp;
         memcpy(temp,m_fwd,sizeof(MAT3X3));
         memcpy(m_fwd,m_inv,sizeof(MAT3X3));
         memcpy(m_inv,temp,sizeof(MAT3X3));
         }

      //! Set transformation from CTRLPOINT array.
      ERRVALUE SetCtrlPoint (
         const CTRLPOINT *cp,             //!< Control point array
         int numpoints,                   //!< Number of control points
         bool invert = false              //!< Invert coordinate system (for images)
         ) { return (FindBestTrans2DA(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0)); }
         
      //! Set transformation from CTRLPOINT3 array.
      ERRVALUE SetCtrlPoint (
         const CTRLPOINT3 *cp,            //!< Control point array
         int numpoints,                   //!< Number of control points
         bool invert = false              //!< Invert coordinate system (for images)
         ) { return (FindBestTrans2D3A(numpoints,cp,m_fwd,m_inv,(invert)?TRANS2DMODEL_OrientInvert:0)); }
         
      //! Set transformation to "identity".
      void SetIdentity (
         ) { trans2dinit(m_fwd,m_inv); }

      //! Set transformation from affine matrices.
      void SetMatrices (
         const MAT3X3 fwd,                //!< Forward transformation
         const MAT3X3 inv                 //!< Inverse transformation
         ) { memcpy(m_fwd,fwd,sizeof(MAT3X3)); memcpy(m_inv,inv,sizeof(MAT3X3)); }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      MAT3X3 m_fwd;                       //!< Forward transformation matrix
      MAT3X3 m_inv;                       //!< Inverse transformation matrix

      friend class TRANS2D_MAPGEN;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//-------------------------------------------------------------------------------------------
//!      TRANS2D_MAPGEN
//-------------------------------------------------------------------------------------------

//! Encapsulate TRANSPARM structure and TransGen...() functions
class TRANS2D_MAPGEN {
   public:

      //! Transformation direction
      enum DIRECTION {
         DIRECTION_Forward = TRANSDIR_Forward,
         DIRECTION_Inverse = TRANSDIR_Inverse
         };

      //! Default constructor, create identity transformation
      TRANS2D_MAPGEN (
         ) { TransGenInit(&m_transparm); }

      //! Copy constructor.
      TRANS2D_MAPGEN (
         const TRANS2D_MAPGEN &rhs
         ) {
         TransGenInit(&m_transparm);
         TransGenCopy(&m_transparm,&rhs.m_transparm);
         }

      //! Construct from TRANSPARM (allows implicit conversion).
      TRANS2D_MAPGEN (
         const TRANSPARM& transparm
         ) {
         TransGenInit(&m_transparm);
         TransGenCopy(&m_transparm,&transparm);
         }

      //! Destructor.
      ~TRANS2D_MAPGEN (
         ) { TransGenFreeParm(&m_transparm); }

      //! Assignment from TRANS2D_MAPGEN.
      TRANS2D_MAPGEN& operator= (
         const TRANS2D_MAPGEN &rhs
         ) {
         if (this != &rhs) {
            TransGenCopy(&m_transparm,&rhs.m_transparm);
            }
         return (*this);
         }

      //! Assignment from TRANSPARM.
      TRANS2D_MAPGEN& operator= (
         const TRANSPARM &rhs
         ) {
         TransGenCopy(&m_transparm,&rhs);
         return (*this);
         }

      //! Cast to (const TRANSPARM *).
      operator const TRANSPARM* (
         ) const { return (&m_transparm); }

      void Clear (
         ) { TransGenFreeParm(&m_transparm); TransGenInit(&m_transparm); }

      //! Perform forward transformation on DPOINT2D
      ERRVALUE ConvertForward (
         const DPOINT2D& ipoint,          //!< Input point
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointFwd(&m_transparm,&ipoint,&opoint)); }

      //! Perform forward transformation on DPOINT3D.
      ERRVALUE ConvertForward (
         const DPOINT3D& ipoint,          //!< Input point
         DPOINT3D& opoint                 //!< Output point
         ) const { opoint.z = ipoint.z; return (TransGenConvPointFwd(&m_transparm, &ipoint, &opoint)); }

      //! Perform forward transformation on DPOINT2D array.
      ERRVALUE ConvertForward (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (TransGenConvPointSetFwd(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,2,reinterpret_cast<double*>(opoints))); }

      //! Perform forward transformation on DPOINT3D array.
      ERRVALUE ConvertForward (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (TransGenConvPointSetFwd(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,3,reinterpret_cast<double*>(opoints))); }

      //! Perform forward transformation on generic point array.
      ERRVALUE ConvertForward (
         const void* ipoints,             //!< Input point array
         void* opoints,                   //!< Output point array
         INT32 NumPoints,                 //!< Number of points to convert
         int NumDim                       //!< Number of dimensions
         ) const { return (TransGenConvPointSetFwd(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,NumDim,reinterpret_cast<double*>(opoints))); }

      //! Perform forward transformation on rectangle.
      ERRVALUE ConvertForward (
         const DRECT2D& irect,            //!< Input rectangle
         DRECT2D& orect,                  //!< Output rectangle
         int sidepoints=0                 //!< Number of extra points along sides for interpolation
         ) const { return (TransGenConvRectFwd(&m_transparm,&irect,&orect,sidepoints)); }

      //! Perform forward transformation on DPOINT2D array with possible densification.
      INT32 ConvertForwardDense (
         const DPOINT2D* ipoint,          //!< Input point array
         INT32 iNumPoints,                //!< Number of input points
         DPOINT2D** opoint                //!< Pointer to output point array (internal, DO NOT FREE)
         ) const {                        //! Returns number of output points or error < 0
         INT32 oNumPoints;
         int err;
         if ((err = TransGenConvPointsFwd(&m_transparm,reinterpret_cast<const double*>(ipoint),iNumPoints,2,reinterpret_cast<double**>(opoint),&oNumPoints)) < 0) return (err);
         return (oNumPoints);
         }

      //! Perform forward transformation on DPOINT3D array with possible densification.
      INT32 ConvertForwardDense (
         const DPOINT3D* ipoint,          //!< Input point array
         INT32 iNumPoints,                //!< Number of input points
         DPOINT3D** opoint                //!< Pointer to output point array (internal, DO NOT FREE)
         ) const {                        //! Returns number of output points or error < 0
         INT32 oNumPoints;
         int err;
         if ((err = TransGenConvPointsFwd(&m_transparm,reinterpret_cast<const double*>(ipoint),iNumPoints,3,reinterpret_cast<double**>(opoint),&oNumPoints)) < 0) return (err);
         return (oNumPoints);
         }

      //! Perform inverse transformation on DPOINT2D.
      ERRVALUE ConvertInverse (
         const DPOINT2D& ipoint,          //!< Input point
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointInv(&m_transparm,&ipoint,&opoint)); }

      //! Perform inverse transformation on DPOINT3D.
      ERRVALUE ConvertInverse (
         const DPOINT3D& ipoint,          //!< Input point
         DPOINT3D& opoint                 //!< Output point
         ) const { opoint.z = ipoint.z; return (TransGenConvPointInv(&m_transparm,&ipoint,&opoint)); }

      //! Perform inverse transformation on DPOINT2D array.
      ERRVALUE ConvertInverse (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (TransGenConvPointSetInv(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,2,reinterpret_cast<double*>(opoints))); }

      //! Perform inverse transformation on DPOINT3D array.
      ERRVALUE ConvertInverse (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (TransGenConvPointSetInv(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,3,reinterpret_cast<double*>(opoints))); }

      //! Perform inverse transformation on generic point array.
      ERRVALUE ConvertInverse (
         const void* ipoints,             //!< Input point array
         void* opoints,                   //!< Output point array
         INT32 NumPoints,                 //!< Number of points to convert
         int NumDim                       //!< Number of dimensions
         ) const { return (TransGenConvPointSetInv(&m_transparm,reinterpret_cast<const double*>(ipoints),NumPoints,NumDim,reinterpret_cast<double*>(opoints))); }

      //! Perform inverse transformation on rectangle.
      ERRVALUE ConvertInverse (
         const DRECT2D& irect,            //!< Input rectangle
         DRECT2D& orect,                  //!< Output rectangle
         int sidepoints=0                 //!< Number of extra points along sides for interpolation
         ) const { return (TransGenConvRectInv(&m_transparm,&irect,&orect,sidepoints)); }

      //! Perform inverse transformation on DPOINT2D array with possible densification.
      INT32 ConvertInverseDense (
         const DPOINT2D* ipoint,          //!< Input point array
         INT32 iNumPoints,                //!< Number of input points
         DPOINT2D** opoint                //!< Pointer to output point array (internal, DO NOT FREE)
         ) const {                        //! Returns number of output points or error < 0
         INT32 oNumPoints;
         int err;
         if ((err = TransGenConvPointsInv(&m_transparm,reinterpret_cast<const double*>(ipoint),iNumPoints,2,reinterpret_cast<double**>(opoint),&oNumPoints)) < 0) return (err);
         return (oNumPoints);
         }

      //! Perform inverse transformation on DPOINT3D array with possible densification.
      INT32 ConvertInverseDense (
         const DPOINT3D* ipoint,          //!< Input point array
         INT32 iNumPoints,                //!< Number of input points
         DPOINT3D** opoint                //!< Pointer to output point array (internal, DO NOT FREE)
         ) const {                        //! Returns number of output points or error < 0
         INT32 oNumPoints;
         int err;
         if ((err = TransGenConvPointsInv(&m_transparm,reinterpret_cast<const double*>(ipoint),iNumPoints,3,reinterpret_cast<double**>(opoint),&oNumPoints)) < 0) return (err);
         return (oNumPoints);
         }

      //! Convert from input map coordinates to output map coordinates.
      ERRVALUE ConvertMapToMapForward (
         const DPOINT2D& ipoint,          //!< Point to convert
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointMapToMapFwd(&m_transparm,&ipoint,&opoint)); }

      //! Convert from output map coordinates to input map coordinates.
      ERRVALUE ConvertMapToMapInverse (
         const DPOINT2D& ipoint,          //!< Point to convert
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointMapToMapInv(&m_transparm,&ipoint,&opoint)); }

      //! Convert from "output" to "map" coordinates.
      ERRVALUE ConvertOutputToMap (
         const DPOINT2D& ipoint,          //!< Point to convert
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointOutputToMap(&m_transparm,&ipoint,&opoint)); }

      //! Copy TRANSPARM "input" parameters to "input" parameters.
      void CopyInputToInput (
         const TRANSPARM& transparm
         ) {
         int err;
         if ((err = TransGenCopyInputParms(&m_transparm,&transparm)) < 0) {
            //! XXX throw an exception
            }
         return;
         }

      //! Copy MAPGEN "input" parameters to "input" parameters.
      void CopyInputToInput (
         const TRANS2D_MAPGEN& itrans
         ) { CopyInputToInput(itrans.m_transparm); }

      //! Copy TRANSPARM "input" parameters to "output" parameters.
      void CopyInputToOutput (
         const TRANSPARM& transparm
         ) {
         int err;
         if ((err = TransGenCopyInputToOutput(&m_transparm,&transparm)) < 0) {
            //! XXX throw an exception
            }
         return;
         }

      //! Copy MAPGEN "input" parameters to "output" parameters.
      void CopyInputToOutput (
         const TRANS2D_MAPGEN& itrans
         ) { CopyInputToOutput(itrans.m_transparm); }

      //! Copy TRANSPARM "output" parameters to "input" parameters.
      void CopyOutputToInput (
         const TRANSPARM& transparm
         ) {
         int err;
         if ((err = TransGenCopyOutputToInput(&m_transparm,&transparm)) < 0) {
            //! XXX throw an exception
            }
         return;
         }

      //! Copy MAPGEN "output" parameters to "input" parameters.
      void CopyOutputToInput (
         const TRANS2D_MAPGEN& itrans
         ) { CopyOutputToInput(itrans.m_transparm); }

      //! Copy TRANSPARM "output" parameters to "output" parameters.
      void CopyOutputToOutput (
         const TRANSPARM& transparm
         ) {
         int err;
         if ((err = TransGenCopyOutputParms(&m_transparm,&transparm)) < 0) {
            //! XXX throw an exception
            }
         return;
         }

      //! Copy MAPGEN "output" parameters to "output" parameters.
      void CopyOutputToOutput (
         const TRANS2D_MAPGEN& itrans
         ) { CopyOutputToOutput(itrans.m_transparm); }

      //! Determine scale/rotation/shear at specified point for forward transformation.
      ERRVALUE DisectForward (
         const DPOINT2D& point,           //!< Reference point at which values will be computed
         double *xscale,                  //!< X scale returned (0 if don't need)
         double *yscale,                  //!< Y scale returned (0 if don't need)
         double *rotangle = 0,            //!< Rotation angle in radians returned (0 if don't need)
         double *shearangle = 0,          //!< Shear angle in radians returned (0 if don't need)
         double size = 1.0                //!< Size of area over which to compute values
         ) const {
         return (TransGenDisectFwd(&m_transparm,&point,size,xscale,yscale,rotangle,shearangle));
         }

      //! Determine scale/rotation/shear at specified point for inverse transformation.
      ERRVALUE DisectInverse (
         const DPOINT2D& point,           //!< Reference point at which values will be computed
         double *xscale,                  //!< X scale returned (0 if don't need)
         double *yscale,                  //!< Y scale returned (0 if don't need)
         double *rotangle = 0,            //!< Rotation angle in radians returned (0 if don't need)
         double *shearangle = 0,          //!< Shear angle in radians returned (0 if don't need)
         double size = 1.0                //!< Size of area over which to compute values
         ) const {
         return (TransGenDisectInv(&m_transparm,&point,size,xscale,yscale,rotangle,shearangle));
         }

      //! Get affine transformation if available.
      //! Will return error if transformation is not affine.
      ERRVALUE GetAffine (
         MAT3X3 fwd,                      //!< Forward transformation
         MAT3X3 inv                       //!< Inverse transformation
         ) const { return (TransGenGetAffine(&m_transparm, fwd, inv)); }

      //! Get affine transformation if available.
      //! Will return error if transformation is not affine.
      ERRVALUE GetAffine (
         TRANS2D_AFFINE& trans            //!< Affine transformation
         ) const { return (TransGenGetAffine(&m_transparm, trans.m_fwd, trans.m_inv)); }

      //! Get 'input' map coordinate reference system.
      const SPATREF::COORDREFSYS& GetInputMapCoordRefSys (
         ) const { return (TransGenGetInputMapCoordRefSys(m_transparm)); }

      //! Get input model
      UINT16 GetInputModel (
         ) const {                       
         return (TransGenGetInputModel(&m_transparm));
         }

      //! Get "input" map projection parameters.
      MAPPROJPARM GetInputProjection (
         ) const {                        //! Returns projection parameters
         MAPPROJPARM projparm;
         TransGenGetInputProj(&m_transparm,&projparm);
         return (projparm);
         }

      //! Get input transformation as affine.
      ERRVALUE GetInputTrans (
         TRANS2D_AFFINE& trans            //!< Affine transformation
         ) { return (TransGenGetInputTransAffine(&m_transparm,trans.m_fwd,trans.m_inv)); }

      //! Get input transformation as affine.
      ERRVALUE GetInputTrans (
         MAT3X3 fwd,
         MAT3X3 inv
         ) { return (TransGenGetInputTransAffine(&m_transparm,fwd,inv)); }

      //! Get input transformation as control points.
      //! Will return number of points if any or error
      int GetInputTrans (
         CTRLPOINT3 **ctrlpoint           
         ) { return (TransGenGetInputTransCtrlPoint(&m_transparm, ctrlpoint)); }

      //! Get local affine transformation.
      ERRVALUE GetLocalAffine (
         const DPOINT2D& point,
         MAT3X3 fwd,                      //!< Forward transformation
         MAT3X3 inv,                      //!< Inverse transformation
         double size = 1.0,
         UINT32 flags = 0
         ) { return (TransGenGetAffineLocal(&m_transparm, &point, size, fwd, inv, flags)); }

      //! Get local affine transformation.
      ERRVALUE GetLocalAffine (
         const DPOINT2D& point,
         TRANS2D_AFFINE& trans,           //!< Affine transformation
         double size = 1.0,
         UINT32 flags = 0
         ) { return (TransGenGetAffineLocal(&m_transparm, &point, size, trans.m_fwd, trans.m_inv, flags)); }

      //! Get 'output' map coordinate reference system.
      const SPATREF::COORDREFSYS& GetOutputMapCoordRefSys (
         ) const { return (TransGenGetOutputMapCoordRefSys(m_transparm)); }

      //! Get output model
      UINT16 GetOutputModel (
         ) const {                       
         return (TransGenGetOutputModel(&m_transparm));
         }

      //! Get "output" map projection parameters.
      MAPPROJPARM GetOutputProjection (
         ) const {                        //! Returns projection parameters
         MAPPROJPARM projparm;
         TransGenGetOutputProj(&m_transparm,&projparm);
         return (projparm);
         }

      //! Get output transformation as affine.
      ERRVALUE GetOutputTrans (
         TRANS2D_AFFINE& trans            //!< Affine transformation
         ) { return (TransGenGetOutputTransAffine(&m_transparm,trans.m_fwd,trans.m_inv)); }

      //! Get output transformation as affine.
      ERRVALUE GetOutputTrans (
         MAT3X3 fwd,
         MAT3X3 inv
         ) { return (TransGenGetOutputTransAffine(&m_transparm,fwd,inv)); }

      //! Get output transformation as control points.
      //! Will return number of points if any or error
      int GetOutputTrans (
         CTRLPOINT3 **ctrlpoint           
         ) { return (TransGenGetOutputTransCtrlPoint(&m_transparm, ctrlpoint)); }

      const TRANSPARM& GetTransParm (
         ) const { return (m_transparm); }

      //! Determine if transformation is "affine".
      bool IsAffine (
         ) const { return (TransGenIsAffine(&m_transparm)); }

      //! Determine if transformation is "identity".
      bool IsIdentity (
         ) const { return (TransGenIsIdentity(&m_transparm)); }

      //! Determine if 'input' transformation is 'identity'.
      bool IsInputTransIdentity (
         ) const { return (TransGenIsInputTransIdentity(&m_transparm)); }

      //! Determine if 'output' transformation is 'identity'.
      bool IsOutputTransIdentity (
         ) const { return (TransGenIsOutputTransIdentity(&m_transparm)); }

      //! Determine if transformation is "reversible".
      bool IsReversible (
         ) const { return (TransGenIsReversible(&m_transparm)); }

      //! Read georeference from RVC object.
      ERRVALUE ReadGeoreference (
         int fhandle,                     //!< Open RVC file hadnle
         RVCINODENUM inode,               //!< Georeference object inode
         bool dooutput = false            //!< Use "output" side of transformation
         ) {
         return (MfReadGeorefTransParm(fhandle,inode,0,&m_transparm,(dooutput)?RVCGREF_TransGenOutput:0));
         }

      //! Set full transformation to approximated affine if within specified tolerance.
      //! The approximate affine transformation will be retained until the next "Set" method is used
      //! at which time the transformation will revert to its "exact" mode (which may also be affine).
      ERRVALUE SetAffineApproximation (
         const DRECT2D& rect,             //!< Rectangle over which transformation is to be used
         double tolerance,                //!< Tolerance in opposite coordinates from rectangle
         UINT32 coord                     //!< Coordinates of rectangle (XXX change to enum)
         ) { return (TransGenSetAffineApprox(&m_transparm,&rect,tolerance,static_cast<UINT32>(coord))); }

      //! Set whether to perform extrapolation outside specified bounds.
      //! If extrapolation is not enabled then an exception -may- occur if and attempt is made
      //! to convert points outside the previously-specified input/output bounds.  This is the
      //! default condition and will generally be much faster than extrapolating.
      void SetExtrapolation (
         bool extrapolate                 //!< Perform extrapolation if true, don't extrapolate if false
         ) { TransGenSetExtrapOutside(&m_transparm,extrapolate); }

      //! Set entire transformation as affine.
      void SetFullTransAffine (
         const TRANS2D_AFFINE& trans      //!< Affine transformation
         ) { TransGenSetFullTransAffine(&m_transparm,trans.m_fwd,trans.m_inv); }

      //! Set boundaries for valid transformation in input coordinates
      ERRVALUE SetInputBounds (
         const DRECT2D& boundrect         //!< Bounding rectangle in input coordinates
         ) { return (TransGenSetInputBound(&m_transparm,&boundrect)); }

      //! Set maximum error for point densification in input coordinates.
      void SetInputMaxError (
         double maxerror                  //!< Maximum error value to set
         ) {
         TransGenSetInputInsertMaxError(&m_transparm,maxerror);
         TransGenSetDoInsert(&m_transparm,1);
         }

      //! Set input map coordinate reference system.
      ERRVALUE SetInputMapCoordRefSys (
         const SPATREF::COORDREFSYS& MapCRS  //!< Map coordinate reference system
         ) { return (TransGenSetInputMapCoordRefSys(m_transparm,MapCRS)); }

      //! Set input projection parameters.
      ERRVALUE SetInputProjection (
         const MAPPROJPARM& projparm      //!< Projection parameters
         ) { return ( TransGenSetInputProj(&m_transparm,&projparm)); }

      //! Set input transformation as affine.
      void SetInputTrans (
         const TRANS2D_AFFINE& trans      //!< Affine transformation
         ) { TransGenSetInputTransAffine(&m_transparm,trans.m_fwd,trans.m_inv); }

      //! Set input transformation as affine.
      void SetInputTrans (
         const MAT3X3 fwd,                //!< Forward transformation
         const MAT3X3 inv                 //!< Inverse transformation
         ) { TransGenSetInputTransAffine(&m_transparm,fwd,inv); }

      //! Set input transformation from control point array.
      ERRVALUE SetInputTrans (
         const CTRLPOINT3 *CtrlPoint,     //!< Control point array
         INT32 NumPoints,                 //!< Number of control points
         UINT16 Model                     //!< Transformation model
         ) { return (TransGenSetInputTransCtrlPoint(&m_transparm,CtrlPoint,NumPoints,Model)); }

      //! Set input transformation to identity.
      void SetInputTransIdentity (
         ) { TransGenSetInputTransIdentity(&m_transparm); }

      //! Set maximum number of vertices to insert if densifying points
      void SetMaxVertices (
         INT32 MaxVertices
         ) { TransGenSetMaxInsertVertices(&m_transparm, MaxVertices); }

      //! Set boundaries for valid transformation in output coordinates.
      ERRVALUE SetOutputBounds (
         const DRECT2D& boundrect         //!< Bounding rectangle in output coordinates
         ) { return (TransGenSetOutputBound(&m_transparm,&boundrect)); }

      //! Set maximum error for point densification in output coordinates.
      void SetOutputMaxError (
         double maxerror                  //!< Maximum error value to set
         ) { 
         TransGenSetOutputInsertMaxError(&m_transparm,maxerror);
         TransGenSetDoInsert(&m_transparm,1);
         }

      //! Set output map coordinate reference system.
      ERRVALUE SetOutputMapCoordRefSys (
         const SPATREF::COORDREFSYS& MapCRS  //!< Map coordinate reference system
         ) { return (TransGenSetOutputMapCoordRefSys(m_transparm,MapCRS)); }

      //! Set output projection parameters.
      ERRVALUE SetOutputProjection (
         const MAPPROJPARM& projparm      //!< Projection parameters
         ) { return (TransGenSetOutputProj(&m_transparm,&projparm)); }

      //! Set output transformation as affine.
      void SetOutputTrans (
         const TRANS2D_AFFINE& trans      //!< Affine transformation
         ) { TransGenSetOutputTransAffine(&m_transparm,trans.m_fwd,trans.m_inv); }

      //! Set output transformation as affine.
      void SetOutputTrans (
         const MAT3X3 fwd,
         const MAT3X3 inv
         ) { TransGenSetOutputTransAffine(&m_transparm,fwd,inv); }

      //! Set output transformation from control point array.
      ERRVALUE SetOutputTrans (
         const CTRLPOINT3 *CtrlPoint,     //!< Control point array
         INT32 NumPoints,                 //!< Number of control points
         UINT16 Model                     //!< Transformation model
         ) { return (TransGenSetOutputTransCtrlPoint(&m_transparm,CtrlPoint,NumPoints,Model)); }

      //! Set output transformation to identity.
      void SetOutputTransIdentity (
         ) { TransGenSetOutputTransIdentity(&m_transparm); }

      //! Set primary transformation direction.
      //! The default transformation direction if not set explicitly is "forward".  This method
      //! is used in cases where the time to do a reverse transformation is much higher than in
      //! the primary direction.  This is commonly used for raster warping.
      void SetPrimaryDirection (
         DIRECTION direction              //!< DIRECTION_Forward or DIRECTION_Inverse
         ) { TransGenSetPrimaryDirection(&m_transparm,static_cast<UINT8>(direction)); }

      ERRVALUE Update (
         ) { return (TransGenUpdate(&m_transparm)); }


   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      TRANSPARM m_transparm;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


#endif   //!< INC_MI32_TRANS2DC_H

---