coordop.h

Go to the documentation of this file.

/**
 * \file coordop.h <mi32/coordop.h>
 * \brief Coordinate Operation (COORDOP) class definitions
 *
 * \if NODOC
 * $Id: coordop.h_v 1.9 2006/02/20 21:15:26 mju Exp $
 *
 * $Log: coordop.h_v $
 * Revision 1.9  2006/02/20 21:15:26  mju
 * Make impl_list friend of impl.
 *
 * Revision 1.8  2006/02/17 18:42:38  mju
 * Add parm to disable range checking.
 *
 * Revision 1.7  2005/04/12 17:35:32  mju
 * Add op_single.ReleaseAttached.
 *
 * Revision 1.6  2004/08/09 17:16:23  mju
 * Fix unix warning.
 *
 * Revision 1.5  2004/07/12 16:58:03  mju
 * Forgot to export coordop_zoned from dll.
 *
 * Revision 1.4  2004/07/12 15:59:14  mju
 * Add zoned conversion from string.
 *
 * Revision 1.3  2004/07/12 15:18:48  mju
 * Change op_str to op_zoned.
 *
 * Revision 1.1  2004/06/17 17:42:38  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_COORDOP_H
#define  INC_MI32_COORDOP_H

#ifndef  INC_MI32_MILIST_H
#include <mi32/milist.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

#ifndef  INC_MI32_SPATREF_H
#include <mi32/spatref.h>
#endif

#ifdef GEOMDLL
   #define CLASSLIBEXPORT MI_DLLCLASSEXPORT
#else
   #define CLASSLIBEXPORT MI_DLLCLASSIMPORT
#endif

// Forward declarations.
#ifndef GENERATING_DOXYGEN_OUTPUT
class REGION2D;
struct CTRLPOINT;
struct CTRLPOINT3;
namespace SPATREF {
   class COORDOP;
   class COORDOP_SINGLE;
   class COORDOP_LIST;
   class COORDOP_IMPL_LINEAR;
   class COORDOP_IMPL_LIST;
   }
#endif


namespace SPATREF {

enum COORDOP_DIRECTION {
   COORDOP_DIRECTION_Reverse = -1,
   COORDOP_DIRECTION_Forward = 1
   };

//=====================================================================================================================
//! Target for densification operations.

class CLASSLIBEXPORT COORDOP_TARGET {
   public:

      //! Called before first input vertex processed.
      ERRVALUE OnBegin (
         ) { return (v_OnBegin()); }

      //! Called after last input vertex processed.
      ERRVALUE OnEnd (
         ) { return (v_OnEnd()); }

      //! Called for each dense point generated.
      ERRVALUE OnPoint (
         const double* pPoint,      //!< Pointer to point of output dimension
         INT32 InVertexNum,         //!< Vertex number in input array associated with point
         INT32 SubVertexNum         //!< Sub-vertex number, 0 if at input vertex
         ) { return (v_OnPoint(pPoint,InVertexNum,SubVertexNum)); }

   private:
      // Overridables.

      //! Called before first input vertex processed.
      virtual ERRVALUE v_OnBegin (
         );

      //! Called after last input vertex processed.
      virtual ERRVALUE v_OnEnd (
         );

      //! Called for each dense point generated.
      virtual ERRVALUE v_OnPoint (
         const double* pPoint,      //!< Pointer to point of output dimension
         INT32 InVertexNum,         //!< Vertex number in input array associated with point
         INT32 SubVertexNum         //!< Sub-vertex number within densified 'segment', 0 if at input vertex
         ) = 0;
   };

//=====================================================================================================================

//! Base for coordinate operation implementation.
class CLASSLIBEXPORT COORDOP_IMPL {
   public:

      class CLASSLIBEXPORT LINEAR {
         public:

            //! Default constructor.
            LINEAR () { SetIdentity(); }

            //! Copy constructor.
            LINEAR (const LINEAR&);

            //! Combination constructor.
            LINEAR (const LINEAR& lhs, const LINEAR& rhs);

            //! Destructor.
            ~LINEAR () { }

            //! Assignment.
            LINEAR& operator= (const LINEAR&);

            //! Apply scale to axes.
            void ApplyScale (
               double scaleX,
               double scaleY,
               double scaleZ = 1,
               bool reverse = false             //!< Specified values apply to reverse direction
               );

            //! Apply scale to X/Y axes using DPOINT2D.
            void ApplyScale (
               const DPOINT2D& scale,
               bool reverse = false             //!< Specified values apply to reverse direction
               ) { ApplyScale(scale.x,scale.y,1.0,reverse); }

            //! Apply scale to axes using DPOINT3D.
            void ApplyScale (
               const DPOINT3D& scale,
               bool reverse = false             //!< Specified values apply to reverse direction
               ) { ApplyScale(scale.x,scale.y,scale.z,reverse); }

            //! Apply translation to origin.
            void ApplyTranslation (
               double transX,
               double transY,
               double transZ = 0,
               bool reverse = false             //!< Specified values apply to reverse direction
               );

            //! Apply translation to origin X/Y using DPOINT2D.
            void ApplyTranslation (
               const DPOINT2D& trans,
               bool reverse = false             //!< Specified values apply to reverse direction
               ) { ApplyTranslation(trans.x,trans.y,0,reverse); }

            //! Apply translation to origin using DPOINT3D..
            void ApplyTranslation (
               const DPOINT3D& trans,
               bool reverse = false             //!< Specified values apply to reverse direction
               ) { ApplyTranslation(trans.x,trans.y,trans.z,reverse); }

            //! Compute (2D) linear transformation using CTRLPOINT array.
            ERRVALUE Compute (
               const CTRLPOINT *CtrlPoints,
               int NumPoints
               );

            //! Compute linear transformation using CTRLPOINT3 array.
            ERRVALUE Compute (
               const CTRLPOINT3 *CtrlPoints,
               int NumPoints
               );

            //! Perform forward operation on DPOINT2D.
            //! Note, the output point must not be the same as the input point.
            void ConvertForward (
               const DPOINT2D& ipoint,          //!< Input point
               DPOINT2D& opoint                 //!< Output point
               ) const {
               opoint.x = m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][3];
               opoint.y = m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][3];
               }

            //! Perform forward operation on DPOINT2D.
            //! @return Converted point.
            DPOINT2D ConvertForward (
               const DPOINT2D& ipoint           //!< Input point
               ) const {
               return (DPOINT2D(
                  (m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][3]),
                  (m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][3])
                  ));
               }

            //! Perform forward operation on DPOINT3D.
            //! Note, the output point must not be the same as the input point.
            void ConvertForward (
               const DPOINT3D& ipoint,          //!< Input point
               DPOINT3D& opoint                 //!< Output point
               ) const {
               opoint.x = m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][2] * ipoint.z + m_Fwd[0][3];
               opoint.y = m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][2] * ipoint.z + m_Fwd[1][3];
               opoint.z = m_Fwd[2][0] * ipoint.x + m_Fwd[2][1] * ipoint.y + m_Fwd[2][2] * ipoint.z + m_Fwd[2][3];
               }

            //! Perform forward operation on DPOINT3D.
            //! @return Converted point.
            DPOINT3D ConvertForward (
               const DPOINT3D& ipoint           //!< Input point
               ) const {
               return (DPOINT3D(
                  (m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][2] * ipoint.z + m_Fwd[0][3]),
                  (m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][2] * ipoint.z + m_Fwd[1][3]),
                  (m_Fwd[2][0] * ipoint.x + m_Fwd[2][1] * ipoint.y + m_Fwd[2][2] * ipoint.z + m_Fwd[2][3])
                  ));
               }

            //! Perform forward operation on DPOINT3DH.
            //! Note, the output point must not be the same as the input point.
            void ConvertForward (
               const DPOINT3DH& ipoint,            //!< Input point
               DPOINT3DH& opoint                //!< Output point
               ) const {
               opoint.x = m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][2] * ipoint.z + m_Fwd[0][3] * ipoint.w;
               opoint.y = m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][2] * ipoint.z + m_Fwd[1][3] * ipoint.w;
               opoint.z = m_Fwd[2][0] * ipoint.x + m_Fwd[2][1] * ipoint.y + m_Fwd[2][2] * ipoint.z + m_Fwd[2][3] * ipoint.w;
               opoint.w = m_Fwd[3][0] * ipoint.x + m_Fwd[3][1] * ipoint.y + m_Fwd[3][2] * ipoint.z + m_Fwd[3][3] * ipoint.w;
               }

            //! Perform forward operation on DPOINT3DH.
            //! @return Converted point.
            DPOINT3DH ConvertForward (
               const DPOINT3DH& ipoint          //!< Input point
               ) const {
               return (DPOINT3DH(
                  (m_Fwd[0][0] * ipoint.x + m_Fwd[0][1] * ipoint.y + m_Fwd[0][2] * ipoint.z + m_Fwd[0][3] * ipoint.w),
                  (m_Fwd[1][0] * ipoint.x + m_Fwd[1][1] * ipoint.y + m_Fwd[1][2] * ipoint.z + m_Fwd[1][3] * ipoint.w),
                  (m_Fwd[2][0] * ipoint.x + m_Fwd[2][1] * ipoint.y + m_Fwd[2][2] * ipoint.z + m_Fwd[2][3] * ipoint.w),
                  (m_Fwd[3][0] * ipoint.x + m_Fwd[3][1] * ipoint.y + m_Fwd[3][2] * ipoint.z + m_Fwd[3][3] * ipoint.w)
                  ));
               }

            //! Perform reverse operation on DPOINT2D.
            //! Note, the output point must not be the same as the input point.
            void ConvertReverse (
               const DPOINT2D& ipoint,          //!< Input point
               DPOINT2D& opoint                 //!< Output point
               ) const {
               opoint.x = m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][3];
               opoint.y = m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][3];
               }

            //! Perform reverse operation on DPOINT2D.
            //! @return Converted point.
            DPOINT2D ConvertReverse (
               const DPOINT2D& ipoint           //!< Input point
               ) const {
               return (DPOINT2D(
                  (m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][3]),
                  (m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][3])
                  ));
               }

            //! Perform reverse operation on DPOINT3D.
            //! Note, the output point must not be the same as the input point.
            void ConvertReverse (
               const DPOINT3D& ipoint,          //!< Input point
               DPOINT3D& opoint                 //!< Output point
               ) const {
               opoint.x = m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][2] * ipoint.z + m_Rev[0][3];
               opoint.y = m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][2] * ipoint.z + m_Rev[1][3];
               opoint.z = m_Rev[2][0] * ipoint.x + m_Rev[2][1] * ipoint.y + m_Rev[2][2] * ipoint.z + m_Rev[2][3];
               }

            //! Perform reverse operation on DPOINT3D.
            //! @return Converted point.
            DPOINT3D ConvertReverse (
               const DPOINT3D& ipoint           //!< Input point
               ) const {
               return (DPOINT3D(
                  (m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][2] * ipoint.z + m_Rev[0][3]),
                  (m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][2] * ipoint.z + m_Rev[1][3]),
                  (m_Rev[2][0] * ipoint.x + m_Rev[2][1] * ipoint.y + m_Rev[2][2] * ipoint.z + m_Rev[2][3])
                  ));
               }

            //! Perform reverse operation on DPOINT3DH.
            //! Note, the output point must not be the same as the input point.
            void ConvertReverse (
               const DPOINT3DH& ipoint,            //!< Input point
               DPOINT3DH& opoint                //!< Output point
               ) const {
               opoint.x = m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][2] * ipoint.z + m_Rev[0][3] * ipoint.w;
               opoint.y = m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][2] * ipoint.z + m_Rev[1][3] * ipoint.w;
               opoint.z = m_Rev[2][0] * ipoint.x + m_Rev[2][1] * ipoint.y + m_Rev[2][2] * ipoint.z + m_Rev[2][3] * ipoint.w;
               opoint.w = m_Rev[3][0] * ipoint.x + m_Rev[3][1] * ipoint.y + m_Rev[3][2] * ipoint.z + m_Rev[3][3] * ipoint.w;
               }

            //! Perform reverse operation on DPOINT3DH.
            //! @return Converted point.
            DPOINT3DH ConvertReverse (
               const DPOINT3DH& ipoint          //!< Input point
               ) const {
               return (DPOINT3DH(
                  (m_Rev[0][0] * ipoint.x + m_Rev[0][1] * ipoint.y + m_Rev[0][2] * ipoint.z + m_Rev[0][3] * ipoint.w),
                  (m_Rev[1][0] * ipoint.x + m_Rev[1][1] * ipoint.y + m_Rev[1][2] * ipoint.z + m_Rev[1][3] * ipoint.w),
                  (m_Rev[2][0] * ipoint.x + m_Rev[2][1] * ipoint.y + m_Rev[2][2] * ipoint.z + m_Rev[2][3] * ipoint.w),
                  (m_Rev[3][0] * ipoint.x + m_Rev[3][1] * ipoint.y + m_Rev[3][2] * ipoint.z + m_Rev[3][3] * ipoint.w)
                  ));
               }

            //! Reverse direction of operation.
            void Reverse (
               );

            //! Set to identity operation.
            void SetIdentity (
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            void ApplyMatrix(const MAT4X4 mat, bool reverse);
            MAT4X4 m_Fwd;
            MAT4X4 m_Rev;
            #endif
         };

      //! Destructor.
      virtual ~COORDOP_IMPL (
         );

      // Increment reference count.
      void AddRef (
         ) { ++m_RefCount; }

      //! Compute approximated linear transformation if within specified tolerance.
      //! Regardless of direction specified, any returned LINEAR operation will have the same direction
      //! as the operation instance itself.
      //! @return TRUE if approximation valid, FALSE if not, < 0 if error
      int ComputeLinearApproximation (
         COORDOP_DIRECTION direction,        //!< Direction in which to perform approximation
         const REGION2D& region,             //!< Region in 'input' CRS based on specified direction
         double tolerance,                   //!< Tolerance in 'output' CRS based on specified direction
         LINEAR& Linear                      //!< Linear approximation returned if available
         ) const;

      //! Perform forward operation on DPOINT2D array.
      ERRVALUE ConvertForward (
         const DPOINT2D* ipoints,            //!< Input point array
         DPOINT2D* opoints,                  //!< Output point array
         INT32 NumPoints                     //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertForward(*ipoints++);
               return (0);
               }
            else return (v_ConvertForward(ipoints,opoints,NumPoints));
            }

      //! Perform forward operation on DPOINT3D array.
      ERRVALUE ConvertForward (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertForward(*ipoints++);
               return (0);
               }
            else return (v_ConvertForward(ipoints,opoints,NumPoints));
            }

      //! Perform forward operation on DPOINT3DH array.
      ERRVALUE ConvertForward (
         const DPOINT3DH* ipoints,        //!< Input point array
         DPOINT3DH* opoints,              //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertForward(*ipoints++);
               return (0);
               }
            else return (v_ConvertForward(ipoints,opoints,NumPoints));
            }

      //! Perform forward operation with possible densification.
      ERRVALUE ConvertForwardDense (
         INT32 NumPoints,                 //!< Number of points
         int NumDim,                      //!< Number of dimensions (usually 2, 3 or 4 (indicates homogeneous))
         const double *ipoint,            //!< Input point array of specified dimension
         double tolerance,                //!< Densification tolerance in target coordinates
         COORDOP_TARGET& target           //!< Target for converted points
         ) const;

      //! Perform reverse operation on DPOINT2D array.
      ERRVALUE ConvertReverse (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertReverse(*ipoints++);
               return (0);
               }
            else return (v_ConvertReverse(ipoints,opoints,NumPoints));
            }

      //! Perform reverse operation on DPOINT3D array.
      ERRVALUE ConvertReverse (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertReverse(*ipoints++);
               return (0);
               }
            else return (v_ConvertReverse(ipoints,opoints,NumPoints));
            }

      //! Perform reverse operation on DPOINT3DH array.
      ERRVALUE ConvertReverse (
         const DPOINT3DH* ipoints,        //!< Input point array
         DPOINT3DH* opoints,              //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const {
            if (IsLinear()) {
               for (INT32 p = 0; (p < NumPoints); ++p)
                  *opoints++ = m_Linear.ConvertReverse(*ipoints++);
               return (0);
               }
            else return (v_ConvertReverse(ipoints,opoints,NumPoints));
            }

      //! Perform reverse operation with possible densification.
      ERRVALUE ConvertReverseDense (
         INT32 NumPoints,                 //!< Number of points
         int NumDim,                      //!< Number of dimensions (usually 2, 3 or 4 (indicates homogeneous))
         const double *ipoint,            //!< Input point array of specified dimension
         double tolerance,                //!< Densification tolerance in target coordinates
         COORDOP_TARGET& target           //!< Target for converted points
         ) const;

      //! Get linear implementation if operation is linear.
      const LINEAR& GetLinear (
         ) const { return (m_Linear); }

      //! Get source coordinate reference system description.
      const COORDREFSYS& GetSourceCRS (
         ) const { return (m_SourceCRS); }

      //! Get target coordinate reference system description.
      const COORDREFSYS& GetTargetCRS (
         ) const { return (m_TargetCRS); }

      //! Determine if forward operation is supported.
      bool HasForward (
         ) const { return (m_HasForward); }

      //! Determine if reverse operation is supported.
      bool HasReverse (
         ) const { return (m_HasReverse); }

      //! Determine if both forward and reverse operations are supported.
      bool IsBidirectional (
         ) const { return (m_HasForward && m_HasReverse); }

      //! Determine if operation is linear.
      bool IsLinear (
         ) const { return (m_IsLinear); }

      // Release reference, destroying if last one.
      void Release ();

      //! Set source region over which operation is valid.
      ERRVALUE SetSourceRegion (
         const REGION2D& region              //!< Region in source coordinate reference system
         );

      //! Set target region over which operation is valid.
      ERRVALUE SetTargetRegion (
         const REGION2D& region              //!< Region in target coordinate reference system
         );

   protected:

      enum TYPE {
         TYPE_Identity,
         TYPE_Single,
         TYPE_List
         };

      //! Default constructor.
      explicit COORDOP_IMPL (
         TYPE type,
         bool IsLinear = false
         );

      //! Copy constructor.
      COORDOP_IMPL (
         const COORDOP_IMPL& rhs
         );

      bool GetDisableRangeCheck (
         ) const { return (m_DisableRangeCheck); }

      //! Get operation type.
      TYPE GetType (
         ) const { return (m_Type); }

      void SetDisableRangeCheck (
         bool DisableRangeCheck
         ) { m_DisableRangeCheck = DisableRangeCheck; }

      //! Set to use specified linear implementation.
      void SetLinear (
         const LINEAR& Linear
         ) { m_IsLinear = true; m_Linear = Linear; }

      //! Set operation to be nonlinear.
      void SetNonLinear (
         ) { m_IsLinear = false; }

      //! Set source coordinate reference system.
      void SetSourceCRS (
         const COORDREFSYS& SourceCRS
         ) { m_SourceCRS = SourceCRS; }

      //! Set target coordinate reference system.
      void SetTargetCRS (
         const COORDREFSYS& TargetCRS
         ) { m_TargetCRS = TargetCRS; }

      //! Set valid directions.
      void SetValidDirections (
         bool hasForward,
         bool hasReverse
         ) { m_HasForward = hasForward; m_HasReverse = hasReverse; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      // Explicitly initialized.
      int m_RefCount;
      TYPE m_Type;
      bool m_IsLinear;
      bool m_HasForward;
      bool m_HasReverse;
      bool m_DisableRangeCheck;
      // Self initializing.
      COORDREFSYS m_SourceCRS;
      COORDREFSYS m_TargetCRS;
      LINEAR m_Linear;                       // Linear implementation

      // Conversion with densification.
      ERRVALUE ConvertDense (
         INT32 NumPoints,                 // Number of points
         int NumDim,                      // Number of dimensions (usually 2, 3 or 4 (indicates homogeneous))
         const double *ipoint,            // Input point array of specified dimension
         COORDOP_DIRECTION direction,     // Operation direction
         double tolerance,                // Densification tolerance in target coordinates
         COORDOP_TARGET& target           // Target for converted points
         ) const;

      // Copy implementation instance.
      COORDOP_IMPL* Copy (
         ) const { return (v_Copy()); }

      // Get reference count.
      int GetRefCount () const { return (m_RefCount); }

      // Reverse direction of operation.
      void Reverse ();

      // Assignment unimplemented.
      COORDOP_IMPL& operator= (const COORDOP_IMPL&);

      friend class SPATREF::COORDOP;
      friend class SPATREF::COORDOP_SINGLE;
      friend class SPATREF::COORDOP_LIST;
      friend class SPATREF::COORDOP_IMPL_LINEAR;
      friend class SPATREF::COORDOP_IMPL_LIST;

      #endif // GENERATING_DOXYGEN_OUTPUT

      // Overridables

      //! Perform forward operation on DPOINT2D array.
      virtual ERRVALUE v_ConvertForward (const DPOINT2D* ipoints, DPOINT2D* opoints, INT32 NumPoints) const = 0;

      //! Perform forward operation on DPOINT3D array.
      virtual ERRVALUE v_ConvertForward (const DPOINT3D* ipoints, DPOINT3D* opoints, INT32 NumPoints) const = 0;

      //! Perform forward operation on DPOINT3DH array.
      virtual ERRVALUE v_ConvertForward (const DPOINT3DH* ipoints, DPOINT3DH* opoints, INT32 NumPoints) const = 0;

      //! Perform reverse operation on DPOINT2D array.
      virtual ERRVALUE v_ConvertReverse (const DPOINT2D* ipoints, DPOINT2D* opoints, INT32 NumPoints) const = 0;

      //! Perform reverse operation on DPOINT3D array.
      virtual ERRVALUE v_ConvertReverse (const DPOINT3D* ipoints, DPOINT3D* opoints, INT32 NumPoints) const = 0;

      //! Perform reverse operation on DPOINT3DH array.
      virtual ERRVALUE v_ConvertReverse (const DPOINT3DH* ipoints, DPOINT3DH* opoints, INT32 NumPoints) const = 0;

      //! Construct copy of instance.
      virtual COORDOP_IMPL* v_Copy () const = 0;

      //! Reverse operation direction.
      virtual void v_Reverse () = 0;

   };


//=====================================================================================================================
//! Coordinate Operation (conversion/transformation) service.
//! Coordinate operatiosn instances are reference-counted so that assignment and
//! list manipulation is efficient and requires no additional memory allocation.
class CLASSLIBEXPORT COORDOP {
   public:

      //! Copy constructor.
      COORDOP (
         const COORDOP& rhs
         );

      //! Destructor.
      ~COORDOP (
         );

      //! Assignment.
      COORDOP& operator= (
         const COORDOP& rhs
         );

      //! Perform forward operation on DPOINT2D
      ERRVALUE ConvertForward (
         const DPOINT2D& ipoint,          //!< Input point
         DPOINT2D& opoint                 //!< Output point
         ) const { return (m_pImpl->ConvertForward(&ipoint,&opoint,1)); }

      //! Perform forward operation on DPOINT3D.
      ERRVALUE ConvertForward (
         const DPOINT3D& ipoint,          //!< Input point
         DPOINT3D& opoint                 //!< Output point
         ) const { return (m_pImpl->ConvertForward(&ipoint,&opoint,1)); }

      //! Perform forward operation on DPOINT3DH.
      ERRVALUE ConvertForward (
         const DPOINT3DH& ipoint,         //!< Input point
         DPOINT3DH& opoint                //!< Output point
         ) const { return (m_pImpl->ConvertForward(&ipoint,&opoint,1)); }

      //! Perform forward operation 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 (m_pImpl->ConvertForward(ipoints,opoints,NumPoints)); }

      //! Perform forward operation 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 (m_pImpl->ConvertForward(ipoints,opoints,NumPoints)); }

      //! Perform forward operation on DPOINT3DH array.
      ERRVALUE ConvertForward (
         const DPOINT3DH* ipoints,        //!< Input point array
         DPOINT3DH* opoints,              //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (m_pImpl->ConvertForward(ipoints,opoints,NumPoints)); }

      //! Perform forward operation with possible densification.
      ERRVALUE ConvertForwardDense (
         INT32 NumPoints,                 //!< Number of points
         int NumDim,                      //!< Number of dimensions (usually 2, 3 or 4 (indicates homogeneous))
         const double *ipoint,            //!< Input point array of specified dimension
         double tolerance,                //!< Densification tolerance in target coordinates
         COORDOP_TARGET& target              //!< Target for converted points
         ) const { return (m_pImpl->ConvertForwardDense(NumPoints,NumDim,ipoint,tolerance,target)); }

      //! Perform reverse operation on DPOINT2D
      ERRVALUE ConvertReverse (
         const DPOINT2D& ipoint,          //!< Input point
         DPOINT2D& opoint                 //!< Output point
         ) const { return (m_pImpl->ConvertReverse(&ipoint,&opoint,1)); }

      //! Perform reverse operation on DPOINT3D.
      ERRVALUE ConvertReverse (
         const DPOINT3D& ipoint,          //!< Input point
         DPOINT3D& opoint                 //!< Output point
         ) const { return (m_pImpl->ConvertReverse(&ipoint,&opoint,1)); }

      //! Perform reverse operation on DPOINT3DH.
      ERRVALUE ConvertReverse (
         const DPOINT3DH& ipoint,            //!< Input point
         DPOINT3DH& opoint                //!< Output point
         ) const { return (m_pImpl->ConvertReverse(&ipoint,&opoint,1)); }

      //! Perform reverse operation on DPOINT2D array.
      ERRVALUE ConvertReverse (
         const DPOINT2D* ipoints,         //!< Input point array
         DPOINT2D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (m_pImpl->ConvertReverse(ipoints,opoints,NumPoints)); }

      //! Perform reverse operation on DPOINT3D array.
      ERRVALUE ConvertReverse (
         const DPOINT3D* ipoints,         //!< Input point array
         DPOINT3D* opoints,               //!< Output point array
         INT32 NumPoints                  //!< Number of points to convert
         ) const { return (m_pImpl->ConvertReverse(ipoints,opoints,NumPoints)); }

      //! Perform reverse operation on DPOINT3DH array.
      ERRVALUE ConvertReverse (
         const DPOINT3DH* ipoints,           //!< Input point array
         DPOINT3DH* opoints,                 //!< Output point array
         INT32 NumPoints                     //!< Number of points to convert
         ) const { return (m_pImpl->ConvertReverse(ipoints,opoints,NumPoints)); }

      //! Perform reverse operation with possible densification.
      ERRVALUE ConvertReverseDense (
         INT32 NumPoints,                    //!< Number of points
         int NumDim,                         //!< Number of dimensions (usually 2, 3 or 4 (indicates homogeneous))
         const double *ipoint,               //!< Input point array of specified dimension
         double tolerance,                   //!< Densification tolerance in target coordinates
         COORDOP_TARGET& target              //!< Target for converted points
         ) const { return (m_pImpl->ConvertReverseDense(NumPoints,NumDim,ipoint,tolerance,target)); }

      //! Get linear implementation instance for subsequent fast inline conversion.
      //! Note: If IsLinear() returns false then the returned LINEAR operation will not be valid.
      const COORDOP_IMPL::LINEAR& GetLinear (
         ) const { return (m_pImpl->GetLinear()); }

      //! Attempt to get linear approximation to operation within specified tolerance.
      //! Regardless of direction specified, any returned LINEAR operation will have the same direction
      //! as the operation instance itself.
      //! @return TRUE if returned operation is linear, FALSE if not, < 0 if error.
      int GetLinearApproximation (
         COORDOP& CoordOp,                   //!< Coordinate operation returned
         COORDOP_DIRECTION direction,        //!< Direction in which to perform approximation
         const REGION2D& region,             //!< Region in 'input' CRS based on specified direction
         double tolerance                    //!< Tolerance in 'output' CRS based on specified direction
         ) const;

      //! Get source coordinate reference system description.
      const COORDREFSYS& GetSourceCRS (
         ) const { return (m_pImpl->GetSourceCRS()); }

      //! Get target coordinate reference system description.
      const COORDREFSYS& GetTargetCRS (
         ) const { return (m_pImpl->GetTargetCRS()); }

      //! Determine if forward operation is supported.
      bool HasForward (
         ) const { return (m_pImpl->HasForward()); }

      //! Determine if reverse operation is supported.
      bool HasReverse (
         ) const { return (m_pImpl->HasReverse()); }

      //! Determine if both forward and reverse operations are supported.
      bool IsBidirectional (
         ) const { return (m_pImpl->IsBidirectional()); }

      bool IsIdentity (
         ) const { return (m_pImpl->m_Type == COORDOP_IMPL::TYPE_Identity); }

      //! Determine if linear transformation available.
      bool IsLinear (
         ) const { return (m_pImpl->IsLinear()); }

      //! Determine if operation uses a list.
      bool IsList (
         ) const { return (m_pImpl->m_Type == COORDOP_IMPL::TYPE_List); }

      //! Reverse direction of operation.
      void ReverseDirection (
         );

   protected:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      COORDOP_IMPL *m_pImpl;
      COORDOP ();
      void GetExclusive ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================
//! Coordinate Operation service with attach/detach interface for use with
//! operation implementations not created automatically by spatial reference system.
class CLASSLIBEXPORT COORDOP_SINGLE : public COORDOP {
   public:

      //! Default constructor.
      //! Operation will reference 'null' implementation until Attach() or Create().
      COORDOP_SINGLE (
         );

      //! Construct and attach implementation instance.
      //! After attachment, COORDOP instance is responsible for deletion and the
      //! passed-in pointer will be set to NULL.
      //! Used when implementation instance is manually created.
      COORDOP_SINGLE (
         COORDOP_IMPL *& pImpl            //!< Operation implementation to attach
         );

      //! Attach implemention to operation container.
      //! After attachment, COORDOP instance is responsible for deletion and the
      //! passed-in pointer will be set to NULL.
      //! Used when implementation instance is manually created.
      void Attach (
         COORDOP_IMPL *& pImpl            //!< Operation implementation to attach
         );

      //! Create operation using operation definition.
      //! Not for use with concatenated coordinate operation.
      ERRVALUE Create (
         const COORDOPDEF& CoordOpDef,    //!< Coordinate operation definition
         const COORDREFSYS& SourceCRS,
         const COORDREFSYS& TargetCRS,
         bool DisableRangeCheck = false   //!< Disable range check where supported
         );

      //! Detach implementation from operation container.
      //! @return Pointer to implementation instance, caller responsible for deletion.
      //! Operation will reference 'null' implementation after detachment.
      COORDOP_IMPL* Detach (
         );

      //! Release attached implementation if any.
      void ReleaseAttached (
         );

   };


//=====================================================================================================================
//! Coordinate Operation service with list management interface.
class CLASSLIBEXPORT COORDOP_LIST : public COORDOP {
   public:

      //! Default constructor.
      COORDOP_LIST (
         );

      //! Copy constructor.
      COORDOP_LIST (
         const COORDOP_LIST& rhs
         );

      //! Construct from COORDOP.
      COORDOP_LIST (
         const COORDOP& rhs
         );

      //! Assignment.
      COORDOP_LIST& operator= (
         const COORDOP_LIST& rhs
         );

      //! Assignment from COORDOP.
      COORDOP_LIST& operator= (
         const COORDOP& rhs
         );

      //! Add operation to end.
      //! Any linear approximation and target region settings will be lost.
      ERRVALUE AddEnd (
         const COORDOP& operation         //!< Operation to add
         );

      //! Add operation list to end.
      //! Any linear approximation and target region settings will be lost.
      ERRVALUE AddEnd (
         const COORDOP_LIST& oplist       //!< Operation list to add
         );

      //! Attempt to add operations to end of list to achieve specified target CRS.
      //! If specified CRS matches current target then no operations will be added and 0 will be returned.
      //! Any linear approximation and target region settings will be lost.
      //! @return Number of operations actually added or error < 0
      int AddEnd (
         const COORDREFSYS& TargetCRS     //! Desired target coordinate reference system
         );

      //! Add operation to start of operation list.
      //! Any linear approximation and source region settings will be lost.
      ERRVALUE AddStart (
         const COORDOP& operation         //!< Operation to add
         );

      //! Add operation list to start.
      //! Any linear approximation and source region settings will be lost.
      ERRVALUE AddStart (
         const COORDOP_LIST& oplist       //!< Operation list to add
         );

      //! Attempt to add operations to start of list to achieve specified source CRS.
      //! If specified CRS matches current source then no operations will be added and 0 will be returned.
      //! Any linear approximation and source region settings will be lost.
      //! @return Number of operations actually added or error < 0
      int AddStart (
         const COORDREFSYS& SourceCRS     //!< Desired source coordinate reference system
         );

      //! Clear operation list, reverting to empty/undefined.
      void Clear (
         );

      //! Create operation using operation definition.
      //! Source and target CRS are determined from operation definition, may not be used
      //! with projection definition obtained from a projected CRS.
      ERRVALUE Create (
         const COORDOPDEF& CoordOpDef,    //!< Coordinate operation definition
         bool DisableRangeCheck = false   //!< Disable range check where supported
         );

      //! Create operation list for conversion between specified coordinate reference systems.
      ERRVALUE Create (
         const COORDREFSYS& SourceCRS,    //!< Source coordinate reference system
         const COORDREFSYS& TargetCRS,    //!< Target coordinate reference system
         bool DisableRangeCheck = false   //!< Disable range check where supported
         );

      //! Remove operation at end of operation list.
      //! Any linear approximation and target region settings will be lost.
      void RemoveEnd (
         );

      //! Remove operation at start of operation list.
      //! Any linear approximation and source region settings will be lost.
      void RemoveStart (
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ERRVALUE Create (const COORDREFSYS& CoordRefSys, bool DisableRangeCheck);
      const MILIST<COORDOP>& GetOpListMin () const;

      friend class COORDOP_IMPL_LIST;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

class COORDOPZONED_IMPL;

//! Service for converting between 'zoned' and non-zoned reference systems.
class CLASSLIBEXPORT COORDOP_ZONED {
   public:

      //! Constructor.
      COORDOP_ZONED (
         );

      //! Copy constructor.
      COORDOP_ZONED (
         const COORDOP_ZONED& rhs
         );

      //! Destructor.
      ~COORDOP_ZONED (
         );

      //! Assignment.
      COORDOP_ZONED& operator= (
         const COORDOP_ZONED& rhs
         );

      //! Convert zone and DPOINT2D to non-zoned CRS
      ERRVALUE ConvertFromZoned (
         const MISTRING& zonestr,               //!< Zone string for point
         const DPOINT2D& ipoint,                //!< Point to convert
         const COORDREFSYS& PointCoordRefSys,   //!< Non-zoned coordinate reference system to convert to
         DPOINT2D& opoint                       //!< Point returned
         ) const;

      //! Convert zone and DPOINT3D to non-zoned CRS
      ERRVALUE ConvertFromZoned (
         const MISTRING& zonestr,               //!< Zone string for point
         const DPOINT3D& ipoint,                //!< Point to convert
         const COORDREFSYS& PointCoordRefSys,   //!< Non-zoned coordinate reference system to convert to
         DPOINT3D& opoint                       //!< Point returned
         ) const;

      //! Parse and convert string to non-zoned CRS
      ERRVALUE ConvertFromZoned (
         const MISTRING& string,                //!< String to parse
         const COORDREFSYS& PointCoordRefSys,   //!< Non-zoned coordinate reference system to convert to
         DPOINT2D& opoint                       //!< Point returned
         ) const;

      //! Convert DPOINT2D to zoned CRS.
      ERRVALUE ConvertToZoned (
         const COORDREFSYS& PointCoordRefSys,   //!< Coordinate reference system to convert from
         const DPOINT2D& ipoint,                //!< Point to convert
         MISTRING& zonestr,                     //!< Zone string returned
         DPOINT2D& opoint                       //!< Point returned
         ) const;

      //! Convert DPOINT3D to zoned CRS.
      ERRVALUE ConvertToZoned (
         const COORDREFSYS& PointCoordRefSys,   //!< Coordinate reference system to convert from
         const DPOINT3D& ipoint,                //!< Point to convert
         MISTRING& zonestr,                     //!< Zone string returned
         DPOINT3D& opoint                       //!< Point returned
         ) const;

      //! Set zoned coordinate reference system.
      ERRVALUE SetCoordRefSys (
         const COORDREFSYS& ZonedCRS            //!< Zoned coordinate reference system
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      COORDOPZONED_IMPL *m_pImpl;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//=====================================================================================================================

}  // End namespace SPATREF

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_COORDOP_H

---