mi32/region2d.h

Go to the documentation of this file.

#ifndef  INC_MI32_REGION2D_H
#define  INC_MI32_REGION2D_H

#ifndef  INC_MI32_POLYLINE_H
   #include <mi32/polyline.h>
#endif

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


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

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class TRANS2D_AFFINE;
class TRANS2D_MAPGEN;
class REGION2D;
class SERIALIZER;
class BINARYTOREGION2D;
namespace RVC {
   class CAD;
   class VECTOR;
   class REGION;
   class REGIONHANDLE;
   }
#endif


class GEOMLIBCLASSEXPORT SUBREGION2D {
   public:
   
      typedef POLYLINELIST::CONST_ITERATOR CONST_ITERATOR;

      class GEOMLIBCLASSEXPORT COPYFILTER {
         public:
            COPYFILTER ();
            virtual ~COPYFILTER () = 0;
            bool IsIslandIncluded (
               const POLYLINE& island
               ) { return (v_IsIslandIncluded(island)); }
         private:
            virtual bool v_IsIslandIncluded (
               const POLYLINE& island
               );
         };
   
      SUBREGION2D ();
         
      SUBREGION2D (
         const SUBREGION2D& rhs
         );
         
      SUBREGION2D (
         const DRECT2D& rect
         );
         
      ~SUBREGION2D ();
         
      SUBREGION2D& operator= (
         const SUBREGION2D& rhs
         );

      SUBREGION2D& operator= (
         const DRECT2D& rhs
         );

      SUBREGION2D& operator= (
         const DRECT3D& rhs
         );

      ERRVALUE Assign (
         const POLYLINE& Polygon
         );

      ERRVALUE AssignFromXML (
         const XMLNODE *topnode
         );

      void AssignValidated (
         const POLYLINE& Polygon
         );
         
      void AssignValidated (
         const POLYLINELIST& PolygonList
         );
         
      CONST_ITERATOR Begin (
         ) const { return (m_ItemList.Begin()); }

      void Clear ();
         
      int ClipLine (
         POLYLINE& PolyLine,
         POLYLINE::CLIP& ClipTarget,
         CLIPMODE ClipMode = CLIPMODE_Inside
         ) const;
         
      double ComputeArea () const;
   
      double ComputeAreaNoIslands () const;

      double ComputeCentroid (
         DPOINT3D& centroid               
         ) const;
   
      double ComputePerimeter () const;
   
      double ComputePerimeterNoIslands () const;
   
      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
   
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertForward (
         const SPATREF::COORDOP& Op
         );
   
      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertForwardDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );

      void ConvertInverse (
         const TRANS2D_AFFINE& taf
         );
   
      ERRVALUE ConvertInverse (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertInverseDense (
         const TRANS2D_MAPGEN& tmg
         );
         
      ERRVALUE ConvertReverse (
         const SPATREF::COORDOP& Op
         );
   
      ERRVALUE ConvertReverseDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );
   
      ERRVALUE ConvertToLongFloor (
         SIMPLE_ARRAY<LPOLYGON>& PolygonArray,     
         SIMPLE_ARRAY<LPOINT2D>& PointArray        
         ) const;

      ERRVALUE ConvertToLongFloor (
         SIMPLE_ARRAY<LPOLYGON>& PolygonArray,     
         SIMPLE_ARRAY<LPOINT2D>& PointArray,       
         const DPOINT2D& scale,                    
         const DPOINT2D& offset                    
         ) const;

      ERRVALUE ConvertToLongNearInt (
         SIMPLE_ARRAY<LPOLYGON>& PolygonArray,
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;

      ERRVALUE ConvertToLongRound (
         SIMPLE_ARRAY<LPOLYGON>& PolygonArray,
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;
   
      ERRVALUE CopyTo (
         SUBREGION2D& target,                      
         COPYFILTER& filter                        
         ) const;
   
      void DumpCoords (
         MISTRING& result,                   
         int indent,                         
         bool maxprec = false                
         ) const;

      CONST_ITERATOR End () const
         { return (m_ItemList.End()); }

      int FitRectangleInside (
         const DPOINT2D& size,               
         DPOINT2D& ptCenterRet,              
         UINT32 QuantFactor = 10,            
         bool bUseFirstFound = false         
         ) const;

      ERRVALUE GeneratePointInside (
         DPOINT2D& PointInside
         ) const;
         
      ERRVALUE GenerateRandomPointInside (
         DPOINT2D& PointInside
         ) const;

      const DRECT3D& GetExtents () const
         { return (m_Extents); }
   
      const DRECT2D& GetExtents2D () const
         { return (m_Extents); }
   
      INT32 GetNumIslands () const
         { return (IsEmpty() ? 0 : m_ItemList.GetNumItems()-1); }
   
      XMLNODE* GetXML (
         XMLNODE *parentnode,                
         const char *nodename = "SubRegion"  
         ) const;
         
      ERRVALUE Intersect (
         const DRECT2D& Rect,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE Intersect (
         const POLYLINE& PolyLine,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE Intersect (
         const SUBREGION2D& SubRegion,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE IntersectValidated (
         const POLYLINE& PolyLine,
         MILIST<SUBREGION2D>& SubRegionList        
         );
         
      bool IsEquivalentTo (
         const SUBREGION2D& rhs,
         double threshold = 0.0        
         ) const;
   
      bool IsPointInside (
         const DPOINT2D& point
         ) const;
   
      bool IsEmpty (
         ) const { return (!m_Extents.IsValid()); }

      bool IsRectangle (
         ) const { return (m_IsRectangle); }

      void RemoveIslands ();
         
      void Reverse ();

      void SetDimension (
         DIMENSION dim
         );

      void SetOrientation (
         ORIENTATION Orientation
         );
         
      ERRVALUE Subtract (
         const POLYLINE& Island,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE Subtract (
         const SUBREGION2D& SubRegion,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE Subtract (
         const DRECT2D& IslandRect,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE SubtractValidated (
         const POLYLINE& Island,
         MILIST<SUBREGION2D>& SubRegionList        
         );
         
      ERRVALUE SubtractValidated (
         const POLYLINE& Island,
         MILIST<SUBREGION2D>& SubRegionList,       
         double ConflateThreshold
         );
         
      bool TestLine (
         const POLYLINE& PolyLine,
         TESTCRITERIA TestCriteria
         ) const;

      POLYLINE::COMPRESULT TestLine (
         const POLYLINE& PolyLine
         ) const;

      bool TestPoint (
         const DPOINT2D& Point,
         TESTCRITERIA TestCriteria
         ) const;

      bool TestPolygon (
         const POLYLINE& PolyLine,
         TESTCRITERIA TestCriteria
         ) const;

      POLYLINE::COMPRESULT TestPolygon (
         const POLYLINE& PolyLine
         ) const;

      bool TestSubRegion (
         const SUBREGION2D& SubRegion,
         TESTCRITERIA TestCriteria
         ) const;

      POLYLINE::COMPRESULT TestSubRegion (
         const SUBREGION2D& SubRegion
         ) const;

      ERRVALUE Union (
         const DRECT2D& Rect,
         MILIST<SUBREGION2D>& SubRegionList,       
         POLYLINE::COMBINERESULT& CombineResult
         );

      ERRVALUE Union (
         const POLYLINE& PolyLine,
         MILIST<SUBREGION2D>& SubRegionList        
         );

      ERRVALUE Union (
         const SUBREGION2D& SubRegion,
         MILIST<SUBREGION2D>& SubRegionList,       
         POLYLINE::COMBINERESULT& CombineResult
         );

      ERRVALUE UnionValidated (
         const POLYLINE& PolyLine,
         MILIST<SUBREGION2D>& SubRegionList,       
         POLYLINE::COMBINERESULT& CombineResult
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
   
      POLYLINELIST m_ItemList;
      DRECT3D m_Extents;
      bool m_IsRectangle;
      
      ERRVALUE ComputeBuffer (const double Distance, REGION2D& Buffer) const;
      void UpdateExtentsRect ();
      ERRVALUE UpdateFromShells (POLYLINELIST& PolyLineList, MILIST<SUBREGION2D>& SubRegionList);
   
      friend class RVC::VECTOR;        
      friend class RVC::REGION;        
      friend class REGION2D;           
      friend class RVC::REGIONHANDLE;
      friend class BINARYTOREGION2D;
      friend class SERIALIZER;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

typedef MILIST<SUBREGION2D> SUBREGIONLIST;
         

class GEOMLIBCLASSEXPORT REGION2D {
   public:

      typedef SUBREGIONLIST::CONST_ITERATOR CONST_ITERATOR;
      
      class GEOMLIBCLASSEXPORT COPYFILTER : public SUBREGION2D::COPYFILTER {
         public:
            COPYFILTER ();
            virtual ~COPYFILTER () = 0;
            bool IsLineIncluded (
               const POLYLINE& line
               ) { return (v_IsLineIncluded(line)); }
            bool IsPointIncluded (
               const DPOINT2D& point
               ) { return (v_IsPointIncluded(point)); }
            bool IsSubRegionIncluded (
               const SUBREGION2D& subregion
               ) { return (v_IsSubRegionIncluded(subregion)); }
         private:
            virtual bool v_IsLineIncluded (
               const POLYLINE& line
               );
            virtual bool v_IsPointIncluded (
               const DPOINT2D& point
               );
            virtual bool v_IsSubRegionIncluded (
               const SUBREGION2D& subregion
               );
         };
   
      REGION2D (
         );
   
      REGION2D (
         const REGION2D& rhs
         );
   
      REGION2D (
         const DRECT2D& rhs
         );

      REGION2D (
         const SUBREGION2D& SubRegion
         );
   
      REGION2D (
         const POLYLINELIST&
         );
   
      ~REGION2D (
         );
         
      REGION2D& operator= (
         const REGION2D& rhs
         );
         
      REGION2D& operator= (
         const DRECT2D& rhs
         );

      REGION2D& operator= (
         const DRECT3D& rhs
         );

      REGION2D& operator= (
         const SUBREGION2D& SubRegion
         );
         
      void AddLine (
         const POLYLINE& PolyLine
         );
   
      void AddLines (
         const POLYLINELIST& LineList
         );
   
      void AddPoint (
         const DPOINT3D& Point
         );

      void AddPoints (
         const POLYLINE& points
         );
   
      void AddSubRegion (
         const SUBREGION2D& SubRegion
         );
   
      ERRVALUE Assign (
         const POLYLINE& PolyLine,
         const SIMPLE_ARRAY<INT32>& Index       
         );
         
      ERRVALUE AssignFromXML (
         const XMLNODE *topnode
         );

      CONST_ITERATOR Begin (
         ) const { return (m_SubList.Begin()); }

      void Clear (
         );
         
      void ClearCoordRefSys (
         );
         
      int ClipLine (
         POLYLINE& PolyLine,
         POLYLINE::CLIP& ClipTarget,
         CLIPMODE ClipMode = CLIPMODE_Inside
         ) const;
         
      double ComputeArea (
         ) const;
   
      double ComputeAreaNoIslands (
         ) const;
   
      void ComputeCentroid (
         DPOINT3D& centroid               
         ) const;
   
      ERRVALUE ComputeExpansion (
         const double Distance,              // Expansion (Shrinkage if negative) distance
         REGION2D& Expansion                 // Expansion returned
         ) const;

      double ComputePerimeter (
         ) const;
   
      ERRVALUE ComputePerimeter (
         double& result,
         SPATREF::COORDREFSYS::MEASUREMETHOD method,
         UOM::IDNUM LengthUnitIdNum = UOM::IDNUM_Length_Meter
         ) const;
   
      double ComputePerimeterNoIslands (
         ) const;
   
      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
   
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertForward (
         const SPATREF::COORDOP& Op
         );
   
      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertForwardDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );
   
      void ConvertInverse (
         const TRANS2D_AFFINE& taf
         );
   
      ERRVALUE ConvertInverse (
         const TRANS2D_MAPGEN& tmg
         );
   
      ERRVALUE ConvertInverseDense (
         const TRANS2D_MAPGEN& tmg
         );
         
      ERRVALUE ConvertReverse (
         const SPATREF::COORDOP& Op
         );
   
      ERRVALUE ConvertReverseDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );

      ERRVALUE ConvertTo (
         const SPATREF::COORDREFSYS& DestCoordRefSys,
         double tolerance = 0.0
         );
   
      ERRVALUE CopyTo (
         REGION2D& target,                         
         COPYFILTER& filter                        
         ) const;
   
      void DumpCoords (
         MISTRING& result,                   
         int indent,                         
         bool maxprec = false                
         ) const;

      CONST_ITERATOR End (
         ) const { return (m_SubList.End()); }

      ERRVALUE ExclusiveUnion (
         const REGION2D& RegionB
         );
         
      ERRVALUE ExclusiveUnion (
         const REGION2D& RegionA,
         const REGION2D& RegionB
         );
         
      ERRVALUE Expand (
         const double Distance               // Expansion (Shrinkage if negative) distance
         );

      const SPATREF::COORDREFSYS& GetCoordRefSys (
         ) const { return (m_CoordRefSys); }
         
      const DRECT3D& GetExtents (
         ) const { return (m_Extents); }
   
      const DRECT2D& GetExtents2D (
         ) const { return (m_Extents); }
   
      const POLYLINELIST& GetLineList (
         ) const { return (m_LineList); }
      
      INT32 GetNumLines (
         ) const { return (m_LineList.GetNumItems()); }

      INT32 GetNumPoints (
         ) const { return (m_PointList.GetNumPoints()); }

      INT32 GetNumSubRegions (
         ) const { return (m_SubList.GetNumItems()); }

      const POLYLINE& GetPointList (
         ) const { return (m_PointList); }
         
      const SUBREGIONLIST& GetSubRegionList (
         ) const { return (m_SubList); }
    
      XMLNODE* GetXML (
         XMLNODE *parentnode,                
         const char *nodename = "Region"     
         ) const;
         
      bool HasPoints (
         ) const { return (m_PointList.GetNumPoints() > 0); }
         
      bool HasLines (
         ) const { return (!m_LineList.IsEmpty()); }
         
      bool HasSubRegions (
         ) const { return (!m_SubList.IsEmpty()); }
         
      ERRVALUE Intersect (
         const DRECT2D& Rect
         );
         
      ERRVALUE Intersect (
         const POLYLINE& PolyLine
         );
         
      ERRVALUE Intersect (
         const SUBREGION2D& SubRegion
         );
         
      ERRVALUE Intersect (
         const REGION2D& RegionB
         );
         
      ERRVALUE Intersect (
         const REGION2D& RegionA,
         const REGION2D& RegionB
         );
         
      ERRVALUE IntersectValidated (
         const POLYLINE& PolyLine
         );
         
      bool IsEmpty (
         ) const { return (!m_Extents.IsValid()); }

      bool IsEquivalentTo (
         const REGION2D& rhs,
         double threshold = 0.0        
         ) const;
   
      bool IsPointInside (
         const DPOINT2D& point
         ) const;
         
      bool IsRectangle (
         ) const { return (m_IsRectangle); }

      ERRVALUE NormalizeToCRS (
         );
         
      void RemoveIslands ();
         
      void Reverse ();

      void SetCoordRefSys (
         const SPATREF::COORDREFSYS& CoordSysRef
         ) { m_CoordRefSys = CoordSysRef; }

      void SetDimension (
         DIMENSION dim
         );

      void SetOrientation (
         ORIENTATION Orientation
         );
         
      void SetZRange (
         const DOUBLE_RANGE& range
         );
         
      ERRVALUE Subtract (
         const DRECT2D& Rect
         );
         
      ERRVALUE Subtract (
         const POLYLINE& PolyLine
         );
         
      ERRVALUE Subtract (
         const SUBREGION2D& SubRegion
         );
         
      ERRVALUE Subtract (
         const REGION2D& RegionB
         );
         
      ERRVALUE Subtract (
         const REGION2D& RegionA,
         const REGION2D& RegionB
         );
         
      ERRVALUE SubtractValidated (
         const POLYLINE& PolyLine
         );
         
      bool TestLine (
         const POLYLINE& PolyLine,
         TESTCRITERIA TestCriteria
         ) const;

      bool TestPoint (
         const DPOINT2D& Point,
         TESTCRITERIA TestCriteria
         ) const;

      bool TestPolygon (
         const POLYLINE& PolyLine,
         TESTCRITERIA TestCriteria
         ) const;

      bool TestSubRegion (
         const SUBREGION2D& SubRegion,
         TESTCRITERIA TestCriteria
         ) const;

      bool TestRegion (
         const REGION2D& Region,
         TESTCRITERIA TestCriteria
         ) const;

      ERRVALUE Union (
         const DRECT2D& Rect
         );
         
      ERRVALUE Union (
         const POLYLINE& PolyLine
         );
         
      ERRVALUE Union (
         const SUBREGION2D& SubRegion
         );
         
      ERRVALUE Union (
         const REGION2D& RegionA,
         const REGION2D& RegionB
         );
         
      ERRVALUE Union (
         const REGION2D& RegionB
         );
         
      ERRVALUE UnionValidated (
         const POLYLINE& PolyLine
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
   
      SUBREGIONLIST m_SubList;
      POLYLINELIST m_LineList;
      POLYLINE m_PointList;
      DRECT3D m_Extents;
      SPATREF::COORDREFSYS m_CoordRefSys;
      bool m_IsRectangle;
      
      void AppendDisjointRegion (const REGION2D& rhs);
      ERRVALUE ComputeBuffer (const double Distance, REGION2D& Buffer) const;
      bool UnionRectangle (const DRECT2D& Rect);
      void UpdateExtentsRect ();
   
      class INTERSECTREGION;
      friend class INTERSECTREGION;
      friend class RVC::VECTOR;           
      friend class RVC::REGION;           
      friend class RVC::CAD;              
      friend class RVC::REGIONHANDLE;
      friend class BINARYTOREGION2D;
      friend class SERIALIZER;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#undef GEOMLIBCLASSEXPORT

#endif      // INC_MI32_REGION2D_H

---