spatref.h

Go to the documentation of this file.

/**
 * \file spatref.h <mi32/spatref.h>
 * \brief Spatial Reference (SPATREF) System definitions
 *
 * \if NODOC
 * $Id: spatref.h_v 1.53 2004/11/24 17:47:13 mju Exp $
 *
 * $Log: spatref.h_v $
 * Revision 1.53  2004/11/24 17:47:13  mju
 * Mark some dlg variants as deprecated.
 *
 * Revision 1.52  2004/11/24 15:45:21  mju
 * Add datum/coordsys 'types' for GeorefObject.
 *
 * Revision 1.51  2004/11/23 23:06:19  mju
 * Add astroproj stuff.
 *
 * Revision 1.50  2004/11/23 17:24:30  mju
 * Add coordopmethod type enum.
 * Add ability to get projected operation type for projected coordsys.
 * Add method to get valid datum type for coordsys.
 *
 * Revision 1.49  2004/11/17 15:39:17  mju
 * Add datum type for astronomical.
 *
 * Revision 1.48  2004/11/09 22:30:33  mju
 * Add crs.setName.
 *
 * Revision 1.47  2004/11/09 18:25:47  mju
 * Add getdisplay values for all IDs and remarks.
 *
 * Revision 1.46  2004/11/08 17:37:56  mju
 * Add getdisplay value to skip valid area.
 *
 * Revision 1.45  2004/11/05 22:51:41  mju
 * Add equatorial coordsys type and appropriate axis and coordsys ids.
 *
 * Revision 1.44  2004/11/03 20:45:01  mju
 * Remove generic 'scale factor' parm as technically incorrect.
 *
 * Revision 1.41  2004/10/13 14:03:07  mju
 * Rename LCC to indicate 2SP.
 *
 * Revision 1.40  2004/10/06 21:00:17  dwilliss
 * added private method to SYSTEM
 *
 * Revision 1.39  2004/09/30 14:53:21  mju
 * Add cs idnums for ft/ftUS.
 *
 * Revision 1.38  2004/09/29 14:20:10  mju
 * Add crs.hasOwnDatumTransOpList.
 * Add system.isInitialized.
 *
 * Revision 1.37  2004/09/27 20:39:07  mju
 * Add system methods to get instances by idnum.
 *
 * Revision 1.36  2004/09/21 20:01:27  mju
 * Add idnums for UTM coordops.
 *
 * Revision 1.35  2004/07/28 15:19:48  mju
 * Change flags for dlgGetCoordRefSys to use Allow3D instead of No3D.
 * Add variant for specifying flags with default coordsystypes.
 *
 * Revision 1.34  2004/07/20 21:52:07  mju
 * Add crs.clear.
 *
 * Revision 1.33  2004/07/19 20:05:40  mju
 * Add ellipsoid idnums.
 *
 * Revision 1.32  2004/07/19 16:57:59  mju
 * Add coordopdef isprojected and setcoordsys by id num.
 *
 * Revision 1.31  2004/07/14 13:13:41  mju
 * Add crs.setDatum using idnum.
 *
 * Revision 1.30  2004/07/13 15:22:39  dwilliss
 * Just reread Mike's email and he wanted it named Undefined, not None.
 *
 * Revision 1.29  2004/07/13 15:21:20  dwilliss
 * Added new SELFLAG for None
 *
 * Revision 1.28  2004/07/13 14:10:13  mju
 * Add crs.getAxis,getDimension.
 * Add axis.getValidRange.
 *
 * Revision 1.27  2004/07/12 15:17:05  mju
 * Change op_string to op_zoned and redesign to have internal implementation.
 *
 * Revision 1.26  2004/07/09 17:43:45  mju
 * Remove unnecessary flag for dlgGetCRS.
 *
 * Revision 1.25  2004/07/09 17:40:17  mju
 * Add coordsys type for string and id for MGRS.
 *
 * Revision 1.24  2004/06/29 15:23:41  mju
 * Add dlggetcrs variant with no prompt.
 *
 * Revision 1.23  2004/06/29 13:24:59  mju
 * Add ellipsoid methods to compute linear scale and distance.
 *
 * Revision 1.22  2004/06/28 17:56:53  mju
 * Add HasDatumType.
 *
 * Revision 1.21  2004/06/28 17:55:55  mju
 * Add ComputeDistance and IsLocal.
 *
 * Revision 1.20  2004/06/24 19:58:53  mju
 * Add crs.HasCoordSysType.
 * Add crs.ComputeAngleToNorth.
 *
 * Revision 1.19  2004/06/24 19:14:10  mju
 * Use uom::idnum for setting parm value.
 *
 * Revision 1.18  2004/06/22 20:28:08  mju
 * Add coordopparm.getdisplaystrs.
 * Add more GETDISPLAY flags.
 *
 * Revision 1.17  2004/06/22 15:33:55  mju
 * Add crs Ini methods.
 * Add GetDisplay methods.
 *
 * Revision 1.16  2004/06/21 14:31:40  mju
 * Change getLegacyProjParm to return TRUE on success, FALSE if can't convert.
 *
 * Revision 1.15  2004/06/21 14:23:33  mju
 * Remove unit from getLegacyProjParm.
 *
 * Revision 1.14  2004/06/18 15:49:55  mju
 * Use oldprojparm.
 * Add CRS validation.
 * Add convenience crs creation using coordsys idnum.
 *
 * Revision 1.13  2004/06/17 17:43:44  mju
 * *** empty log message ***
 *
 * Revision 1.12  2004/05/25 21:21:29  mju
 * Add datum.getAbbr.
 *
 * Revision 1.11  2004/05/24 20:14:22  mju
 * More refinements.
 *
 * Revision 1.10  2004/05/20 14:50:58  mju
 * Change "type" enums to use unique bits so can combine for use in selection.
 * Add methods to get source/target axis lists for coordopmethod.
 *
 * Revision 1.9  2004/04/29 20:24:11  mju
 * Add getselectiongrouplist.
 *
 * Revision 1.8  2004/04/29 14:34:10  mju
 * Add assign from xml and getxml methods.
 * Finish datumtransop support.
 *
 * Revision 1.7  2004/04/20 13:49:29  mju
 * Add get/setMapProjParm.
 * Add DatumTransOp methods.
 *
 * Revision 1.6  2004/04/13 14:40:27  mju
 * Initial implementation for reading from XML now mostly complete.
 *
 * Revision 1.1  2003/09/19 14:06:27  mju
 * Initial revision
 *
 * \endif
**/

#ifndef  INC_MI32_SPATREF_H
#define  INC_MI32_SPATREF_H

#ifndef  INC_MI32_IDENTIFIER_H
#include <mi32/identifier.h>
#endif

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

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

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

#ifndef  INC_MI32_TEXTRES_H
#include <mi32/textres.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;
#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,    //!< Show MicroImages ID number
   GETDISPLAY_SkipName =      0x02,    //!< Skip name, usually because included by caller
   GETDISPLAY_SkipMethod =    0x04,    //!< Skip method name for COORDOPDEF
   GETDISPLAY_SkipValidArea = 0x08,    //!< Skip valid area for COORDOPDEF
   GETDISPLAY_AllIDs =        0x10,    //!< Show all IDs
   GETDISPLAY_Remarks =       0x20,    //!< Show 'remarks' from database
   };
DEFINE_ENUM_OP_BITWISE(GETDISPLAY)

//=====================================================================================================================
//! Ellipsoid specification.
class CLASSLIBEXPORT ELLIPSOID {
   public:

      //! Ellipsoid ID numbers.
      //! Note, not all IDs in database are listed.
      enum IDNUM {
         IDNUM_Undefined =          -1,
         IDNUM_UnitSphere =         1300,
         IDNUM_Clarke_1866 =        1302,
         IDNUM_GRS_1980 =           1301,
         IDNUM_WGS_1984 =           1351,
         };

      //! Ellipsoid definition form
      enum FORM {
         FORM_Undefined =           0,
         FORM_Sphere =              1,    //!< Defined as sphere, semi-minor axis equal to semi-major.
         FORM_SemiMinorAxis =       2,    //!< Defined using value for semi-minor axis
         FORM_InverseFlattening =   3     //!< Defined using inverse flattening
         };

      //! Lookup IDNUM using axis values.
      static IDNUM LookupIdNum (
         double SemiMajorAxis,            //!< Semi-major axis (meters)
         double SemiMinorAxis,            //!< Semi-minor axis (meters), 0 to use InverseFlattening
         double InverseFlattening = 0     //!< Inverse flattening, 0 to use semi-minor axis
         );

      //! Default constructor.
      ELLIPSOID (
         );

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

      //! Destructor.
      ~ELLIPSOID (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Compute geodesic distance over ellipsoid between specified points.
      ERRVALUE ComputeDistance (
         const DPOINT2D& point1,
         const DPOINT2D& point2,
         double& distance,
         const UOM::UNIT& PointUnit,
         const UOM::UNIT& LengthUnit
         ) const;

      //! Compute eccentricity.
      //! @return Eccentricity.
      double ComputeEccentricity (
         ) const;

      //! Compute flattening.
      //! @return Flattening, 0 if sphere.
      double ComputeFlattening (
         ) const;

      //! Compute scale from angular to linear units at specified latitude.
      void ComputeLinearScale (
         double GeodeticLatitude,               //!< Latitude at which to compute scale
         DPOINT2D& scale,                       //!< Scale from angular to linear unit on ellipsoid returned
         UOM::IDNUM LatitudeUnitIdNum = UOM::IDNUM_PlaneAngle_Degree,
         UOM::IDNUM LinearUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get ellipsoid definition form.
      FORM GetForm (
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get inverse flatting value.
      //! @return Inverse flattening, infinity if sphere.
      double GetInverseFlattening (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      //! Get semi-major axis in meters.
      double GetSemiMajorAxis (
         ) const;

      //! Get semi-minor axis in meters.
      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)); 
   }

//=====================================================================================================================
//! Prime meridian specification.
class CLASSLIBEXPORT PRIMEMERIDIAN {
   public:

      //! Prime Meridian ID numbers.
      //! Note, not all IDs in database are listed.
      enum IDNUM {
         IDNUM_Undefined =          -1,
         IDNUM_Greenwich =          1001
         };

      //! Default constructor.
      PRIMEMERIDIAN (
         );

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

      //! Destructor.
      ~PRIMEMERIDIAN (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get longitude positive eastward from Greenwich meridian in degrees.
      double GetGreenwichLongitude (
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      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
   };

//=====================================================================================================================
//! Datum specification.
class CLASSLIBEXPORT DATUM {
   public:

      //! Datum ID numbers.
      //! Note, not all IDs in database are listed.
      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_NorthAmerican_1927 =       2346,
         IDNUM_NorthAmerican_1983 =       2347,
         IDNUM_SouthAmerican_1969 =       2386,
         IDNUM_Astronomical_Unspecified = 2700,
         IDNUM_MeanSeaLevel =             2900,
         };

      //! Datum type enumeration.
      enum TYPE {
         TYPE_Undefined =     0x0000,
         TYPE_Geodetic =      0x0002,  //!< Geodetic datum with ellipsoid and prime meridian
         TYPE_Vertical =      0x0004,  //!< Vertical (gravity-based) datum
         TYPE_Engineering =   0x0008,  //!< Engineering/Local datum
         TYPE_Temporal =      0x0010,  //!< Temporal (time-based) datum
         TYPE_Image =         0x0020,  //!< Image (pixel-based) datum
         TYPE_Astronomical =  0x0040,  //!< Astronomical datum
         TYPES_GeorefObject = (TYPE_Geodetic | TYPE_Engineering | TYPE_Astronomical)
         };

      //! Convert DATUM::TYPE to TEXTID.
      static TEXTID TypeToTextID (
         TYPE type
         );

      //! Default constructor.
      DATUM (
         );

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

      //! Destructor.
      ~DATUM (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Get abbreviation.
      const MISTRING& GetAbbr (
         ) const;

      //! Get default transformation operation definition list.
      const MILIST<COORDOPDEF>& GetDftTransOpList (
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get ellipsoid reference for geodetic datum.
      //! @return Ellipsoid reference.
      const ELLIPSOID& GetEllipsoid (
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      //! Get prime meridian reference for geodetic datum.
      const PRIMEMERIDIAN& GetPrimeMeridian (
         ) const;

      //! Get datum type.
      TYPE GetType (
         ) const;

      //! Get list of valid area names.
      const TEXTRESITEMLIST& GetValidAreaList (
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,                   //! Parent for contain node to be created
         const char *nodename = "Datum"
         ) const;

      //! Determine if datum can be converted to other datums.
      bool IsConvertible (
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      DATUM (PRIV& Priv);
      // 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)); 
   }

//=====================================================================================================================
//! Coordinate axis definition.
class CLASSLIBEXPORT COORDAXIS {
   public:

      //! Coordinate Axis ID numbers.
      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
         };

      //! Default constructor.
      COORDAXIS (
         );

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

      //! Destructor.
      ~COORDAXIS (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Create coordinate axis.
      ERRVALUE Create (
         const UOM::UNIT& unit,                 //!< Coordinate unit
         const MISTRING& name,                  //!< Axis name
         const MISTRING& SymbolPositive,        //!< Symbol for coordinate
         const MISTRING& SymbolNegative         //!< Symbol for negative coordinate, blank if same as for positive
         );

      //! Get abbreviation.
      const MISTRING& GetAbbr (
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None     //!< Flags for extra items to display
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      //! Get name fitted to limited space.
      //! Used where name is displayed in limited space such as a table column heading or field name.
      //! Returned name may contain spaces, and may contain symbol for axis if no other availble name will fit.
      //! If unit symbol is included, returned string will be in the form of "name (unitsym)".
      MISTRING GetNameFitted (
         int maxchars,                          //!< Maximum string length returned
         bool IncludeUnitSymbol                 //!< Include unit symbol in name
         ) const;

      //! Get symbol for specified usage.
      const MISTRING& GetSymbol (
         SYMBOLUSAGE usage = SYMBOLUSAGE_Unspecified
         ) const;

      //! Get axis measurement unit.
      const UOM::UNIT& GetUnit (
         ) const;

      //! Get valid range for ordinates on this axis.
      //! @return Valid range, will be arbitrarily large if no valid range defined.
      const DOUBLE_RANGE& GetValidRange (
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,                   //! Parent for contain node to be created
         const char *nodename = "CoordAxis"
         ) const;

      //! Determine if has different symbol for negative values than for positive.
      bool HasSymbolNegative (
         ) const;

      //! Set name for axis.
      void SetName (
         const MISTRING& textitem
         );

      //! Set symbol for reporting 'positive' values.
      //! Will use for all values if no 'negative' symbol specified.
      void SetSymbolPositive (
         const MISTRING& symbol
         );

      //! Set symbol for reporting 'negative' values.
      void SetSymbolNegative (
         const MISTRING& symbol
         );

      //! Set new measurement unit for axis.
      //! Does not alter valid range if any.
      void SetUnit (
         const UOM::UNIT& unit
         );

      //! Set valid range for axis values.
      void SetValidRange (
         const DOUBLE_RANGE& ValidRange   //!< Range to set
         );

      #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)); 
   }


//=====================================================================================================================
//! Coordinate operation parameter definition.
class CLASSLIBEXPORT COORDOPPARM {
   public:

      //! Coordinate Operation Parameter ID numbers.
      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_RightAscensionOfProjectionCenter =           1578,
         IDNUM_DeclinationOfProjectionCenter =              1579,
         IDNUM_CoefficientA0 =                              1600,
         IDNUM_CoefficientB0 =                              1700
         };

      //! CoordOpParm type enumeration.
      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
         };

      //! Convert IDNUM to AngleType.
      static ANGLETYPE IdNumToAngleType (
         IDNUM idnum
         );

      //! Lookup IDNUM given IDENTIFIER.
      static IDNUM LookupIdNum (
         const IDENTIFIER& Id
         );

      //! Default constructor.
      COORDOPPARM (
         );

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

      //! Destructor.
      ~COORDOPPARM (
         );

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

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Get 'angle type'.
      ANGLETYPE GetAngleType (
         ) const;

      //! Get description.
      const MISTRING& GetDescription (
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get formatted value and unit strings for display based on type.
      //! @return true if has value, false if not
      bool GetDisplayStrs (
         MISTRING& valstr,                      //!< Value string returned
         MISTRING& unitstr,                     //!< Unit string returned
         bool Strip0 = false                    //!< Strip trailing zeros from value
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      //! Get parameter type.
      TYPE GetType (
         ) const;

      //! Get measurement unit.
      const UOM::UNIT& GetUnit (
         ) const { return (m_unit); }

      //! Get numeric value.
      //! @return true if successful, false if value not numeric or not set.
      bool GetValue (
         double& value                    //!< Value returned if available
         ) const;

      //! Get boolean value.
      //! @return true if successful, false if value not boolean or not set.
      bool GetValue (
         bool& value                      //!< Value returned if available
         ) const;

      //! Get string, filename or URL value as STRUTF8.
      //! @return true if successful, false if value not set.
      bool GetValue (
         STRUTF8& value                   //!< Value returned if available
         ) const;

      //! Get string, filename or URL value as MISTRING.
      //! @return true if successful, false if value not set.
      bool GetValue (
         MISTRING& value                  //!< Value returned if available
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,                   //! Parent for contain node to be created
         const char *nodename = "CoordOpParm"
         ) const;

      //! Determine if has value set.
      bool HasValue (
         ) const { return (!m_svalue.IsEmpty()); }

      //! Determine if parameter is optional.
      //! Only useful when accessing method parameter list.
      bool IsOptional (
         ) const { return (m_optional); }

      //! Set IDNUM and boolean value.
      ERRVALUE Set (
         IDNUM IdNum,
         bool value
         );

      //! Set IDNUM and unitless integer value.
      ERRVALUE Set (
         IDNUM IdNum,
         int value
         );

      //! Set IDNUM, numeric value and unit if applicable.
      ERRVALUE Set (
         IDNUM IdNum,
         double value,
         UOM::IDNUM UnitIdNum = UOM::IDNUM_Unspecified
         );

      //! Set IDNUM, numeric value and UNIT.
      ERRVALUE Set (
         IDNUM IdNum,
         double value,
         const UOM::UNIT& unit
         );

      //! Set IDNUM and value from MISTRING.
      ERRVALUE Set (
         IDNUM IdNum,
         const MISTRING& string
         );

      //! Set IDNUM and value from STRUTF8.
      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;
   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)); 
   }


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

//! Factory class for creating COORDOP_IMPL instance.
class COORDOP_IMPL_FACTORY {
   public:
      virtual COORDOP_IMPL_SINGLE *v_ConstructImpl () = 0;
   };

//=====================================================================================================================
//! Coordinate Operation Method definition.
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)
         };

      //! Coordinate Operation Method identification numbers.
      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_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_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
         };

      //! Register implementation.
      static void RegisterImplementation (
         IDNUM IdNum,
         COORDOP_IMPL_FACTORY *pImplFactory
         );

      //! Default constructor.
      COORDOPMETHOD (
         );

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

      //! Destructor.
      ~COORDOPMETHOD (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Construct implementation instance for operation method using previously registered factory.
      ERRVALUE ConstructImplementation (
         COORDOP_IMPL_SINGLE *& pImpl           //! Pointer to constructed implementation returned
         ) const;

      //! Get default target coordinate system for operation.
      ERRVALUE GetDefaultTargetCoordSys (
         COORDSYS& CoordSys                     //!< Coordinate system returned
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      const COORDOPPARMLIST& GetParmList (
         ) const;

      //! Get source axes for operation.
      const COORDAXISLIST& GetSourceAxisList (
         ) const;

      //! Get target axes for operation.
      const COORDAXISLIST& GetTargetAxisList (
         ) const;

      //! Get method type.
      TYPE GetType (
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,                   //! Parent for contain node to be created
         const char *nodename = "Method"
         ) const;

      //! Determine if operation method is implemented.
      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)); 
   }


//=====================================================================================================================
//! Coordinate System definition.
class CLASSLIBEXPORT COORDSYS {
   public:

      //! Coordinate system ID numbers.
      //! Not all entries from database are listed.
      enum IDNUM {
         IDNUM_Undefined =                     -1,
         IDNUM_None =                           0,
         IDNUM_Projected2D_EN_m =            1200,    //! Projected 2D (east,north) meters
         IDNUM_Projected2D_EN_ft =           1201,    //! Projected 2D (east,north) feet
         IDNUM_Projected2D_EN_ftUS =         1202,    //! Projected 2D (east,north) US Survey feet
         IDNUM_UPS_North_m =                 1250,    //! Univeral Polar Stereographic North zone (east, north) meters
         IDNUM_UPS_South_m =                 1251,    //! Univeral Polar Stereographic South zone (east, north) meters
         IDNUM_Cartesian2D_XY_m =            1260,    //! Local 2D cartesian, not same as projected
         IDNUM_Cartesian3D_XYZ_m =           1261,    //! Local 3D cartesian, not same as geocentric
         IDNUM_Ellipsoidal2D_Deg =           1280,    //! Ellipsoidal 2D (lon,lat) degrees
         IDNUM_Ellipsoidal3D_DegM =          1281,    //! Ellipsoidal 3D (lon,lat,h) degrees, meters
         IDNUM_Ellipsoidal2D_Grad =          1282,    //! Ellipsoidal 2D (lon,lat) grads
         IDNUM_Ellipsoidal3D_GradM =         1283,    //! Ellipsoidal 3D (lon,lat,h) grads, meters
         IDNUM_Equatorial2D_Deg =            1288,    //! Equatorial (right ascension, declination) degrees
         IDNUM_Equatorial2D_HrDeg =          1289,    //! Equatorial (right ascension, declination) hours, degrees
         IDNUM_GravityRelated_Height_m =     1290,
         IDNUM_GravityRelated_Height_ftUS =  1291,
         IDNUM_GravityRelated_Depth_m =      1292,
         IDNUM_Zoned_MGRS =                  1295,    //! Military Grid Reference System (zoned)
         IDNUM_Spherical3D =                 1298,    //! Spherical 3D, not same as ellipsoidal 3D (lon,lat,r) degrees, meters
         IDNUM_Geocentric =                  1299     //! Geocentric (x,y,z) meters
         };

      //! Coordinate system type enumeration.
      enum TYPE {
         TYPE_Undefined =           0x0000,
         TYPE_Cartesian =           0x0001,  //! Cartesian (not projected)
         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)
         };

      //! Convert COORDSYS::TYPE to TEXTID.
      static TEXTID TypeToTextID (
         TYPE type
         );

      //! Default constructor.
      COORDSYS (
         );

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

      //! Destructor.
      ~COORDSYS (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Create coordinate system definition.
      ERRVALUE Create (
         TYPE type,                             //!< Coordinate system type
         const COORDAXISLIST& AxisList          //!< List of coordinate axes
         );

      //! Get coordinate axis using index.
      const COORDAXIS& GetAxis (
         int axisidx                            //!< 0-based position of axis in list
         ) const;

      //! Get coordinate axis list reference.
      const COORDAXISLIST& GetAxisList (
         ) const;

      //! Get coordinate system dimension.
      //! @return Dimension (1-3)
      int GetDimension (
         ) const;

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                      //!< String returned, will be initially cleared if indent is 0
         int indent,                            //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

      //! Get method type for projected coordinate system.
      COORDOPMETHOD::TYPE GetProjectedMethodType (
         ) const;

      //! Get coordinate system type.
      TYPE GetType (
         ) const;

      //! Get valid datum type for coordinate system.
      DATUM::TYPE GetValidDatumType (
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,                   //!< Parent for contain node to be created
         const char *nodename = "CoordSys"
         ) const;

      //! Determine if has all axes in specified list.
      bool HasAxes (
         const COORDAXISLIST& AxisList          //!< List of axes
         ) const;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      // Internal constructor.
      COORDSYS (PRIV& Priv);
      bool IsEqual (const COORDSYS& rhs) const;
   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)); 
   }


//=====================================================================================================================
//! Coordinate Operation definition.
class CLASSLIBEXPORT COORDOPDEF {
   public:

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

      //! Default constructor.
      COORDOPDEF (
         );

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

      //! Destructor.
      ~COORDOPDEF (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Create operation definition with specified method and parameter list.
      ERRVALUE Create (
         const MISTRING& name,
         const COORDOPMETHOD& method,
         const COORDOPPARMLIST& parmlist
         );

      //! Get multiline string suitable for display.
      void GetDisplay (
         MISTRING& string,                   //!< String returned, will be initially cleared if indent is 0
         int indent,                         //!< Indent level
         GETDISPLAY flags = GETDISPLAY_None  //!< Flags for extra items to display
         ) const;

      //! Get identifer list.
      const IDENTIFIERLIST& GetIdList (
         ) const;

      //! Get MicroImages identification number.
      IDNUM GetIdNum (
         ) const;

      //! Get operation method.
      const COORDOPMETHOD& GetMethod (
         ) const;

      //! Get name.
      const MISTRING& GetName (
         ) const;

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

      //! Get list of parameters.
      const COORDOPPARMLIST& GetParmList (
         ) const;

      //! Get value for numeric parameter in specified unit.
      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        //!< Parameter ID number
         double& value,                   //!< Value returned if available
         const UOM::UNIT& unit            //!< Unit to return value in
         ) const;

      //! Get value for numeric parameter in specified unit ID.
      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        //!< Parameter ID number
         double& value,                   //!< Value returned if available
         int unitid                       //!< Unit ID
         ) const;

      //! Get value for boolean parameter.
      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        //!< Parameter ID number
         bool& value                      //!< Value returned if available
         ) const;

      //! Get value for string parameter.
      ERRVALUE GetParmValue (
         COORDOPPARM::IDNUM idnum,        //!< Parameter ID number
         MISTRING& value                  //!< Value returned if available
         ) const;

      //! Get source coordinate reference system.
      const COORDREFSYS& GetSourceCRS (
         ) const;

      //! Get list of operation steps for concatenated operation.
      const MILIST<COORDOPDEF>& GetStepList (
         ) const;

      //! Get target coordinate reference system.
      const COORDREFSYS& GetTargetCRS (
         ) const;

      //! Get list of valid area names.
      const TEXTRESITEMLIST& GetValidAreaList (
         ) const;

      //! Get XMLNODE representation.
      XMLNODE* GetXML (
         XMLNODE *parentnode,             //! Parent for contain node to be created
         const char *nodename = "CoordOp"
         ) const;

      //! Determine if has specified parameter with value set.
      bool HasParmValue (
         COORDOPPARM::IDNUM idnum         //!< Parameter ID number
         ) const;

      //! Determine if is 'concatenated' coordinate operation.
      bool IsConcatenated (
         ) const;

      //! Determine if uses implemented operation method(s).
      bool IsImplemented (
         ) const;

      //! Set operation method.
      void SetMethod (
         const COORDOPMETHOD& CoordOpMethod
         );

      //! Set operation method using IDNUM.
      void SetMethod (
         COORDOPMETHOD::IDNUM MethodIdNum
         );

      //! Set parameter value.
      ERRVALUE SetParm (
         const COORDOPPARM& parm
         );

      //! Set parameter by ID number and boolean value.
      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         bool value
         );

      //! Set parameter by ID number and unitless integer value.
      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         int value
         );

      //! Set parameter by ID number, numeric value and UNIT.
      ERRVALUE SetParm (
         COORDOPPARM::IDNUM idnum,
         double value,
         const UOM::UNIT& unit
         );

      //! Set parameter by ID number, numeric value and unit IDNUM.
      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;
      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)); 
   }

//=====================================================================================================================
//! Coordinate Reference System.
class CLASSLIBEXPORT COORDREFSYS {
   public:

      //! Coordinate reference system ID numbers.
      //! Note, not all IDs in database are listed.
      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,
         };

      //! Method for distance computation.
      enum DISTANCEMETHOD {
         DISTANCEMETHOD_Projected,           //!< Projected distance, requires projected CRS
         DISTANCEMETHOD_Geodesic,            //!< Geodesic distance, shortest path over ellipsoid
//       DISTANCEMETHOD_StraightLine,        //!< Straight line distance "through the earth"
         };

      //! Default constructor.
      COORDREFSYS (
         );

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

      //! Destructor.
      ~COORDREFSYS (
         );

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

      //! Assign by IDENTIFIER.
      ERRVALUE Assign (
         const IDENTIFIER& Id
         );

      //! Assign by MicroImages ID number.
      ERRVALUE Assign (
         IDNUM IdNum
         );

      //! Assign from XMLNODE.
      ERRVALUE Assign (
         const XMLNODE* xmlnode
         );

      //! Assign from MISTRING.
      ERRVALUE Assign (
         const MISTRING& string                 //!< String representation previously generated by GetString().
         );

      //! Assign from legacy projection parameter structure.
      ERRVALUE Assign (
         const OLDPROJPARM& projparm
         );

// #ifndef NO_DEPRECATED
      //! Assign from legacy MAPPROJPARM structure.
      DEPRECATED ERRVALUE Assign (
         const MAPPROJPARM& projparm
         );
// #endif

      //! Clear coordinate reference system, resetting to undefined.
      void Clear (
         );

      //! Compute angle between projected CRS and true north at specified point.
      ERRVALUE ComputeAngleToNorth (
         const DPOINT2D& point,                 //!< Point to compute at
         double& angle,                         //!< Angle in specified unit returned
         int angleunitid                        //!< Unit to return angle in (UNIT_PlaneAngle_...)
         ) const;

      //! Compute distance between pair of points.
      ERRVALUE ComputeDistance (
         const DPOINT2D& point1,                //!< First point
         const DPOINT2D& point2,                //!< Second point
         DISTANCEMETHOD method,                 //!< Distance computation method
         double& distance,                      //!< Distance returned
         UOM::IDNUM LengthUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;