mi32/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.33 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: trans2dc.h_v $
 * 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

//! Forward declarations

class TRANS2D_MAPGEN;

//-------------------------------------------------------------------------------------------------------------------
//! 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 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 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 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 {
         for (int i = 0; (i < NumPoints); ++i) {
            opoints[i] = ConvertForward(ipoints[i]);
            }
         }

      //! 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 {
         for (int i = 0; (i < NumPoints); ++i) {
            opoints[i] = ConvertForward(ipoints[i]);
            }
         }

      //! 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 {
         for (int i = 0; (i < NumPoints); ++i) {
            opoints[i] = ConvertInverse(ipoints[i]);
            }
         }

      //! 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 {
         for (int i = 0; (i < NumPoints); ++i) {
            opoints[i] = ConvertInverse(ipoints[i]);
            }
         }

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

      //! 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.
      void SetCtrlPoint (
         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); }
         
      //! Set transformation from CTRLPOINT3 array.
      void SetCtrlPoint (
         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); }
         
      //! 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_CARTO
//-------------------------------------------------------------------------------------------

//! Implement cartographic coordinate transformation.  This class is a wrapper for
//! the "gctp" functions.
class TRANS2D_CARTO {
public:
   // CONSTRUCTION / DESTRUCTION

   //! Default contructor for Lat-Lon WGS84/GRS1980.
   TRANS2D_CARTO (
      ) {
      m_gctph = gctpAlloc();
      }

   //! Copy constructor.
   TRANS2D_CARTO (
      const TRANS2D_CARTO& rhs
      ) {
      m_gctph = gctpAlloc();
      gctpCopy(m_gctph,rhs.m_gctph);
      }

   //! Construct from MAPPROJPARM.
   TRANS2D_CARTO (
      const MAPPROJPARM& projparm      //!< Projection parameters
      ) {
      m_gctph = gctpAlloc();
      gctpSetParm(m_gctph,&projparm);
      }

   //! Destructor.
   ~TRANS2D_CARTO (
      ) {
      gctpFree(m_gctph);
      }

   // OPERATORS

   //! Assignment from TRANS2D_CARTO.
   TRANS2D_CARTO& operator= (
      const TRANS2D_CARTO& rhs
      ) {
      if (this != &rhs) {
         gctpCopy(m_gctph,rhs.m_gctph);
         }
      return (*this);
      }

   //! Assignment from MAPPROJPARM.
   TRANS2D_CARTO& operator= (
      const MAPPROJPARM& rhs
      ) {
      gctpSetParm(m_gctph,&rhs);
      return (*this);
      }
      
   // METHODS

   //! Convert DPOINT2D from one projection to another.
   ERRVALUE Convert (
      const TRANS2D_CARTO& ocarto,     //!< Output projection definition
      const DPOINT2D& ipoint,          //!< Input point
      DPOINT2D& opoint                 //!< Output point
      ) const {
      return (gctpConvert(m_gctph,&ipoint,ocarto.m_gctph,&opoint,1));
      }

   //! Convert DPOINT3D from one projection to another.
   ERRVALUE Convert (
      const TRANS2D_CARTO& ocarto,     //!< Output projection definition
      const DPOINT3D& ipoint,          //!< Input point
      DPOINT3D& opoint                 //!< Output point
      ) const {
      return (gctpConvertND(m_gctph,reinterpret_cast<const void*>(&ipoint),ocarto.m_gctph,reinterpret_cast<void*>(&opoint),1,3));
      }

   //! Convert DPOINT2D array from one projection to another.
   ERRVALUE Convert (
      const TRANS2D_CARTO& ocarto,     //!< Output projection definition
      const DPOINT2D *ipoints,         //!< Input point array
      DPOINT2D *opoints,               //!< Output point array
      INT32 NumPoints                  //!< Number of points
      ) const {
      return (gctpConvert(m_gctph,ipoints,ocarto.m_gctph,opoints,NumPoints));
      }

   //! Convert DPOINT3D array from one projection to another.
   ERRVALUE Convert (
      const TRANS2D_CARTO& ocarto,     //!< Output projection definition
      const DPOINT3D *ipoints,         //!< Input point array
      DPOINT3D *opoints,               //!< Output point array
      INT32 NumPoints                  //!< Number of points
      ) const {
      return (gctpConvertND(m_gctph,reinterpret_cast<const void*>(ipoints),ocarto.m_gctph,reinterpret_cast<void*>(opoints),NumPoints,3));
      }

   //! Convert DPOINT2D from Latitude-Longitude to projection.
   ERRVALUE ConvertLatLonToProj (
      const DPOINT2D& ipoint,          //!< Input point
      DPOINT2D& opoint                 //!< Output point
      ) const {
      return (gctpConvertLatLonToProj(m_gctph,&ipoint,&opoint,1));
      }

   //! Convert DPOINT2D array from Latitude-Longitude to projection.
   ERRVALUE ConvertLatLonToProj (
      const DPOINT2D *ipoints,         //!< Input point array
      DPOINT2D *opoints,               //!< Output point array
      INT32 NumPoints                  //!< Number of points
      ) const {
      return (gctpConvertLatLonToProj(m_gctph,ipoints,opoints,NumPoints));
      }

   //! Convert DPOINT2D from projection to Latitude-Longitude.
   ERRVALUE ConvertProjToLatLon (
      const DPOINT2D& ipoint,          //!< Input point
      DPOINT2D& opoint                 //!< Output point
      ) const {
      return (gctpConvertProjToLatLon(m_gctph,&ipoint,&opoint,1));
      }

   //! Convert DPOINT2D array from projection to Latitude-Longitude.
   ERRVALUE ConvertProjToLatLon (
      const DPOINT2D *ipoints,         //!< Input point array
      DPOINT2D *opoints,               //!< Output point array
      INT32 NumPoints                  //!< Number of points
      ) const {
      return (gctpConvertProjToLatLon(m_gctph,ipoints,opoints,NumPoints));
      }

   //! Get angle between projection and true North at given point.
   double GetAngleToNorth (
      double x,                        //!< X coordinate
      double y                         //!< Y coordinate
      ) const {                        //! Returns angle in radians
      double angle;
      if (gctpAngleToNorth(m_gctph,x,y,&angle) < 0) return (0.0);
      return (angle);
      }

   //! Get angle between projection and true North at given point.
   double GetAngleToNorth (
      const DPOINT2D& point            //!< Point at which to determine angle
      ) const {                        //! Returns angle in radians
      return (GetAngleToNorth(point.x,point.y));
      }

   //! Get map projection parameters.
   const MAPPROJPARM& GetProjection (
      ) const {                        //! Returns projection parameters
      MAPPROJPARM *projparm = gctpGetParm(m_gctph,0);
      return (*projparm);
      }

protected:

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT
   void *m_gctph;                      //!< GCTP handle

   friend bool operator== (const TRANS2D_CARTO&, const TRANS2D_CARTO&);
   #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! Compare TRANS2D_CARTOs for equality.
inline bool operator== (
   const TRANS2D_CARTO& lhs,
   const TRANS2D_CARTO& rhs
   ) {
   return (!gctpCompare(lhs.m_gctph,rhs.m_gctph));
   }

//! Compare TRANS2D_CARTOs for inequality.
inline bool operator!= (
   const TRANS2D_CARTO& lhs,
   const TRANS2D_CARTO& rhs
   ) {
   return (!operator==(lhs,rhs));
   }


//-------------------------------------------------------------------------------------------
//!      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,reinterpret_cast<const DPOINT2D*>(&ipoint),reinterpret_cast<DPOINT2D*>(&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);
         }

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

      //! 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,reinterpret_cast<const DPOINT2D*>(&ipoint),reinterpret_cast<DPOINT2D*>(&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 point from "map" to "input" coordinates.
      ERRVALUE ConvertMapToInput (
         const DPOINT2D& ipoint,          //!< Point to convert
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointMapToInput(&m_transparm,&ipoint,&opoint)); }

      //! 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 "map" to "output" coordinates.
      ERRVALUE ConvertMapToOutput (
         const DPOINT2D& ipoint,          //!< Point to convert
         DPOINT2D& opoint                 //!< Output point
         ) const { return (TransGenConvPointMapToOutput(&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);
         return;
         }

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

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

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

      //! 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 projection parameters.
      MAPPROJPARM GetInputProjection (
         ) const {                        //! Returns projection parameters
         MAPPROJPARM projparm;
         TransGenGetInputProj(&m_transparm,&projparm);
         return (projparm);
         }

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

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

      //! 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 projection parameters.
      MAPPROJPARM GetOutputProjection (
         ) const {                        //! Returns projection parameters
         MAPPROJPARM projparm;
         TransGenGetOutputProj(&m_transparm,&projparm);
         return (projparm);
         }

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

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

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

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

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

      //! Determine if transformation is "reversible".
      bool IsReversible (
         ) const {                        //! Returns true if reversible, false if not
         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).
      void 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)
         ) {
         int err;
         if ((err = TransGenSetAffineApprox(&m_transparm,&rect,tolerance,static_cast<UINT32>(coord))) < 0) {
            //! XXX throw an exception
            }
         return;
         }

      //! 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);
         Tra