mi32/region.h

Go to the documentation of this file.

/**
 * \file region.h <mi32/region.h>
 * \brief Functions and structure for regions
 *
 * \if NODOC
 * $Id: region.h_v 1.114 2003/09/15 13:49:56 fileserver!dwilliss Exp $
 *
 * $Log: region.h_v $
 * Revision 1.114  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.113  2002/12/20 20:42:05  dwilliss
 * For some reason, VC6.0 suddenly decided  friend operators wern't friends
 * any more.  Defined public inline methods to do what they needed and made
 * the friend operators call those.
 *
 * Revision 1.112  2002/07/30 19:06:59  dwilliss
 * Use 0 instead of NULL.  MacOS X seems to have problems declaring NULL
 *
 * Revision 1.111  2001/12/20 22:13:10  scowan
 * Removed deprecated include.
 *
 * Revision 1.110  2001/10/08 21:01:30  scowan
 * Added has dest region method.
 *
 * Revision 1.109  2001/10/08 20:43:11  scowan
 * Made more functions take const regions.
 *
 * Revision 1.108  2001/02/01 22:20:26  mju
 * Fix GEOREGION::operator-=.
 *
 * Revision 1.107  2000/11/27 18:01:55  mju
 * Add comments that intersect, union, subtract and xor APPEND to destination.
 *
 * Revision 1.106  2000/11/15 15:01:19  mju
 * Move region generation defns to rgngen.h.
 *
 * Revision 1.105  2000/10/26 19:56:52  mju
 * Add georegion::Get/SetSource/Dest... methods.
 *
 * Revision 1.104  2000/09/18 16:58:13  mju
 * Make GEOREGION dtor free the region.
 *
 * Revision 1.103  2000/09/14 17:52:04  msmith
 * Added MregionGetStats - calculates area, perimeter, and centroid.
 *
 * Revision 1.102  2000/09/14 17:47:46  mju
 * Use const for TRANSPARN in regionFromVector...
 *
 * Revision 1.101  2000/08/04 16:47:40  mju
 * Change ConvertToLatLon to take maxerror parm.
 *
 * Revision 1.100  2000/08/03 14:44:43  mju
 * Add MregionConvertToLatLon.
 *
 * Revision 1.99  2000/08/02 22:06:52  mju
 * Change georegion:setpolygon to AddSubRegion() and don't clear first.
 *
 * Revision 1.98  2000/08/02 15:39:10  mju
 * Enable use of GEOREGION class.
 *
 * Revision 1.97  2000/07/18 20:50:22  sparsons
 * Genitor documentation.
 *
 * Revision 1.91  1999/05/12  20:50:26  mju
 * Use const for most Mregion functions.
 * Add GEOREGION class.
 *
 * Revision 1.89  1999/04/29  19:33:55  mju
 * Move prototypes requiring X stuff to xdefns.h.
 *
 * Revision 1.88  1999/04/29  16:00:58  mju
 * Move DREGION/DSUBREGION definitions here.
 *
 * Revision 1.87  1999/03/15  15:37:48  mju
 * Use const for some source regions and test funcs.
 *
 * Revision 1.86  1999/01/05  19:12:39  scowan
 * Swapped multiple keywords
 *
 * \endif
**/

#ifndef  INC_MI32_REGION_H
#define  INC_MI32_REGION_H

#ifndef  INC_MI32_STDDEFNS_H
   #include <mi32/stddefns.h>
#endif

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

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

#ifndef  INC_MI32_TRANS2DC_H
   #include <mi32/trans2dc.h>
#endif

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

#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
#endif

/*----------------------------------------------------------------------------*/
/*    DREGION - Region structure used by Mr...() functions                    */
/*----------------------------------------------------------------------------*/

/*** !!! The structures DSUBREGION and DREGION cannot be changed without significant alterations to geom.dll !!! */

struct DSUBREGION {
   /* DO NOT CHANGE THIS STRUCTURE UNDER PENALTY OF ILLOP'S */
   DRECT2D Extents;
   UINT32 NumPoints;
   UINT32 NumIslands;
   UINT32 *IsleNumPoints;
   DPOINT2D *Points;
   };

struct DREGION {
   /* DO NOT CHANGE THIS STRUCTURE UNDER PENALTY OF ILLOP'S */
   UINT32 NumRegions;                  //!<  Number of sub regions 
   DSUBREGION *RegionList;             //!<  Original Sub region list 
   DRECT2D Extents;
   DSUBREGION *DestRegionList;         //!<  Sub region list run through TRANSPARM 
   DRECT2D DestExtents;
   MAPPROJPARM mapparm;                //!<  Region coordinates if in a projection are implied 
   TRANSPARM transparm;                //!<  Transformation object<->region 
   };

/**
*  This will take a little explanation.  The DSUBREGION structure follows the
*  same storage format as the CAD Polygon structure.  The IsleNumPoints array
*  is an array containing the number of points per island.  The Points
*  array contains both the points for the exterior polygon region and
*  the islands.  The layout of the points is as follows: first the exterior
*  polygon is stored then the points for each island in the order stored
*  in the IsleNumPoints array.  If no islands exist, then the IsleNumPoints
*  array is not allocated.  Anything inside an island is considered to be
*  "outside" the region.  DREGION and DSUBREGION are defined in stddefns.h
**/


#define  REGIONTEST_CompInside   1     //!<  Only elements completely inside region 
#define  REGIONTEST_PartInside   2     //!<  All elements that partially or completely fall inside region 
#define  REGIONTEST_CompOutside  3     //!<  Only elements completely outside region 
#define  REGIONTEST_PartOutside  4     //!<  All elements that partially or completely fall outside region 
#define  REGIONTEST_ClipInside   5     //!<  Clip inside, not actual test 
#define  REGIONTEST_ClipOutside  6     //!<  Clip outside, not actual test 

#define  REGIONCOMP_Outside      1     //!<  Element is outside the region 
#define  REGIONCOMP_Inside       2     //!<  Element is inside the region 
#define  REGIONCOMP_Intersect    3     //!<  Element intersects the region 
#define  REGIONCOMP_Overlap      4     //!<  Element overlaps the region, both inside and outside 

#define  REGIONFLAG_TestAsLines  0x00000001  //!<  Test element if possible as line data 


/**
*  Functions prototypes
**/

#if defined(__cplusplus)
extern "C" {
#endif

//!:Associate with "Region Functions"
//!\addtogroup Region Region Functions
//!@{

//! Change the region projection.
//!
//! This function can be used to set/change the projection of the region's
//!   coordinates.  If the region's projection is arbitrary, then the new
//!   projection is set, otherwise the function converts the coordinates
//!   to the new projection.  This is why MregionInit() needs to be called.
//!   If the destination region list exists, it will be recomputed.
GEOMLIBEXPORT ERRVALUE MregionChangeProj (
   DREGION *region,                    //!< The region to set/change the region projection on
   const MAPPROJPARM *mapparm          //!< The projection to set the region to
   );

//! Check if extents is outside the entire region.
//!
//! @return REGIONCOMP_Outside if outside, REGIONCOMP_Overlap if not, or error code. 
GEOMLIBEXPORT int MregionCheckIfOutside (
   const DRECT2D *extents,             //!< Rectangle to check if outside
   const DREGION *region               //!< The region to check against
   );

//! Clear a region of all sub-regions.
GEOMLIBEXPORT void MregionClear (
   DREGION *region
   );

//! Clip a line to a region.
//!
//! RegionTest values:
//!      \li \b REGIONTEST_ClipInside     Clip the line to the inside of the region
//!      \li \b REGIONTEST_ClipOutside    Clip the line to the outside of the region   
//!      
//!   Notes:
//!      If clipping to a single non rotated rectangle a faster clipping algorithm is used if
//!      the extents are specified in the region and the NumRegions is 0 or the RegionList 
//!      field is NULL.  If there are multiple subregions and some are rectangles then the 
//!      faster clipping algorithm is used if the extents are specified in the SubRegion and 
//!      the Points field is set to NULL.
GEOMLIBEXPORT int MregionClipLine (
   const DREGION *region,                                //!< The region to clip to
   const DPOLYGON *line,                                 //!< The line to clip
   int (*ClippedLine)(DPOLYGON *retline, void *udata),   //! Clipped line callback function 
   void *udata,                                          //!< User data passed to ClippedLine()
   UINT32 RegionTest                                     //!< The type of clip to perform
   );

//! Clip a point to a region.
//!
//! RegionTest values:
//!      \li \b REGIONTEST_ClipInside     Clip the point to the inside of the region
//!      \li \b REGIONTEST_ClipOutside    Clip the point to the outside of the region
GEOMLIBEXPORT int MregionClipPoint (
   const DREGION *region,                                //!< The region to clip to
   const DPOINT3D *pt,                                   //!< The point to clip
   int (*ClippedPoint)(DPOINT3D *pt, void *udata),       //! Clipped line callback function
   void *udata,                                          //!< User data passed to ClippedPoint()
   UINT32 RegionTest                                     //!< The type of clip to perform
   );

//! Clip a polygon to a region.
//!
//! RegionTest values:
//!      \li \b REGIONTEST_ClipInside     Clip the polygon to the inside of the region
//!      \li \b REGIONTEST_ClipOutside    Clip the polygon to the outside of the region
GEOMLIBEXPORT int MregionClipPolygon (
   const DREGION *region,              //!< The region to clip to
   const DPOLYGON *IPolygon,           //!< The polygon to clip
   DPOLYGON **OPolyList,               //!< List of clipped polygons RETURNED, free with MmFree()
   UINT32 *ONumPolys,                  //!< Number of clipped polygons RETURNED
   UINT32 RegionTest                   //!< The type of clip to perform
   );

//! Clip a list of polygons to a region and place in a LPOLYGON array.
//!
//! RegionTest values:
//!      \li \b REGIONTEST_ClipInside     Clip the polygon to the inside of the region
//!      \li \b REGIONTEST_ClipOutside    Clip the polygon to the outside of the region
GEOMLIBEXPORT int MregionClipPolygonsL (
   const DREGION *region,              //!< The region to clip to
   const DPOLYGON *IPolyList,          //!< The list of polygons to clip
   UINT32 INumPolys,                   //!< Number of polygons in the IPolyList array
   LPOLYGON **OPolyList,               //!< List of clipped polygons RETURNED, free with MmFree()
   UINT32 *ONumPolys,                  //!< Number of clipped polygons RETURNED
   UINT32 RegionTest                   //!< The type of clip to perform
   );

//! Compares a region to a given line.
//!
//! Returns error or one of the values below.
//!
//! <pre>
//! #define REGIONCOMP_Outside   1    //!<  Element is outside the region 
//! #define REGIONCOMP_Inside    2    //!<  Element is inside the region 
//! #define REGIONCOMP_Intersect  3    //!<  Element intersects the region 
//! #define REGIONCOMP_Overlap   4    //!<  Element overlaps the region, both inside and outside 
//! </pre>
//!
//! The "INT32 *SubRegion" returns which sub region the line intersected with.
GEOMLIBEXPORT int MregionCompareLine (
   const DPOLYGON *line, 
   const DREGION *region, 
   INT32 *SubRegion
   );

//! Convert region to Latitude-Longitude WGS84 coordinates
GEOMLIBEXPORT ERRVALUE MregionConvertToLatLon (
   DREGION *region,                    //!< Region to convert
   double maxerror = 0.0               //!< Maximum error for inserting points, 0.0 to not insert additional points
   );

//! Copy one region to another.
GEOMLIBEXPORT ERRVALUE MregionCopy (
   DREGION *DestRegion,                //!< Region to copy to
   const DREGION *SrcRegion            //!< Region to copy from
   );

//! Convert destination portion of region to LPOLYGON array.
GEOMLIBEXPORT int MregionDestToPolygonsL (
   DREGION *region,                    //!< Region
   LPOLYGON **polys,                   //!< Polygon array allocated and returned
   INT32 *numpolys                     //!< Number of polygons returned
   );

//! Exclusive Or two regions together and append result to destination region.
//!
//! NOTES:  DestRegion will have the same map projection and transparm as RegionB.  If the return value
//!   is ERgnTooCompToComb and RegionB == NULL, DestRegion will be reset to its original region.
GEOMLIBEXPORT int MregionExclusiveOr (
   DREGION *DestRegion,                //!< Region to store result
   const DREGION *RegionA,             //!< Region to "exclusive or" with RegionB
   const DREGION *RegionB              //!< Region to intersect with RegionA (can be 'NULL' or '== DestRegion')
   );

//! Free all data associated with a region.
GEOMLIBEXPORT void MregionFree (
   DREGION *region                     //!< Region to free
   );

//! Generate the destination region.
//!
//! This function generates the 'DestRegionList' field in the region
//!   based on the inverse of the 'transparm' field in the region.
GEOMLIBEXPORT ERRVALUE MregionGenerateDest (
   DREGION *region                     //!< The region
   );

//! Generate point inside specified subregion.
GEOMLIBEXPORT int MregionGenPointInSub (
   const DREGION *region, 
   INT32 SubIndex, 
   DPOINT2D *retpt
   );

//! Determine if region has 'destination' coordinate region.
inline bool MregionHasDest (
   const DREGION *region
   ) {
   return (region->DestRegionList != 0);
   }


//! Initialize the region structure.
GEOMLIBEXPORT void MregionInit (
   DREGION *region                     //!< Region to initialize
   );

//! Intersect two regions together and append result to destination region.
//!
//! NOTES:  DestRegion will have the same map projection and transparm as RegionB.  If the return value 
//!   is ERgnTooCompToComb and RegionB == NULL, DestRegion will be reset to its original region.
GEOMLIBEXPORT int MregionIntersect (
   DREGION *DestRegion, 
   const DREGION *RegionA, 
   const DREGION *RegionB
   );

//! Determine if specified point is inside given subregion.
//!
//! @return TRUE if point inside, FALSE if not, < 0 if error.
GEOMLIBEXPORT int MregionIsPointInSub (
   const DSUBREGION *subregion,        //!< Subregion to check point against
   const DPOINT2D *point               //!< Point to test in subregion's coordinates
   );

//! Set input side of the region's TRANSPARM.
//!
//! This function copies the input parameters from the 'transparm' to the
//!   'region'.  The input parameters determine either the computation of
//!   the DestRegionList or the conversion of test data (points, lines, etc...)
//!   to the region coordinates.
GEOMLIBEXPORT ERRVALUE MregionSetTransParm (
   DREGION *region,                    //!< Region to set input coordinate TRANSPARM info on
   const TRANSPARM *transparm          //!< TRANSPARM to get input transformation settings from
   );

//! Subtract region B from region A and append result to destination region.
//!
//! NOTES:  DestRegion will have the same map projection and transparm as RegionB.  If the return value 
//!   is ERgnTooCompToComb and RegionB == NULL, DestRegion will be reset to its original region.
GEOMLIBEXPORT int MregionSubtract (
   DREGION *DestRegion, 
   const DREGION *RegionA, 
   const DREGION *RegionB
   );

//! Test a line against the region.
//!
//! @return 1 if successful, 0 if not, < 0 error.
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the line completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the line partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the line completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the line partially outside the region
GEOMLIBEXPORT int MregionTestLine (
   const DPOLYGON *line,               //!< The line to test
   const DREGION *region,              //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//! Test a point against the region.
//!
//! @return 1 if successful, 0 if not, < 0 error.
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the point completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the point partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the point completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the point partially outside the region
GEOMLIBEXPORT int MregionTestPoint (
   const DPOINT2D *pt,                 //!< The point to test
   const DREGION *region,              //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//! Test a simple polygon against the region.
//!
//! @return 1 if successful, 0 if not, < 0 error.  
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the polygon completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the polygon partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the polygon completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the polygon partially outside the region
GEOMLIBEXPORT int MregionTestPolygon (
   const DPOLYGON *poly,               //!< The simple polygon to test
   const DREGION *region,              //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//! Test a complex polygon (polygon with islands) against the region.
//!
//! @return 1 if successful, 0 if not, < 0 error.
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the sub-region completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the sub-region partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the sub-region completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the sub-region partially outside the region
GEOMLIBEXPORT int MregionTestSubRegion (
   const DSUBREGION *subregion,        //!< The sub-region (complex polygon) to test
   const DREGION *region,              //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//! Copy sub-regions to another.
GEOMLIBEXPORT ERRVALUE MregionTransfer (
   DREGION *DestRegion, 
   const DREGION *SrcRegion
   );

//! Convert a region to a new coordinate system using a TRANSPARM.
GEOMLIBEXPORT ERRVALUE MregionTranslate (
   DREGION *region,                    //!< Region to translate to a new coordinate system
   const TRANSPARM *tp                 //!< TransParm to use in the translation
   );

//! Union two regions together and append result to destination region.
//!
//! NOTES:  DestRegion will have the same map projection and transparm as RegionB.  If the return 
//! value is ERgnTooCompToComb and RegionB == NULL, DestRegion will be reset to its original region.
GEOMLIBEXPORT int MregionUnion (
   DREGION *DestRegion,                //!< Region to store result
   const DREGION *RegionA,             //!< Region to union with RegionB
   const DREGION *RegionB              //!< Region to union with RegionA (can be 'NULL' or '== DestRegion')
   );

//! Update the extents and orientation of a region.
GEOMLIBEXPORT ERRVALUE MregionUpdate (
   DREGION *region                     //!< Region to update extents and check orientation
   );

//! Append region to vector object as vector polygons.
int MregionAppendToVector (
   int vid,                            //!< Open handle to RVC vector object to append to
   void *vvinfo,                       //!< Pointer to vector header, it will be updated
   DREGION *region                     //!< The region to append to the vector
   );

//! Read polygon convert to screen coords and clip.
int MregionClipVectPolygon (
   DREGION *region, 
   int vid,                            //!< ID of opened vector object
   INT32 PolyNum,                      //!< Polygon number to read
   LPOLYGON **rpolygons, 
   INT32 *rnumpolys, 
   UINT32 flags
   );

//! Get area, perimeter, and centroid with and with islands for the given region.
ERRVALUE MregionGetStats (
   const DREGION& region,              //!< Region to calculate from
   double *Area,                       //!< Area passed / returned
   double *Perimeter,                  //!< Perimeter passed / returned
   DPOINT2D *Centroid,                 //!< Centroid passed / returned
   double *AreaNotIsle,                //!< Area without islands passed / returned
   double *PerimeterNotIsle,           //!< Perimeter without islands passed / returned
   DPOINT2D *CentroidNotIsle           //!< Centroid without islands passed / returned
   );

//! Test a CAD element against the region.
//!
//! @return 1 if successful, 0 if not. 
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the element completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the element partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the element completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the element partially outside the region  
//!
//!   Flags:
//!      \li\b REGIONFLAG_TestAsLines     Test polygon type elements as lines rather than polygons
int MregionTestCADElement (
   void *velem,                        //!< CADELEMENT to test with
   const DREGION *region,                    //!< The region to test against
   UINT32 RegionTest,                  //!< The type of test to perform
   UINT32 flags                        //!< Flags
   );

//! Test a TIN element against the region.
//!
//! @return 1 if successful, 0 if not.
//!
//!   RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the element completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the element partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the element completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the element partially outside the region
int MregionTestTINElement (
   int tid,                            //!< Handle to open TIN object
   int ElemType,                       //!< Element type ELEMTYPE_...
   INT32 ElemNum,                      //!< Element number to test
   const DREGION *region,                    //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//! Test a vector element against the region.
//!
//! @return 1 if successful, 0 if not. 
//!
//! RegionTest values:
//!      \li\b REGIONTEST_CompInside      Is the element completely inside the region
//!      \li\b REGIONTEST_PartInside      Is the element partially inside the region
//!      \li\b REGIONTEST_CompOutside     Is the element completely outside the region
//!      \li\b REGIONTEST_PartOutside     Is the element partially outside the region
int MregionTestVectorElement (
   int vid,                            //!< Handle to open vector object
   int ElemType,                       //!< Element type ELEMTYPE_...
   INT32 ElemNum,                      //!< Element number to test
   const DREGION *region,                    //!< The region to test against
   UINT32 RegionTest                   //!< The type of test to perform
   );

//!@}

#if defined(__cplusplus)
}                       
#endif


//-----------------------------------------------------------------------------
//    GEOREGION class
//-----------------------------------------------------------------------------

//! 
class GEOREGION {
public:

   enum TESTMODE {
      TESTMODE_FullOutside =  REGIONTEST_CompOutside, //!< Test if fully outside region
      TESTMODE_PartOutside =  REGIONTEST_PartOutside, //!< Test if any part is outside region
      TESTMODE_FullInside =   REGIONTEST_CompInside,  //!< Test if fully inside region
      TESTMODE_PartInside =   REGIONTEST_PartInside   //!< Test if any part is inside region
      };

   enum CLIPMODE {
      CLIPMODE_Inside =    REGIONTEST_ClipInside,  //!< Clip to inside of region
      CLIPMODE_Outside =   REGIONTEST_ClipOutside  //!< Clip to outside of region
      };

   // CONSTRUCTION / DESTRUCTION

   //! Default constructor, create empty region.
   GEOREGION (                         
      ) {
      MregionInit(&m_region);
      }

   //! Copy constructor.
   GEOREGION (                         
      const GEOREGION& rhs
      ) {
      MregionInit(&m_region);
      MregionCopy(&m_region,&rhs.m_region);
      }

   //! Construct from DREGION (implicit).
   GEOREGION (                         
      const DREGION& rhs
      ) {
      MregionInit(&m_region);
      MregionCopy(&m_region,&rhs);
      }

   //! Destructor.
   ~GEOREGION (                        
      ) {
      MregionFree(&m_region);
      }

   // OPERATORS

   //! Assignment from GEOREGION.
   GEOREGION& operator= (              
      const GEOREGION& rhs
      ) {
      if (this != &rhs) {
         MregionCopy(&m_region,&rhs.m_region);
         }
      return (*this);
      }

   //! Assignment from DREGION.
   GEOREGION& operator= (              
      const DREGION& rhs
      ) {
      MregionCopy(&m_region,&rhs);
      return (*this);
      }

   //! Intersection.
   GEOREGION& operator&= (             
      const GEOREGION& rhs
      ) {
      if (this != &rhs) {
         MregionIntersect(&m_region,&rhs.m_region,0);
         }
      return (*this);
      }

   //! Union.
   GEOREGION& operator|= (             
      const GEOREGION& rhs
      ) {
      if (this != &rhs) {
         MregionUnion(&m_region,&rhs.m_region,0);
         }
      return (*this);
      }

   //! Sum (same as union).
   GEOREGION& operator+= (             
      const GEOREGION& rhs
      ) {
      return (operator|=(rhs));
      }

   //! Subtract one region from another.
   GEOREGION& operator-= (             
      const GEOREGION& rhs
      ) {
      DREGION TempRegion;
      MregionInit(&TempRegion);
      MregionCopy(&TempRegion,&m_region);
      MregionClear(&m_region);
      MregionSubtract(&m_region,&TempRegion,&rhs.m_region);
      MregionFree(&TempRegion);
      return (*this);
      }

   //! Exclusive-or.
   GEOREGION& operator^= (             
      const GEOREGION& rhs
      ) {
      MregionExclusiveOr(&m_region,&rhs.m_region,0);
      return (*this);
      }

   // METHODS

   //! Add polygon to region as new subregion.
   ERRVALUE AddSubRegion (
      const DPOLYGON& poly                //!< Polygon in region 'source' coordinates
      ) {
      if (poly.numpts < 3) return (0);
      int err;
      if ((err = MmReallocC((void**)&m_region.RegionList,(m_region.NumRegions+1)*sizeof(DSUBREGION),m_region.NumRegions*sizeof(DSUBREGION))) < 0) return (err);
      DSUBREGION *srp = &m_region.RegionList[m_region.NumRegions++];
      if ((err = MmAlloc((void**)&srp->Points,(poly.numpts+1)*sizeof(DPOINT2D))) < 0) return (err);
      memcpy(srp->Points,poly.point,poly.numpts*sizeof(DPOINT2D));
      srp->NumPoints = poly.numpts;
      if (srp->Points[0] != srp->Points[poly.numpts-1]) {
         srp->Points[srp->NumPoints++] = srp->Points[0];
         }
      srp->Extents.SetInvalid();
      for (int i = 0; (i < poly.numpts); ++i) {
         srp->Extents.Extend(poly.point[i]);
         }
      m_region.Extents.Extend(srp->Extents);
      return (0);
      }

   //! Clear region.
   void Clear (
      ) {
      MregionClear(&m_region);
      return;
      }

   //! Clip DPOLYLINE to region.
   bool ClipLine (                     
      const DPOLYLINE& line,              //!< Line to clip in region 'destination' coordinates
      CLIPMODE clipmode,                  //!< Clipping mode (CLIPMODE_Inside or CLIPMODE_Outside)
      int (*ClipOutputFunc)(              //! Function to output clipped sections to
         const DPOLYLINE *clippedline,    //!< Clipped line section
         void *funcdata                   //!< Data passed from ClipLine
         ),                               //! Returns < 0 if error to stop clipping
      void *ClipOutputData                //!< Data to pass on to clipping output function
      ) const {                           //! Returns false if line was outside region, true if inside or clipped
      return (MregionClipLine(&m_region,&line,reinterpret_cast<int(*)(DPOLYLINE*,void*)>(ClipOutputFunc),ClipOutputData,clipmode) > 0);
      }

   //! Clip DPOINT3D to region.
   bool ClipPoint (                    
      const DPOINT3D& point,              //!< Point to clip in region 'destination' coordinates
      CLIPMODE clipmode,                  //!< Clipping mode (CLIPMODE_Inside or CLIPMODE_Outside)
      int (*ClipOutputFunc)(              //! Function to output clipped point to
         const DPOINT3D* point,           //!< Point if was clipped
         void *funcdata                   //!< Data passed from ClipPoint
         ),                               //! Returns < 0 if error to stop clipping
      void *ClipOutputData                //!< Data to pass on to clipping output function
      ) const {                           //! Returns false if point was outside region, true if inside
      return (MregionClipPoint(&m_region,&point,reinterpret_cast<int(*)(DPOINT3D*,void*)>(ClipOutputFunc),ClipOutputData,clipmode) > 0);
      }

   //! Convert region to Latitude-Longitude WGS84 coordinates
   ERRVALUE ConvertToLatLon (
      double maxerror = 0.0               //!< Maximum error for point insertion, 0.0 to not insert points
      ) {
      return (MregionConvertToLatLon(&m_region,maxerror));
      }

   //! Generate 'destination' coordinates.
   ERRVALUE GenerateDest (
      ) {
      return (MregionGenerateDest(&m_region));
      }

   //! Get extents in 'destination' coordinates.
   const DRECT2D& GetDestExtents (     
      ) const {
      MregionGenerateDest(const_cast<DREGION*>(&m_region));
      return (m_region.DestExtents);
      }

   //! Get extents in region 'source' coordinates.
   const DRECT2D& GetExtents (
      ) const {
      return (m_region.Extents);
      }

   //! Get number of sub-regions.
   int GetNumSubRegions (
      ) const {
      return (m_region.NumRegions);
      }

   //! Get region 'source' projection.
   const MAPPROJPARM& GetProjection (  
      ) const {
      return (m_region.mapparm);
      }

   const DREGION& GetRegion (
      ) const {
      return (m_region);
      }

   DREGION& GetRegion (
      ) {
      return (m_region);
      }

   //! Get extents in 'source' coordinates.
   const DRECT2D& GetSourceExtents (
      ) const {
      return (m_region.Extents);
      }

   //! Get 'source' projection.
   const MAPPROJPARM& GetSourceProjection (
      ) const {
      return (m_region.mapparm);
      }

   //! Get region's TRANSPARM.
   //! Note that the "input" side of the transparm corresponds to the region's 'destination'
   //! coordinates and the "output" side corresponds to the region's 'source' coordinates.
   const TRANSPARM& GetTransParm (
      ) const {
      return (m_region.transparm);
      }
      
   bool HasDestRegion (
      ) const {
      return (MregionHasDest(&m_region));
      }

   //! Sets the region to the intersection of two other regions
   void Intersect (
      const GEOREGION& lhs,
      const GEOREGION& rhs
      ) {
      MregionIntersect(&m_region,&lhs.m_region,&rhs.m_region);
      }

   //! Determine if region is "empty".
   bool IsEmpty (
      ) const {
      return (!m_region.Extents.IsValid());
      }

   //! Set 'destination' projection.
   void SetDestProjection (
      const MAPPROJPARM& proj
      ) {
      TransGenSetInputProj(&m_region.transparm,&proj);
      UpdateDest();
      return;
      }

   //! Set 'destination' transformation as affine.
   void SetDestTrans (
      const MAT3X3 fwd,
      const MAT3X3 inv
      ) {
      TransGenSetInputTransAffine(&m_region.transparm,fwd,inv);
      UpdateDest();
      return;
      }

   //! Set 'destination' transformation to identity (default).
   void SetDestTransIdentity (
      ) {
      TransGenSetInputTransIdentity(&m_region.transparm);
      return;
      }

   //! Set region to be specified rectangle.
   void SetRectangle (                 
      const DRECT2D& extents              //!< Rectangle in region 'source' coordinate.
      ) {
      Clear();
      m_region.Extents = extents;
      return;
      }

   //! Set region 'source' projection.
   void SetSourceProjection (
      const MAPPROJPARM& proj
      ) {
      MregionChangeProj(&m_region,&proj);
      return;
      }

   //! Set 'source' transformation as affine.
   void SetSourceTrans (
      const MAT3X3 fwd,                   //!< Source to SourceProj transformation
      const MAT3X3 inv                    //!< SourceProj to Source transformation
      ) {
      TransGenSetOutputTransAffine(&m_region.transparm,fwd,inv);
      return;
      }

   //! Set 'source' transformation to identity (default).
   void SetSourceTransIdentity (
      ) {
      TransGenSetOutputTransIdentity(&m_region.transparm);
      UpdateDest();
      return;
      }

   //! Set region's TRANSPARM.
   //! Note that the "input" side of the transparm corresponds to the region's 'destination'
   //! coordinates and the "output" side corresponds to the region's 'source' coordinates.
   void SetTransParm (
      const TRANSPARM& transparm
      ) {
      TransGenCopy(&m_region.transparm,&transparm);
      UpdateDest();
      return;
      }

   //! Set region's TRANSPARM.
   //! Note that the "input" side of the transparm corresponds to the region's 'destination'
   //! coordinates and the "output" side corresponds to the region's 'source' coordinates.
   void SetTransParm (
      const TRANS2D_MAPGEN& transgen
      ) {
      TransGenCopy(&m_region.transparm,&transgen.GetTransParm());
      return;
      }

   //! Sets the region to the result of lhs - rhs
   void Subtract (
      const GEOREGION& lhs,
      const GEOREGION& rhs
      ) {
      MregionSubtract(&m_region,&lhs.m_region,&rhs.m_region);
      }

   //! Test line against region.
   bool TestLine (                     
      const DPOLYLINE& line,              //!< Line in region 'destination' coordinates
      TESTMODE testmode
      ) const {
      return (MregionTestLine(&line,&m_region,testmode) > 0);
      }

   //! Test point against region.
   bool TestPoint (                    
      const DPOINT2D& point,              //!< Point in region 'destination' coordinates
      TESTMODE testmode
      ) const {
      return (MregionTestPoint(&point,&m_region,testmode) > 0);
      }

   //! Test polygon against region.
   bool TestPolygon (                  
      const DPOLYGON& polygon,            //!< Polygon in region 'destination' coordinates
      TESTMODE testmode
      ) const {
      return (MregionTestPolygon(&polygon,&m_region,testmode) > 0);
      }

   //! Sets the region to the union of two other regions
   void Union (
      const GEOREGION& lhs,
      const GEOREGION& rhs
      ) {
      MregionUnion(&m_region,&lhs.m_region,&rhs.m_region);
      }

   //! Update destination region if exists.
   void UpdateDest (
      ) {
      if (m_region.DestRegionList != 0) MregionGenerateDest(&m_region);
      return;
      }

private:
   #ifndef GENERATING_DOXYGEN_OUTPUT

   // MEMBERS

   DREGION m_region;

   // FRIENDS
   friend GEOREGION operator& (const GEOREGION& lhs, const GEOREGION& rhs);
   friend GEOREGION operator| (const GEOREGION& lhs, const GEOREGION& rhs);
   friend GEOREGION operator- (const GEOREGION& lhs, const GEOREGION& rhs);
   friend GEOREGION operator^ (const GEOREGION& lhs, const GEOREGION& rhs);
   #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! Intersection.
inline GEOREGION operator& (           
   const GEOREGION& lhs,
   const GEOREGION& rhs
   ) {
   GEOREGION result;
   result.Intersect(lhs, rhs);
   return (result);
   }

//! Union.
inline GEOREGION operator| (           
   const GEOREGION& lhs,
   const GEOREGION& rhs
   ) {
   GEOREGION result;
   result.Union(lhs, rhs);
   return (result);
   }

//! Sum (same as union).
inline GEOREGION operator+ (           
   const GEOREGION& lhs,
   const GEOREGION& rhs
   ) {
   return (lhs | rhs);
   }

//! Subtract one region from another.
inline GEOREGION operator- (           
   const GEOREGION& lhs,
   const GEOREGION& rhs
   ) {
   GEOREGION result;
   result.Subtract(lhs, rhs);
   return (result);
   }

//! Exclusive-or.
inline GEOREGION operator^ (           
   const GEOREGION& lhs,
   const GEOREGION& rhs
   ) {
   GEOREGION result;
   MregionExclusiveOr(&result.m_region,&lhs.m_region,&rhs.m_region);
   return (result);
   }


#endif   //!<  INC_MI32_REGION_H 

---