mi32/spatref.h

Go to the documentation of this file.

#ifndef  INC_MI32_SPATREF_H
#define  INC_MI32_SPATREF_H

#ifndef  INC_MI32_MISTRING_H
#include <mi32/mistring.h>
#endif

#ifndef  INC_MI32_UOM_H
#include <mi32/uom.h>
#endif

#ifndef  INC_MI32_STRUTF8_H
#include <mi32/strutf8.h>
#endif

#ifndef  INC_MI32_RANGE_H
#include <mi32/range.h>
#endif

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

#ifndef GENERATING_DOXYGEN_OUTPUT
class XMLNODE;
struct CHECKEXE;
struct OLDPROJPARM;
class TEXTRESITEM;
class TEXTRESITEMLIST;
class IDENTIFIER;
class IDENTIFIERLIST;
class POLYLINE;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace SPATREF {

class COORDSYS;
class COORDREFSYS;
class COORDOPDEF;
class COORDOP_IMPL;
class COORDOP_IMPL_SINGLE;

enum GETDISPLAY {
   GETDISPLAY_None =          0x00,
   GETDISPLAY_MicroImagesID = 0x01,    
   GETDISPLAY_SkipName =      0x02,    
   GETDISPLAY_SkipMethod =    0x04,    
   GETDISPLAY_SkipValidArea = 0x08,    
   GETDISPLAY_AllIDs =        0x10,    
   GETDISPLAY_Remarks =       0x20,    
   };
DEFINE_ENUM_OP_BITWISE(GETDISPLAY)

static const INT32 IdNumUserDefinedBase = 50000;

//=====================================================================================================================
class CLASSLIBEXPORT ELLIPSOID {
   public:

      enum IDNUM {
         IDNUM_Undefined =          -1,
         IDNUM_UnitSphere =         1300,
         IDNUM_Clarke_1866 =        1302,
         IDNUM_GRS_1980 =           1301,
         IDNUM_WGS_1984 =           1351,
         };

      enum FORM {
         FORM_Undefined =           0,
         FORM_Sphere =              1,    
         FORM_SemiMinorAxis =       2,    
         FORM_InverseFlattening =   3     
         };

      static IDNUM LookupIdNum (
         double SemiMajorAxis,            
         double SemiMinorAxis,            
         double InverseFlattening = 0     
         );

      ELLIPSOID (
         );

      ELLIPSOID (
         const ELLIPSOID& rhs
         );

      ~ELLIPSOID (
         );

      ELLIPSOID& operator= (
         const ELLIPSOID& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE ComputeDistance (
         const DPOINT2D& point1,
         const DPOINT2D& point2,
         double& distance,
         const UOM::UNIT& PointUnit,
         const UOM::UNIT& LengthUnit
         ) const;

      double ComputeEccentricity (
         ) const;

      double ComputeFlattening (
         ) const;

      ERRVALUE ComputeLength (
         const POLYLINE& polyline,
         double& length,
         const UOM::UNIT& PointUnit,
         const UOM::UNIT& LengthUnit
         ) const;

      void ComputeLinearScale (
         double GeodeticLatitude,               
         DPOINT2D& scale,                       
         UOM::IDNUM LatitudeUnitIdNum = UOM::IDNUM_PlaneAngle_Degree,
         UOM::IDNUM LinearUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;

      void ComputeLinearScale (
         double GeodeticLatitude,               
         DPOINT2D& scale,                       
         const UOM::UNIT& LatitudeUnit,         
         const UOM::UNIT& LinearUnit            
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      FORM GetForm (
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      double GetInverseFlattening (
         ) const;

      const MISTRING& GetName (
         ) const;

      double GetSemiMajorAxis (
         ) const;

      double GetSemiMinorAxis (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      ELLIPSOID (PRIV& Priv);
      bool IsEqual (const ELLIPSOID& rhs) const { return (m_pPriv == rhs.m_pPriv); }
   private:
      PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<ELLIPSOID> ELLIPSOIDLIST;

inline bool operator== (
   const ELLIPSOID& lhs,
   const ELLIPSOID& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const ELLIPSOID& lhs,
   const ELLIPSOID& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }

//=====================================================================================================================
class CLASSLIBEXPORT PRIMEMERIDIAN {
   public:

      enum IDNUM {
         IDNUM_Undefined =          -1,
         IDNUM_Greenwich =          1001
         };

      PRIMEMERIDIAN (
         );

      PRIMEMERIDIAN (
         const PRIMEMERIDIAN& rhs
         );

      ~PRIMEMERIDIAN (
         );

      PRIMEMERIDIAN& operator= (
         const PRIMEMERIDIAN& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      double GetGreenwichLongitude (
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      PRIMEMERIDIAN (PRIV& Priv);
   private:
      PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<PRIMEMERIDIAN> PRIMEMERIDIANLIST;

enum PRIMEMERIDIAN_IDNUM {
   PRIMEMERIDIAN_IDNUM_Greenwich =     1001
   };

//=====================================================================================================================
class CLASSLIBEXPORT DATUM {
   public:

      enum IDNUM {
         IDNUM_Undefined =                -1,
         IDNUM_Local =                    2000,
         IDNUM_WGS_1984 =                 2800,
         IDNUM_WGS_1972 =                 2802,
         IDNUM_AustralianGeodetic_1966 =  2219,
         IDNUM_AustralianGeodetic_1984 =  2220,
         IDNUM_CampoInchauspe =           2233,
         IDNUM_CorregoAlegre =            2245,
         IDNUM_European_1950 =            2260,
         IDNUM_JGD2000 =                  2304,
         IDNUM_NorthAmerican_1927 =       2346,
         IDNUM_NorthAmerican_1983 =       2347,
         IDNUM_NorthAmerican_1983_HARN =  2418,
         IDNUM_SouthAmerican_1969 =       2386,
         IDNUM_Tokyo =                    2393,
         IDNUM_Astronomical_Unspecified = 2700,
         IDNUM_MeanSeaLevel =             2900,
         };

      enum TYPE {
         TYPE_Undefined =     0x0000,
         TYPE_Geodetic =      0x0002,  
         TYPE_Vertical =      0x0004,  
         TYPE_Engineering =   0x0008,  
         TYPE_Temporal =      0x0010,  
         TYPE_Image =         0x0020,  
         TYPE_Astronomical =  0x0040,  
         TYPES_GeorefObject = (TYPE_Geodetic | TYPE_Engineering | TYPE_Astronomical)
         };

      static TEXTID TypeToTextID (
         TYPE type
         );

      DATUM (
         );

      DATUM (
         const DATUM& rhs
         );

      DATUM (
         IDNUM idnum
         );

      ~DATUM (
         );

      DATUM& operator= (
         const DATUM& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      const MISTRING& GetAbbr (
         ) const;

      bool GetDftTransOp (
         const DATUM& datum,                    
         COORDOPDEF& CoordOpDef                 
         ) const;

      const MILIST<COORDOPDEF>& GetDftTransOpList (
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      const ELLIPSOID& GetEllipsoid (
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      const PRIMEMERIDIAN& GetPrimeMeridian (
         ) const;

      TYPE GetType (
         ) const;

      const TEXTRESITEMLIST& GetValidAreaList (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "Datum"
         ) const;

      bool IsAllowedLegacy (
         ) const;

      bool IsConvertible (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      DATUM (PRIV& Priv);
      // Used internally to get legacy datum number.
      INT16 GetLegacyDatumNum (const COORDOPDEF *pDatumTransToWGS84) const;
      // Used internally for initialization.
      PRIV* GetPrivPtr () const { return (m_pPriv); }
      bool IsEqual (const DATUM& rhs) const { return (m_pPriv == rhs.m_pPriv); }
   private:
      PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<DATUM> DATUMLIST;
DEFINE_ENUM_OP_BITWISE(DATUM::TYPE)

inline bool operator== (
   const DATUM& lhs,
   const DATUM& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const DATUM& lhs,
   const DATUM& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }

//=====================================================================================================================
class CLASSLIBEXPORT COORDAXIS {
   public:

      enum IDNUM {
         IDNUM_Undefined =               -1,
         IDNUM_None =                     0,
         IDNUM_GeodeticLatitude =      1101,
         IDNUM_GeodeticLongitude =     1102,
         IDNUM_EllipsoidalHeight =     1103,
         IDNUM_Easting =               1104,
         IDNUM_Northing =              1105,
         IDNUM_Westing =               1106,
         IDNUM_Southing =              1107,
         IDNUM_GravityRelatedHeight =  1108,
         IDNUM_GravityRelatedDepth =   1109,
         IDNUM_GeocentricX =           1110,
         IDNUM_GeocentricY =           1111,
         IDNUM_GeocentricZ =           1112,
         IDNUM_SphericalLatitude =     1113,
         IDNUM_SphericalLongitude =    1114,
         IDNUM_GeocentricRadius =      1115,
         IDNUM_LocalX =                1116,
         IDNUM_LocalY =                1117,
         IDNUM_LocalZ =                1118,
         IDNUM_ImageColumn =           1119,
         IDNUM_ImageRow =              1120,
         IDNUM_RightAscension =        1121,
         IDNUM_Declination =           1122,
         };

      enum SYMBOLUSAGE {
         SYMBOLUSAGE_Unspecified =     0,
         SYMBOLUSAGE_Positive =        1,
         SYMBOLUSAGE_Negative =        2
         };

      COORDAXIS (
         );

      COORDAXIS (
         const COORDAXIS& rhs
         );

      ~COORDAXIS (
         );

      COORDAXIS& operator= (
         const COORDAXIS& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      ERRVALUE Create (
         const UOM::UNIT& unit,                 
         const MISTRING& name,                  
         const MISTRING& SymbolPositive,        
         const MISTRING& SymbolNegative         
         );

      const MISTRING& GetAbbr (
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None     
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      MISTRING GetNameFitted (
         int maxchars,                          
         bool IncludeUnitSymbol                 
         ) const;

      const MISTRING& GetSymbol (
         SYMBOLUSAGE usage = SYMBOLUSAGE_Unspecified
         ) const;

      const UOM::UNIT& GetUnit (
         ) const;

      const DOUBLE_RANGE& GetValidRange (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "CoordAxis"
         ) const;

      bool HasSymbolNegative (
         ) const;

      void SetName (
         const MISTRING& textitem
         );

      void SetSymbolPositive (
         const MISTRING& symbol
         );

      void SetSymbolNegative (
         const MISTRING& symbol
         );

      void SetUnit (
         const UOM::UNIT& unit
         );

      void SetValidRange (
         const DOUBLE_RANGE& ValidRange   
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDAXIS (PRIV& Priv);
      bool IsEqual (const COORDAXIS& rhs) const;
      void SetSymbolPositive (const TEXTRESITEM& textitem);
      void SetSymbolNegative (const TEXTRESITEM& textitem);

   private:
      PRIV *m_pPriv;
      void GetExclusive ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDAXIS> COORDAXISLIST;

inline bool operator== (
   const COORDAXIS& lhs,
   const COORDAXIS& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDAXIS& lhs,
   const COORDAXIS& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }


//=====================================================================================================================
class CLASSLIBEXPORT COORDOPPARM {
   public:

      enum IDNUM {
         IDNUM_Undefined =                                    -1,
         IDNUM_LatitudeOffset =                             1501,
         IDNUM_LongitudeOffset =                            1502,
         IDNUM_VerticalOffset =                             1503,
         IDNUM_GeoidUndulation =                            1504,
         IDNUM_X_AxisTranslation =                          1505,
         IDNUM_Y_AxisTranslation =                          1506,
         IDNUM_Z_AxisTranslation =                          1507,
         IDNUM_X_AxisRotation =                             1508,
         IDNUM_Y_AxisRotation =                             1509,
         IDNUM_Z_AxisRotation =                             1510,
         IDNUM_ScaleDifference =                            1511,
         IDNUM_ScaleFactorForSourceCRSFirstAxis =           1512,
         IDNUM_ScaleFactorForSourceCRSSecondAxis =          1513,
         IDNUM_RotationAngleOfSourceCRSAxes =               1514,
         IDNUM_RotationAngleOfSourceCRSFirstAxis =          1515,
         IDNUM_RotationAngleOfSourceCRSSecondAxis =         1516,
         IDNUM_Ordinate1OfEvaluationPoint =                 1517,
         IDNUM_Ordinate2OfEvaluationPoint =                 1518,
         IDNUM_Ordinate3OfEvaluationPoint =                 1519,
         IDNUM_Ordinate1OfEvaluationPointInSourceCRS =      1520,
         IDNUM_Ordinate2OfEvaluationPointInSourceCRS =      1521,
         IDNUM_Ordinate1OfEvaluationPointInTargetCRS =      1522,
         IDNUM_Ordinate2OfEvaluationPointInTargetCRS =      1523,
         IDNUM_SemiMajorAxisLengthDifference =              1526,
         IDNUM_FlatteningDifference =                       1527,
         IDNUM_LatitudeAndLongitudeDifferenceFile =         1528,
         IDNUM_LatitudeDifferenceFile =                     1529,
         IDNUM_LongitudeDifferenceFile =                    1530,
         IDNUM_PointScaleFactor =                           1531,
         IDNUM_EastingAndNorthingDifferenceFile =           1532,
         IDNUM_MaritimeProvinceResidualFile =               1533,
         IDNUM_GeoideModelFile =                            1534,
         IDNUM_ScalingFactorForSourceCRSCoordDifferences =  1535,
         IDNUM_ScalingFactorForTargetCRSCoordDifferences =  1536,
         IDNUM_ScalingFactorForCoordDifferences =           1537,
         IDNUM_LatitudeOfNaturalOrigin =                    1538,
         IDNUM_LongitudeOfNaturalOrigin =                   1539,
         IDNUM_ScaleFactorAtNaturalOrigin =                 1540,
         IDNUM_FalseEasting =                               1541,
         IDNUM_FalseNorthing =                              1542,
         IDNUM_LatitudeOfProjectionCenter =                 1543,
         IDNUM_LongitudeOfProjectionCenter =                1544,
         IDNUM_AzimuthOfInitialLine =                       1545,
         IDNUM_AngleFromRectifiedToSkewGrid =               1546,
         IDNUM_ScaleFactorOnInitialLine =                   1547,
         IDNUM_EastingAtProjectionCenter =                  1548,
         IDNUM_NorthingAtProjectionCenter =                 1549,
         IDNUM_LatitudeOfPseudoStandardParallel =           1550,
         IDNUM_ScaleFactorOnPseudoStandardParallel =        1551,
         IDNUM_LatitudeOfFalseOrigin =                      1552,
         IDNUM_LongitudeOfFalseOrigin =                     1553,
         IDNUM_LatitudeOf1stStandardParallel =              1554,
         IDNUM_LatitudeOf2ndStandardParallel =              1555,
         IDNUM_EastingAtFalseOrigin =                       1556,
         IDNUM_NorthingAtFalseOrigin =                      1557,
         IDNUM_SphericalLatitudeOfOrigin =                  1558,
         IDNUM_SphericalLongitudeOfOrigin =                 1559,
         IDNUM_InitialLongitude =                           1560,
         IDNUM_ZoneWidth =                                  1561,
         IDNUM_HeightAboveEllipsoid =                       1563,
         IDNUM_IsSkewed =                                   1564,
         IDNUM_LandsatNumber =                              1565,
         IDNUM_SatellitePath =                              1566,
         IDNUM_X_AxisTranslationRev =                       1567,
         IDNUM_Y_AxisTranslationRev =                       1568,
         IDNUM_Z_AxisTranslationRev =                       1569,
         IDNUM_X_AxisRotationRev =                          1570,
         IDNUM_Y_AxisRotationRev =                          1571,
         IDNUM_Z_AxisRotationRev =                          1572,
         IDNUM_ScaleDifferenceRev =                         1573,
         IDNUM_LatitudeOfStandardParallel =                 1576,
         IDNUM_RightAscensionOfProjectionCenter =           1578,
         IDNUM_DeclinationOfProjectionCenter =              1579,
         IDNUM_LatitudeOfPoint1 =                           1580,
         IDNUM_LongitudeOfPoint1 =                          1581,
         IDNUM_LatitudeOfPoint2 =                           1582,
         IDNUM_LongitudeOfPoint2 =                          1583,
         IDNUM_CoefficientA0 =                              1600,
         IDNUM_CoefficientB0 =                              1700
         };

      enum TYPE {
         TYPE_Invalid =    0,
         TYPE_Boolean =    1,
         TYPE_Number =     2,
         TYPE_String =     3,
         };

      enum ANGLETYPE {
         ANGLETYPE_Invalid =        0,
         ANGLETYPE_General =        1,
         ANGLETYPE_Longitude =      2,
         ANGLETYPE_Latitude =       3,
         ANGLETYPE_RightAscension = 4,
         ANGLETYPE_Declination =    5
         };

      static ANGLETYPE IdNumToAngleType (
         IDNUM idnum
         );

      static IDNUM LookupIdNum (
         const IDENTIFIER& Id
         );

      COORDOPPARM (
         );

      COORDOPPARM (
         const COORDOPPARM& rhs
         );

      ~COORDOPPARM (
         );

      COORDOPPARM& operator= (
         const COORDOPPARM& rhs
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      ANGLETYPE GetAngleType (
         ) const;

      const MISTRING& GetDescription (
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      bool GetDisplayStrs (
         MISTRING& valstr,                      
         MISTRING& unitstr,                     
         bool Strip0 = false                    
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      TYPE GetType (
         ) const;

      const UOM::UNIT& GetUnit (
         ) const { return (m_unit); }

      bool GetValue (
         double& value                    
         ) const;

      bool GetValue (
         bool& value                      
         ) const;

      bool GetValue (
         STRUTF8& value                   
         ) const;

      bool GetValue (
         MISTRING& value                  
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "CoordOpParm"
         ) const;

      bool HasValue (
         ) const { return (!m_svalue.IsEmpty()); }

      bool IsOptional (
         ) const { return (m_optional); }

      ERRVALUE Set (
         IDNUM IdNum,
         bool value
         );

      ERRVALUE Set (
         IDNUM IdNum,
         int value
         );

      ERRVALUE Set (
         IDNUM IdNum,
         double value,
         UOM::IDNUM UnitIdNum = UOM::IDNUM_Unspecified
         );

      ERRVALUE Set (
         IDNUM IdNum,
         double value,
         const UOM::UNIT& unit
         );

      ERRVALUE Set (
         IDNUM IdNum,
         const MISTRING& string
         );

      ERRVALUE Set (
         IDNUM IdNum,
         const STRUTF8& string
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDOPPARM (PRIV& Priv);
      // Set ID number with no value, used by parser.
      ERRVALUE SetIdNum (IDNUM IdNum);
      // Set whether parameter is optional.
      void SetOptional (bool optional) { m_optional = optional; }
      // Set unit without value, used by parser.
      ERRVALUE SetUnit (UOM::IDNUM unitid);
      // Set value and unit, used by parser.
      ERRVALUE SetValue (const UINT8* value, UOM::IDNUM unitid);
      // Set value from COORDOPPARM, used by parser.
      ERRVALUE SetValue (const COORDOPPARM& parm);

      bool IsEqual (const COORDOPPARM& rhs) const;
      bool IsEquivalent (const COORDOPPARM& rhs) const;
   private:
      PRIV *m_pPriv;
      bool m_bvalue;
      double m_dvalue;
      STRUTF8 m_svalue;
      UOM::UNIT m_unit;
      bool m_optional;

      void FormatDoubleToStr ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDOPPARM> COORDOPPARMLIST;

inline bool operator== (
   const COORDOPPARM& lhs,
   const COORDOPPARM& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDOPPARM& lhs,
   const COORDOPPARM& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }


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

class COORDOP_IMPL_FACTORY {
   public:
      virtual COORDOP_IMPL_SINGLE *v_ConstructImpl () = 0;
   };

//=====================================================================================================================
class CLASSLIBEXPORT COORDOPMETHOD {
   public:

      enum TYPE {
         TYPE_Undefined =                 0x0000,
         TYPE_Unspecified =               0x0001,
         TYPE_DatumTransformation =       0x0002,
         TYPE_GeographicProjection =      0x0004,
         TYPE_PolarProjection =           0x0008,
         TYPE_AstronomicProjection =      0x0010,
         TYPE_AnyProjection =             (TYPE_GeographicProjection | TYPE_PolarProjection | TYPE_AstronomicProjection)
         };

      enum IDNUM {
         IDNUM_Undefined =                                       -1,
         IDNUM_FIRST =                                         1800,
         IDNUM_Identity =                                      1800,
         IDNUM_Linear =                                        1801,
         IDNUM_PlaneProjective =                               1802,
         IDNUM_Bilinear =                                      1803,
         IDNUM_Quintic =                                       1804,
         IDNUM_SpaceResection =                                1805,
         IDNUM_RubberSheet =                                   1806,
         IDNUM_RationalPolynomial =                            1807,
         IDNUM_Conformal =                                     1808,
         IDNUM_PiecewiseAffine =                               1810,
         IDNUM_ReversiblePolynomialDegree2 =                   1820,
         IDNUM_ReversiblePolynomialDegree3 =                   1821,
         IDNUM_ReversiblePolynomialDegree4 =                   1822,
         IDNUM_ReversiblePolynomialDegree13 =                  1823,
         IDNUM_GeneralPolynomialDegree6 =                      1824,
         IDNUM_LongitudeOffset =                               1858,
         IDNUM_GeographicGeocentric =                          1859,
         IDNUM_Datum_GeocentricTranslation =                   1860,
         IDNUM_Datum_CoordinateFrameRotation =                 1861,
         IDNUM_Datum_PositionVector7Parameter =                1862,
         IDNUM_Datum_MolodenskiBadekas =                       1863,
         IDNUM_Datum_GeographicAndHeightOffsets =              1864,
         IDNUM_Datum_GeographicOffsets =                       1865,
         IDNUM_Datum_VerticalOffset =                          1866,
         IDNUM_Datum_MadridToED50 =                            1877,
         IDNUM_Datum_BuiltIn_WGS72 =                           1878,
         IDNUM_Datum_BuiltIn_MRE =                             1879,
         IDNUM_Datum_Grid_MicroImages =                        1880,
         IDNUM_Datum_Grid_NADCON1 =                            1881,
         IDNUM_Datum_Grid_NADCON2 =                            1882,
         IDNUM_Datum_Grid_NTv1 =                               1883,
         IDNUM_Datum_Grid_NTv2 =                               1884,
         IDNUM_Projection_AlbersConicalEqualArea =             1903,
         IDNUM_Projection_LambertConformalConic2SP =           1904,
         IDNUM_Projection_Mercator =                           1905,
         IDNUM_Projection_PolarStereographic =                 1906,
         IDNUM_Projection_Polyconic =                          1907,
         IDNUM_Projection_EquidistantConic =                   1908,
         IDNUM_Projection_TransverseMercator =                 1909,
         IDNUM_Projection_Stereographic =                      1910,
         IDNUM_Projection_LambertAzimuthalEqualArea =          1911,
         IDNUM_Projection_AzimuthalEquidistant =               1912,
         IDNUM_Projection_Gnomonic =                           1913,
         IDNUM_Projection_Orthographic =                       1914,
         IDNUM_Projection_GeneralVerticalNearSidePerspective = 1915,
         IDNUM_Projection_Sinusoidal =                         1916,
         IDNUM_Projection_Equirectangular =                    1917,
         IDNUM_Projection_MillerCylindrical =                  1918,
         IDNUM_Projection_VanDerGrintenI =                     1919,
         IDNUM_Projection_HotineObliqueMercator =              1920,
         IDNUM_Projection_Robinson =                           1921,
         IDNUM_Projection_BipolarObliqueConformalConic =       1922,
         IDNUM_Projection_LandsatSpaceObliqueMercator =        1923,
         IDNUM_Projection_Cassini =                            1924,
         IDNUM_Projection_NewZealandMapGrid =                  1925,
         IDNUM_Projection_SwissConformalCylindrical =          1926,
         IDNUM_Projection_RoyalDutch =                         1927,
         IDNUM_Projection_ObliqueStereographic =               1928,
         IDNUM_Projection_InterruptedGoodeHomolosine =         1929,
         IDNUM_Projection_LabordeObliqueMercator =             1930,
         IDNUM_Projection_ObliqueMercator =                    1931,
         IDNUM_Projection_KrovakObliqueConicConformal =        1932,
         IDNUM_Projection_LambertConformalConic1SP =           1933,
         IDNUM_Projection_TransverseMercatorSouthOriented =    1934,
         IDNUM_Projection_LambertConformalConicWestOriented =  1935,
         IDNUM_Projection_LambertConformalConicBelgium2SP =    1936,
         IDNUM_Projection_LambertConicNearConformal =          1937,
         IDNUM_Projection_LambertAzimuthalEqualAreaSpherical = 1938,
         IDNUM_Projection_Bonne =                              1939,
         IDNUM_Projection_BonneSouthOriented =                 1940,
         IDNUM_Projection_PolarStereographicVariantB =         1941,
         IDNUM_Projection_PolarStereographicVariantC =         1942,
         IDNUM_Projection_Mollweide =                          1943,
         IDNUM_Projection_CylindricalEqualArea =               1944,
         IDNUM_Projection_TwoPointEquidistant =                1945,
         IDNUM_AstroProjection_Orthographic =                  1980,
         IDNUM_AstroProjection_Mercator =                      1981,
         IDNUM_AstroProjection_Stereographic =                 1982,
         IDNUM_AstroProjection_Gnomonic =                      1983,
         IDNUM_AstroProjection_AzimuthalEqualArea =            1984,
         IDNUM_AstroProjection_AzimuthalEquidistant =          1985,
         IDNUM_LAST =                                          1998,
         IDNUM_Concatenated =                                  1999
         };

      static void RegisterImplementation (
         IDNUM IdNum,
         COORDOP_IMPL_FACTORY *pImplFactory
         );

      COORDOPMETHOD (
         );

      COORDOPMETHOD (
         const COORDOPMETHOD& rhs
         );

      ~COORDOPMETHOD (
         );

      COORDOPMETHOD& operator= (
         const COORDOPMETHOD& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE ConstructImplementation (
         COORDOP_IMPL_SINGLE *& pImpl           
         ) const;

      ERRVALUE GetDefaultTargetCoordSys (
         COORDSYS& CoordSys                     
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      const COORDOPPARMLIST& GetParmList (
         ) const;

      const COORDAXISLIST& GetSourceAxisList (
         ) const;

      const COORDAXISLIST& GetTargetAxisList (
         ) const;

      TYPE GetType (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "Method"
         ) const;

      bool IsImplemented (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDOPMETHOD (PRIV& Priv);
      bool IsEqual (const COORDOPMETHOD& rhs) const { return (m_pPriv == rhs.m_pPriv); }
   private:
      static COORDOP_IMPL_FACTORY* s_pImplementations[IDNUM_LAST-IDNUM_FIRST+1];
      PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDOPMETHOD> COORDOPMETHODLIST;

inline bool operator== (
   const COORDOPMETHOD& lhs,
   const COORDOPMETHOD& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDOPMETHOD& lhs,
   const COORDOPMETHOD& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }


//=====================================================================================================================
class CLASSLIBEXPORT COORDSYS {
   public:

      enum IDNUM {
         IDNUM_Undefined =                     -1,
         IDNUM_None =                           0,
         IDNUM_Projected2D_EN_m =            1200,    
         IDNUM_Projected2D_EN_ft =           1201,    
         IDNUM_Projected2D_EN_ftUS =         1202,    
         IDNUM_UPS_North_m =                 1250,    
         IDNUM_UPS_South_m =                 1251,    
         IDNUM_Cartesian2D_XY_m =            1260,    
         IDNUM_Cartesian3D_XYZ_m =           1261,    
         IDNUM_Ellipsoidal2D_Deg =           1280,    
         IDNUM_Ellipsoidal3D_DegM =          1281,    
         IDNUM_Ellipsoidal2D_Grad =          1282,    
         IDNUM_Ellipsoidal3D_GradM =         1283,    
         IDNUM_Equatorial2D_Deg =            1288,    
         IDNUM_Equatorial2D_HrDeg =          1289,    
         IDNUM_GravityRelated_Height_m =     1290,
         IDNUM_GravityRelated_Height_ftUS =  1291,
         IDNUM_GravityRelated_Depth_m =      1292,
         IDNUM_Zoned_MGRS =                  1295,    
         IDNUM_Spherical3D =                 1298,    
         IDNUM_Geocentric =                  1299     
         };

      enum TYPE {
         TYPE_Undefined =           0x0000,
         TYPE_Cartesian =           0x0001,  
         TYPE_ObliqueCartesian =    0x0002,
         TYPE_Projected =           0x0004,  
         TYPE_Ellipsoidal =         0x0008,  
         TYPE_Spherical =           0x0010,
         TYPE_Polar =               0x0020,
         TYPE_Cylindrical =         0x0040,
         TYPE_MultiLinear =         0x0080,
         TYPE_GravityRelated =      0x0100,
         TYPE_Temporal =            0x0200,
         TYPE_Equatorial =          0x0400,
         TYPE_Zoned =               0x8000,
         TYPES_GeorefObject =       (TYPE_Cartesian | TYPE_Projected | TYPE_Ellipsoidal | TYPE_Equatorial)
         };

      static TEXTID TypeToTextID (
         TYPE type
         );

      COORDSYS (
         );

      COORDSYS (
         const COORDSYS& rhs
         );

      COORDSYS (
         IDNUM idnum
         );

      ~COORDSYS (
         );

      COORDSYS& operator= (
         const COORDSYS& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      ERRVALUE Create (
         TYPE type,                             
         const COORDAXISLIST& AxisList,         
         DATUM::TYPE ValidDatumType             
         );

      const COORDAXIS& GetAxis (
         int axisidx                            
         ) const;

      const COORDAXISLIST& GetAxisList (
         ) const;

      int GetDimension (
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent,                            
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const MISTRING& GetName (
         ) const;

      COORDOPMETHOD::TYPE GetProjectedMethodType (
         ) const;

      TYPE GetType (
         ) const;

      DATUM::TYPE GetValidDatumType (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "CoordSys"
         ) const;

      bool HasAxes (
         const COORDAXISLIST& AxisList          
         ) const;

      bool IsAllowedLegacy (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDSYS (PRIV& Priv);
      bool IsEqual (const COORDSYS& rhs) const;
      void SetValidDatumType (DATUM::TYPE ValidDatumType);
   private:
      PRIV *m_pPriv;
      void GetExclusive ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDSYS> COORDSYSLIST;
DEFINE_ENUM_OP_BITWISE(COORDSYS::TYPE)

inline bool operator== (
   const COORDSYS& lhs,
   const COORDSYS& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDSYS& lhs,
   const COORDSYS& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }


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

class CLASSLIBEXPORT COORDOPDEF {
   public:

      enum IDNUM {
         IDNUM_Undefined =            -1,
         IDNUM_None =                  0,
         IDNUM_UPS_North =             25382,   
         IDNUM_UPS_South =             25383,   
         IDNUM_PlateCarree =           26200,   
         IDNUM_UserDefinedBase =       IdNumUserDefinedBase 
         };

      enum AUTOPROJECT {
         AUTOPROJECT_UTM =                   1, 
         AUTOPROJECT_TM_WMS =                2, 
         AUTOPROJECT_Orthographic =          3,
         AUTOPROJECT_Equirectangular =       4,
         AUTOPROJECT_Gnomonic =              5,
         AUTOPROJECT_AzimuthalEquidistant =  6,
         AUTOPROJECT_Stereographic =         7,
         };

      COORDOPDEF (
         );

      COORDOPDEF (
         const COORDOPDEF& rhs
         );

      ~COORDOPDEF (
         );

      COORDOPDEF& operator= (
         const COORDOPDEF& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      ERRVALUE Create (
         const MISTRING& name,               
         const COORDOPMETHOD& method,        
         const COORDOPPARMLIST& parmlist     
         );

      ERRVALUE Create (
         AUTOPROJECT autoproj,               
         const DPOINT2D& center              
         );

      ERRVALUE Create (
         const MISTRING& name,               
         const MILIST<COORDOPDEF>& StepList  
         );

      bool FindPredefined (
         );

      void GetDisplay (
         MISTRING& string,                   
         int indent,                         
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      const COORDOPMETHOD& GetMethod (
         ) const;

      const MISTRING& GetName (
         ) const;

      ERRVALUE GetParm (
         COORDOPPARM::IDNUM idnum,
         COORDOPPARM& parm
         ) const;

      const COORDOPPARMLIST& GetParmList (
         ) const;

      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        
         double& value,                   
         const UOM::UNIT& unit            
         ) const;

      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        
         double& value,                   
         int unitid                       
         ) const;

      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        
         bool& value                      
         ) const;

      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        
         MISTRING& value                  
         ) const;

      const COORDREFSYS& GetSourceCRS (
         ) const;

      const MILIST<COORDOPDEF>& GetStepList (
         ) const;

      const COORDREFSYS& GetTargetCRS (
         ) const;

      const TEXTRESITEMLIST& GetValidAreaList (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,             
         const char *nodename = "CoordOp"
         ) const;

      bool HasParmValue (
         COORDOPPARM::IDNUM idnum         
         ) const;

      bool IsConcatenated (
         ) const;

      bool IsImplemented (
         ) const;

      void SetMethod (
         const COORDOPMETHOD& CoordOpMethod
         );

      void SetMethod (
         COORDOPMETHOD::IDNUM MethodIdNum
         );

      ERRVALUE SetParm (
         const COORDOPPARM& parm
         );

      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         bool value
         );

      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         int value
         );

      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         double value,
         const UOM::UNIT& unit
         );

      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         double value,
         const UOM::IDNUM unitid
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDOPDEF (PRIV& Priv);
      bool IsEqual (const COORDOPDEF& rhs) const;
      bool IsEquivalent (const COORDOPDEF& rhs) const;
      ERRVALUE Resolve ();
   private:
      PRIV *m_pPriv;
      void GetExclusive ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDOPDEF> COORDOPDEFLIST;

inline bool operator== (
   const COORDOPDEF& lhs,
   const COORDOPDEF& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDOPDEF& lhs,
   const COORDOPDEF& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }

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

class CLASSLIBEXPORT COORDREFSYS {
   public:

      enum IDNUM {
         IDNUM_Undefined =                  -1,
         IDNUM_None =                        0,
         IDNUM_Geographic2D_WGS84_Deg =   3800,    
         IDNUM_Geographic2D_WGS72_Deg =   3802,    
         IDNUM_Geographic3D_WGS84_DegM =  4800,    
         IDNUM_Geographic3D_WGS72_DegM =  4802,    
         IDNUM_Geocentric_WGS84 =         7800,    
         IDNUM_Geocentric_ITRF_1988 =     7804,    
         IDNUM_Geocentric_ITRF_1989 =     7805,    
         IDNUM_Geocentric_ITRF_1990 =     7806,    
         IDNUM_Geocentric_ITRF_1991 =     7807,    
         IDNUM_Geocentric_ITRF_1992 =     7808,    
         IDNUM_Geocentric_ITRF_1993 =     7809,    
         IDNUM_Geocentric_ITRF_1994 =     7810,    
         IDNUM_Geocentric_ITRF_1996 =     7811,    
         IDNUM_Geocentric_ITRF_1997 =     7812,    
         IDNUM_Geocentric_ITRF_2000 =     7813,    
         IDNUM_Local2D_XY_m =             9000,    
         IDNUM_Projected_US_NationalAtlas_EqualArea =    10559,   
         IDNUM_SphericalWebMercator =     12685,   
         };

      enum MEASUREMETHOD {
         MEASUREMETHOD_Projected,            
         MEASUREMETHOD_Geodesic,             
         MEASUREMETHOD_Automatic,            
//       MEASUREMETHOD_StraightLine,         //!< Straight line distance "through the earth"
         };

   #ifdef GEOMDLL
      DEPRECATED enum DISTANCEMETHOD {
         DISTANCEMETHOD_Projected = MEASUREMETHOD_Projected
         };
   #endif

      COORDREFSYS (
         );

      COORDREFSYS (
         const COORDREFSYS& rhs
         );

      ~COORDREFSYS (
         );

      COORDREFSYS& operator= (
         const COORDREFSYS& rhs
         );

      ERRVALUE Assign (
         const IDENTIFIER& Id                   
         );

      ERRVALUE Assign (
         IDNUM IdNum
         );

      ERRVALUE Assign (
         const XMLNODE* xmlnode                 
         );

      ERRVALUE Assign (
         const MISTRING& string                 
         );

      ERRVALUE Assign (
         const OLDPROJPARM& projparm
         );

      void Clear (
         );

      ERRVALUE ComputeAngleToNorth (
         const DPOINT2D& point,                 
         double& angle,                         
         int angleunitid                        
         ) const;

      ERRVALUE ComputeDistance (
         const DPOINT2D& point1,                
         const DPOINT2D& point2,                
         double& distance,                      
         MEASUREMETHOD method = MEASUREMETHOD_Automatic, 
         UOM::IDNUM LengthUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;

   #ifdef GEOMDLL
      DEPRECATED ERRVALUE ComputeDistance (
         const DPOINT2D& point1,                
         const DPOINT2D& point2,                
         DISTANCEMETHOD method,                 
         double& distance,                      
         UOM::IDNUM LengthUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;
   #endif

      ERRVALUE ComputeLength (
         const POLYLINE& polyline,              
         double& length,                        
         MEASUREMETHOD method = MEASUREMETHOD_Automatic, 
         UOM::IDNUM LengthUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;

      ERRVALUE Create (
         const COORDSYS& CoordSys,              
         const DATUM& Datum                     
         );

      ERRVALUE Create (
         COORDSYS::IDNUM CoordSysIdNum,         
         const DATUM& Datum                     
         );

      ERRVALUE Create (
         const COORDSYS& CoordSys,              
         const DATUM& Datum,                    
         const COORDOPDEF& CoordOp              
         );

      ERRVALUE Create (
         COORDSYS::IDNUM CoordSysIdNum,         
         const DATUM& Datum,                    
         const COORDOPDEF& CoordOp              
         );

      ERRVALUE Create (
         COORDSYS::IDNUM CoordSysIdNum,         
         const DATUM& Datum,                    
         const COORDOPDEF::IDNUM CoordOpDefId   
         );

      ERRVALUE Create (
         const MILIST<COORDREFSYS>& CoordRefSysList   
         );

      bool FindPredefined (
         );

      const COORDAXIS& GetAxis (
         int axisidx                            
         ) const;

      const MILIST<COORDREFSYS>& GetComponentList (
         ) const;

      const COORDOPDEF& GetCoordOpDef (
         ) const;

      const COORDSYS& GetCoordSys (
         ) const;

      const DATUM& GetDatum (
         ) const;

      bool GetDatumTransOp (
         const DATUM& datum,                    
         COORDOPDEF& CoordOpDef                 
         ) const;

      const COORDOPDEFLIST& GetDatumTransOpList (
         ) const;

      int GetDimension (
         ) const;

      void GetDisplay (
         MISTRING& string,                      
         int indent = 0,                        
         GETDISPLAY flags = GETDISPLAY_None  
         ) const;

      const IDENTIFIERLIST& GetIdList (
         ) const;

      IDNUM GetIdNum (
         ) const;

      int GetLegacyProjParm (
         OLDPROJPARM& projparm                  
         ) const;

      const MISTRING& GetName (
         ) const;

      ERRVALUE GetString (
         MISTRING& string                       
         ) const;

      const TEXTRESITEMLIST& GetValidAreaList (
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                   
         const char *nodename = "CoordRefSys"
         ) const;

      bool HasCoordSysType (
         COORDSYS::TYPE CoordSysType
         ) const;

      bool HasDatumType (
         DATUM::TYPE DatumType
         ) const;

      bool HasOwnDatumTransOpList (
         ) const;

      bool IniRead (
         INIHANDLE hdl,
         const char *group,
         const char *field
         );

      ERRVALUE IniWrite (
         INIHANDLE hdl,
         const char *group,
         const char *field
         ) const;

      bool IsCompound (
         ) const;

      bool IsDefined (
         ) const;

      bool IsLocal (
         ) const;

      bool IsProjected (
         ) const;

      ERRVALUE SetCoordOpDef (
         const COORDOPDEF& CoordOpDef
         );

      ERRVALUE SetCoordSys (
         const COORDSYS& CoordSys
         );

      ERRVALUE SetCoordSys (
         COORDSYS::IDNUM CoordSysIdNum
         );

      ERRVALUE SetDatum (
         const DATUM& Datum
         );

      ERRVALUE SetDatum (
         DATUM::IDNUM DatumIdNum
         );

      ERRVALUE SetDatumTransOpList (
         const COORDOPDEFLIST& DatumTransOpList
         );

      void SetId (
         const IDENTIFIER& Id
         );

      void SetName (
         const MISTRING& name                   
         );

      ERRVALUE Validate (
         bool FixIfPossible,                    
         bool CheckOpCreate                     
         );

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDREFSYS (PRIV& Priv);
      // Used internally for initialization.
      PRIV* GetPrivPtr () const { return (m_pPriv); }
      bool IsEqual (const COORDREFSYS& rhs) const;
   private:
      mutable PRIV *m_pPriv;
      COORDOPDEFLIST m_DatumTransOpList;
      void GetExclusive ();
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<COORDREFSYS> COORDREFSYSLIST;

inline bool operator== (
   const COORDREFSYS& lhs,
   const COORDREFSYS& rhs
   ) {
   return (lhs.IsEqual(rhs)); 
   }

inline bool operator!= (
   const COORDREFSYS& lhs,
   const COORDREFSYS& rhs
   ) {
   return (!lhs.IsEqual(rhs)); 
   }


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

class CLASSLIBEXPORT GROUP {
   public:

      GROUP (
         );

      GROUP (
         const GROUP& rhs
         );

      ~GROUP (
         );

      GROUP& operator= (
         const GROUP& rhs
         );

      const COORDOPDEFLIST& GetCoordOpDefList (
         ) const;

      const COORDREFSYSLIST& GetCoordRefSysList (
         ) const;

      const COORDSYSLIST& GetCoordSysList (
         ) const;

      const MILIST<GROUP>& GetGroupList (
         ) const;

      const MISTRING& GetName (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      // Internal constructor.
      GROUP (bool);
      class PRIV;
      PRIV* GetPrivPtr () const { return (m_pPriv); }
   private:
      PRIV *m_pPriv;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
typedef MILIST<GROUP> GROUPLIST;

//=====================================================================================================================
class CLASSLIBEXPORT SYSTEM {
   public:

      static ERRVALUE GetCoordAxis (
         COORDAXIS::IDNUM IdNum,
         COORDAXIS& CoordAxis
         );

      static const COORDAXISLIST& GetCoordAxisList (
         );

      static ERRVALUE GetCoordOpDef (
         COORDOPDEF::IDNUM IdNum,
         COORDOPDEF& CoordOpDef
         );

      static const COORDOPDEFLIST& GetCoordOpDefList (
         );

      static ERRVALUE GetCoordOpMethod (
         COORDOPMETHOD::IDNUM IdNum,
         COORDOPMETHOD& CoordOpMethod
         );

      static const COORDOPMETHODLIST& GetCoordOpMethodList (
         );

      static ERRVALUE GetCoordOpParm (
         COORDOPPARM::IDNUM IdNum,
         COORDOPPARM& CoordOpParm
         );

      static const COORDOPPARMLIST& GetCoordOpParmList (
         );

      static ERRVALUE GetCoordRefSys (
         COORDREFSYS::IDNUM IdNum,
         COORDREFSYS& CoordRefSys
         );

      static const COORDREFSYSLIST& GetCoordRefSysList (
         );

      static ERRVALUE GetCoordSys (
         COORDSYS::IDNUM IdNum,
         COORDSYS& CoordSys
         );

      static const COORDSYSLIST& GetCoordSysList (
         );

      static ERRVALUE GetDatum (
         DATUM::IDNUM IdNum,
         DATUM& Datum
         );

      static const DATUMLIST& GetDatumList (
         );

      static ERRVALUE GetEllipsoid (
         ELLIPSOID::IDNUM IdNum,
         ELLIPSOID& Ellipsoid
         );

      static const ELLIPSOIDLIST& GetEllipsoidList (
         );

      static ERRVALUE GetPrimeMeridian (
         PRIMEMERIDIAN::IDNUM IdNum,
         PRIMEMERIDIAN& PrimeMeridian
         );

      static const PRIMEMERIDIANLIST& GetPrimeMeridianList (
         );

      static const GROUPLIST& GetSelectionGroupList (
         );

      static ERRVALUE Initialize (
         );

      static bool IsInitialized (
         );

      static void Terminate ();

      #ifndef GENERATING_DOXYGEN_OUTPUT
      static const CHECKEXE& GetChk ();
      class PRIV;
   private:
      static PRIV *s_pPriv;

#ifdef MAC_OSX
      static void* BackgroundInit (void*);
#endif
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//=====================================================================================================================
//    Functions - Begin

enum COORDREFSYS_SELFLAGS {
   COORDREFSYS_SELFLAG_Default =                0x0000,
   COORDREFSYS_SELFLAG_AllowChangeDatumType =   0x0001,  
   COORDREFSYS_SELFLAG_AllowGeocentric =        0x0002,  
   COORDREFSYS_SELFLAG_AllowLocal =             0x0004,  
   COORDREFSYS_SELFLAG_Allow3D =                0x0008,  
   COORDREFSYS_SELFLAG_AllowCompound2DGR =      0x0010,  
   COORDREFSYS_SELFLAG_AllowUndefined =         0x0020,  
   COORDREFSYS_SELFLAG_Need3D =                 0x0040,  
   COORDREFSYS_SELFLAG_AllowCheckLegacy =       0x0080,  
   COORDREFSYS_SELFLAG_AllowDftUndefined =      0x0100,  
   };
DEFINE_ENUM_OP_BITWISE(COORDREFSYS_SELFLAGS)



ERRVALUE DlgGetCoordRefSys (
   MDLGPARENT dlgparent,               
   COORDREFSYS& CoordRefSys,           
   COORDREFSYS_SELFLAGS flags,
   DATUM::TYPE DatumTypesAllowed = DATUM::TYPE_Geodetic,
   COORDSYS::TYPE CoordSysTypesAllowed = (COORDSYS::TYPE_Projected | COORDSYS::TYPE_Ellipsoidal | COORDSYS::TYPE_Equatorial)
   );

ERRVALUE DlgGetCoordRefSys (
   MDLGPARENT dlgparent,               
   const MISTRING& title,              
   COORDREFSYS& CoordRefSys,           
   COORDREFSYS_SELFLAGS flags = COORDREFSYS_SELFLAG_Default,
   DATUM::TYPE DatumTypesAllowed = DATUM::TYPE_Geodetic,
   COORDSYS::TYPE CoordSysTypesAllowed = (COORDSYS::TYPE_Projected | COORDSYS::TYPE_Ellipsoidal | COORDSYS::TYPE_Equatorial)
   );

inline ERRVALUE DlgGetCoordRefSys (
   MDLGPARENT dlgparent,               
   COORDREFSYS& CoordRefSys,           
   DATUM::TYPE DatumTypesAllowed = DATUM::TYPE_Geodetic,
   COORDSYS::TYPE CoordSysTypesAllowed = (COORDSYS::TYPE_Projected | COORDSYS::TYPE_Ellipsoidal | COORDSYS::TYPE_Equatorial),
   COORDREFSYS_SELFLAGS flags = COORDREFSYS_SELFLAG_Default
   ) { return (DlgGetCoordRefSys(dlgparent,CoordRefSys,flags,DatumTypesAllowed,CoordSysTypesAllowed)); }

void DlgMapCalculator (
   MDLGPARENT dlgparent
   );


//    Functions - End
//=====================================================================================================================
}; // End namespace SPATREF

#undef   CLASSLIBEXPORT

#endif   // INC_MI32_SPATREF_H

---