mi32/polyline.h

Go to the documentation of this file.

#ifndef INC_MI32_POLYLINE_H
#define INC_MI32_POLYLINE_H

#ifndef  INC_MI32_DOUBLEAR_H
   #include <mi32/doublear.h>
#endif

#ifndef  INC_MI32_SIMPLEAR_H
   #include <mi32/simplear.h>
#endif

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

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

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

#ifndef  INC_MI32_DELEGATE_H
   #include <mi32/delegate.h>
#endif


#ifdef GEOMDLL
   #define GEOMLIBEXPORT MI_DLLEXPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSEXPORT
#else
   #define GEOMLIBEXPORT MI_DLLIMPORT
   #define GEOMLIBCLASSEXPORT MI_DLLCLASSIMPORT
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class BITSET_UNOWNED;
class MISTRING;
class POLYLINELIST;
class TRANS2D_AFFINE;
class TRANS2D_MAPGEN;
class TRANS3D;
class XMLNODE;
namespace SPATREF {
   class COORDOP;
   }
#endif


struct DTRIANGLE2D {
   DPOINT2D p1;
   DPOINT2D p2;
   DPOINT2D p3;
   };

enum CLIPMODE {
   CLIPMODE_Inside =    0, 
   CLIPMODE_Outside =   1  
   };

enum TESTCRITERIA {
   TESTCRITERIA_FullOutside = 0,  
   TESTCRITERIA_PartOutside = 1,  
   TESTCRITERIA_FullInside = 2,  
   TESTCRITERIA_PartInside = 3      
   };


//--------------------------------------------------------------------------------------------------------------------
//--------------------------------------------------------------------------------------------------------------------

class GEOMLIBCLASSEXPORT POLYLINE {
   public:

      enum BUFFERSIDE {
         BUFFERSIDE_In =   1,
         BUFFERSIDE_Out =  2,
         BUFFERSIDE_Both = 3
         };

      enum COMPRESULT {
         COMPRESULT_Outside = 1,       
         COMPRESULT_Inside,            
         COMPRESULT_Intersect,         
         COMPRESULT_Overlap            
         };

      enum COMBINERESULT {
         COMBINERESULT_Disjoint =      1, 
         COMBINERESULT_OperInsideSrc = 2, 
         COMBINERESULT_SrcInsideOper = 3, 
         COMBINERESULT_Equal =         4, 
         COMBINERESULT_Intersect =     5, 
         // Legacy names
         COMBINERESULT_ClipOutside =   COMBINERESULT_Disjoint,
         COMBINERESULT_ClipInside =    COMBINERESULT_OperInsideSrc,
         COMBINERESULT_SrcInside =     COMBINERESULT_SrcInsideOper
         };

      enum EXTRACT {
         EXTRACT_StartPoint = 1,
         EXTRACT_CenterPoint,
         EXTRACT_EndPoint
         };
         
      enum JOINTYPE {
         JOINTYPE_Miter = 0,
         JOINTYPE_Round,
         JOINTYPE_Bevel
         };
         
      enum SPLINEFLAGS {
         SPLINEFLAG_None =             0x0000,
         SPLINEFLAG_DontMoveEnds =     0x0001,
         SPLINEFLAG_UseMinDistance =   0x0002,
         SPLINEFLAG_TreatAsClosed =    0x0004
         };
         
      enum SPLINE {
         SPLINE_NoSpline = 0,
         SPLINE_Cubic,
         SPLINE_Quadratic,
         SPLINE_Bezier
         };
         
      enum THINMETHOD {
         THINMETHOD_MinRatio = 1,
         THINMETHOD_Minimum,
         THINMETHOD_Douglas
         };

      class ITERATOR;

      class CONST_ITERATOR {
         public:

            CONST_ITERATOR (
               ) :
               m_Index(0),
               m_PolyLine(0)
               { }

            CONST_ITERATOR (
               INT32 index,
               const POLYLINE*const PolyLine
               ) : 
               m_Index(index),
               m_PolyLine(PolyLine)
               { }

            CONST_ITERATOR (
               const CONST_ITERATOR& rhs
               ) : 
               m_Index(rhs.m_Index),
               m_PolyLine(rhs.m_PolyLine)
               { }

            CONST_ITERATOR (
               const ITERATOR& rhs
               ) : 
               m_Index(rhs.m_Index),
               m_PolyLine(rhs.m_PolyLine)
               { }

            CONST_ITERATOR& operator= (
               const CONST_ITERATOR& rhs
               ) {
               if (this != &rhs) {
                  m_Index = rhs.m_Index;
                  m_PolyLine = rhs.m_PolyLine;
                  }
               return (*this);
               }
               
            const DPOINT2D& operator* (
               ) const { return (m_PolyLine->GetVertex(m_Index)); }

            const DPOINT2D* operator-> (
               ) const { return (&**this); }

            CONST_ITERATOR& operator++ (
               ) {
               ++m_Index;
               return (*this);
               }

            CONST_ITERATOR operator++(int
               ) {
               CONST_ITERATOR temp = *this;
               ++*this;
               return (temp);
               }

            CONST_ITERATOR& operator-- (
               ) {
               --m_Index;
               return (*this);
               }

            CONST_ITERATOR operator--(int
               ) {
               CONST_ITERATOR temp = *this;
               --*this;
               return (temp);
               }

            bool operator== (
               const CONST_ITERATOR& rhs
               ) const { return (m_Index == rhs.m_Index && m_PolyLine == rhs.m_PolyLine); }

            bool operator!= (
               const CONST_ITERATOR& rhs
               ) const { return (!(*this == rhs)); }

            INT32 GetIndex (
               ) const { return (m_Index); }

         protected:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            INT32 m_Index;
            const POLYLINE* m_PolyLine;
            #endif
         };

      class ITERATOR {
         public:

            ITERATOR (
               ) :
               m_Index(0),
               m_PolyLine(0)
               { }

            ITERATOR (
               INT32 index,
               POLYLINE* PolyLine
               ) : 
               m_Index(index),
               m_PolyLine(PolyLine)
               { }

            ITERATOR (
               const ITERATOR& rhs
               ) : 
               m_Index(rhs.m_Index),
               m_PolyLine(rhs.m_PolyLine)
               { }

            ITERATOR& operator= (
               const ITERATOR& rhs
               ) {
               if (this != &rhs) {
                  m_Index = rhs.m_Index;
                  m_PolyLine = rhs.m_PolyLine;
                  }
               return (*this);
               }
               
            DPOINT2D& operator* (
               ) const { return (m_PolyLine->GetVertexRef(m_Index)); }

            DPOINT2D* operator-> (
               ) const { return (&**this); }

            ITERATOR& operator++ (
               ) {
               m_Index ++;
               return (*this);
               }

            ITERATOR operator++(int
               ) {
               ITERATOR temp = *this;
               ++*this;
               return (temp);
               }

            ITERATOR& operator-- (
               ) {
               m_Index --;
               return (*this);
               }

            ITERATOR operator--(int
               ) {
               ITERATOR temp = *this;
               --*this;
               return (temp);
               }

            bool operator== (
               const ITERATOR& rhs
               ) const { return (m_Index == rhs.m_Index && m_PolyLine == rhs.m_PolyLine); }

            bool operator!= (
               const ITERATOR& rhs
               ) const { return (!(*this == rhs)); }

         protected:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            INT32 m_Index;
            POLYLINE *m_PolyLine;
            friend class CONST_ITERATOR;
            #endif
         };

      class SECTION {
         public:
            SECTION (
               const DRECT2D& Extents,
               INT32 StartVertex,
               INT32 EndVertex
               ) : 
               m_Extents(Extents),
               m_VertexRange(StartVertex, EndVertex)
               { }
               
            ~SECTION (
               ) { }
               
            const DRECT2D& GetExtents (
               ) const { return (m_Extents); }
               
            const INT32_RANGE& GetVertexRange (
               ) const { return (m_VertexRange); }
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DRECT2D m_Extents;
            INT32_RANGE m_VertexRange;

            friend class POLYLINE;
            #endif
         };
      typedef DOUBLE_ARRAY<SECTION> SECTIONARRAY;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CLIP;
      class INTERSECTINFO;
      class SECTIONS;
      class SPLIT;
      class STRIPS;
      #endif
      
      POLYLINE ();

      explicit POLYLINE (
         bool closed,                        
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0,                
         UINT32 ReservePoints = 1            
         );

      explicit POLYLINE (
         const DRECT2D& rect,                
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         const DRECT3D& rect                 
         );
         
      explicit POLYLINE (
         const DPOLYGON& dpoly,              
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );
         
      POLYLINE (
         const DPOINT2D* pts,
         INT32 NumPoints,
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         DOUBLE_ARRAY<double>& rhs,
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         const DOUBLE_ARRAY<DPOINT2D>& rhs,
         bool closed = false,                
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         const SIMPLE_ARRAY<LPOINT2D>& rhs,
         bool closed = false,                
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         const LPOINT2D* points,
         INT32 NumPoints,
         bool closed = false,                
         double ZValue = 0.0                 
         );
         
      explicit POLYLINE (
         const DOUBLE_ARRAY<DPOINT3D>& rhs,
         bool closed = false                 
         );
         
      POLYLINE (
         const POLYLINE& rhs
         );

      POLYLINE (
         const POLYLINE& rhs,                
         INT32 StartVertex,                  
         INT32 EndVertex                     
         );
      
      ~POLYLINE (
         );

      POLYLINE& operator= (
         const POLYLINE& rhs
         );

      POLYLINE& operator+= (
         const POLYLINE& rhs
         );

      ERRVALUE AddVertex (
         const DPOINT2D& point,              
         INT32 index = -1                    
         );

      ERRVALUE AddVertex (
         const DPOINT3D& point,              
         INT32 index = -1                    
         );
         
      ERRVALUE Append (
         const POLYLINE& rhs,
         bool RemovePoints = true
         );
         
      // Apply a z scale factor to each of the z coordinate values if 'this' has them, otherwise apply it to the z value stored
      void ApplyZScale (
         double zscale                       
         );
         
      ERRVALUE Assign (
         const DPOLYGON& dpoly,
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );

      ERRVALUE Assign (
         const DPOINT2D* pts,
         INT32 NumPoints,
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );
               
      ERRVALUE Assign (
         const SIMPLE_ARRAY<LPOINT2D>& rhs,
         bool closed = false,                
         double ZValue = 0.0                 
         );

      ERRVALUE Assign (
         const LPOINT2D* rhs,
         int NumPoints,
         bool closed = false,                
         double ZValue = 0.0                 
         );
               
      ERRVALUE Assign (
         const DOUBLE_ARRAY<DPOINT2D>& rhs,
         bool closed = false,                
         double ZValue = 0.0                 
         );
               
      ERRVALUE Assign (
         const DOUBLE_ARRAY<DPOINT3D>& rhs,
         bool closed = false                 
         );
         
      ERRVALUE Assign (
         const DRECT2D& rect,                
         double ZValue = 0.0                 
         );
         
      ERRVALUE Assign (
         const DRECT3D& rect                 
         );
         
      ERRVALUE AssignFromXML (
         const XMLNODE *topnode
         );

      void Attach (
         MIDOUBLEARRAY& rhs,
         INT32 NumPoints,
         bool closed = false,                
         DIMENSION dimension = DIMENSION_2D, 
         double ZValue = 0.0                 
         );

      CONST_ITERATOR Begin (       
         ) const { return (CONST_ITERATOR(0, this)); }

      ITERATOR Begin (              
         ) { return (ITERATOR(0, this)); }

      void Clear (
         );

      void ClearOptimizations (
         );

      void ClearPoints (
         INT32 StartPosn = 0,
         INT32 EndPosn = INT32_MAX           
         );
         
      int Clip (
         const DRECT2D& ClipRect,                        
         DELEGATE_ERRVALUE_POLYLINE DelegateOnClip,      
         CLIPMODE ClipMode = CLIPMODE_Inside
         );

      int Clip (
         const DRECT2D& ClipRect,                        
         CLIP& ClipTarget,
         CLIPMODE ClipMode = CLIPMODE_Inside             
         );

      COMPRESULT CompareLineToLine (
         const POLYLINE& OtherLine
         ) const;

      COMPRESULT CompareLineToPolygon (
         const POLYLINE& Polygon
         ) const;

      COMPRESULT CompareLineToPolygon (
         const DRECT2D& rect
         ) const;

      COMPRESULT ComparePolygonToPolygon (
         const POLYLINE& OtherPoly
         ) const;

      double ComputeAngle (
         ) const;

      double ComputeArea (
         ) const {
         double area;
         ComputeStats(&area, 0);
         return (area);
         }
         
      ERRVALUE ComputeBuffer (
         const double BufferDistance,        
         POLYLINELIST& BufferLineList,
         const BUFFERSIDE BufferSide = BUFFERSIDE_Both
         ) const;

      void ComputeCentroid (
         DPOINT2D& cent
         ) const;
         
      void ComputeCentroid (
         DPOINT3D& cent
         ) const;
         
      double ComputeDistance (
         const POLYLINE& OtherLine,
         bool ExtentsOverlap = true       
         ) const;

      bool ComputeDistPointOnLine (
         double Distance,
         DPOINT3D& NewPoint,              
         bool DistanceFromStart = true
         ) const;
         
      INT32 ComputeDistPointAndVertexOnLine (
         double Distance,
         DPOINT3D& NewPoint,              
         bool DistanceFromStart = true
         ) const;
         
      void ComputeExtents (
         DRECT3D& rect
         ) const;
      
      void ComputeExtents (
         DRECT3D& rect,
         INT32 StartVertex,
         INT32 EndVertex            
         ) const;
         
      void ComputeExtents (
         DRECT2D& rect
         ) const;
      
      void ComputeExtents (
         DRECT2D& rect,
         INT32 StartVertex,
         INT32 EndVertex            
         ) const;

      void ComputeInteriorPoint (
         DPOINT3D& pt               
         ) const;
      
      double ComputeLength (
         ) const;
         
      double ComputeLength (
         const DPOINT3D& point            
         ) const;
         
      double ComputeLongestSegmentLength (
         ) const;

      double ComputeMaxDimension (
         ) const;
         
      void ComputeMidPoint (
         DPOINT3D& MidPoint               
         ) const;

      ERRVALUE ComputeOffset (
         double OffsetDistance,
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      ERRVALUE ComputeOffset (
         double StartOffsetDistance,
         double EndOffsetDistance,
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      ERRVALUE ComputeOffset (
         const SIMPLE_ARRAY<double>& OffsetDistance,        
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      ORIENTATION ComputeOrientation (
         ) const { return (ComputeStats(0, 0)); }
         
      INT32 ComputePercentPointOnLine (
         double Percent,                  
         DPOINT3D& NewPoint,              
         bool DistanceFromStart = true
         ) const;
         
      ORIENTATION ComputeStats (
         double *const area,                 
         DPOINT2D *const centroid            
         ) const;
         
      ERRVALUE Conflate (
         double thresh,
         bool& LineChanged
         );
      
      ERRVALUE Conflate (
         POLYLINELIST& LineList,
         double thresh,
         bool& LineChanged,
         BITSET_UNOWNED& LineListSet         
         );
      
      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
      
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );

      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );

      void ConvertForward (
         const TRANS3D& t3d
         );
      
      ERRVALUE ConvertForward (
         const SPATREF::COORDOP& Op
         );

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

      void ConvertInverse (
         const TRANS3D& t3d
         );
      
      ERRVALUE ConvertReverse (
         const SPATREF::COORDOP& Op
         );

      ERRVALUE ConvertReverseDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );

      ERRVALUE ConvertToLong (
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;

      INT32 ConvertToLong (
         LPOINT2D *PointArray
         ) const;

      ERRVALUE ConvertToLongFloor (
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;

      INT32 ConvertToLongFloor (
         LPOINT2D *PointArray
         ) const;

      INT32 ConvertToLongFloor (
         LPOINT2D *PointArray,         
         const DPOINT2D& scale,        
         const DPOINT2D& offset        
         ) const;

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

      INT32 ConvertToLongNearInt (
         LPOINT2D *PointArray
         ) const;

      ERRVALUE ConvertToLongRound (
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;

      INT32 ConvertToLongRound (
         LPOINT2D *PointArray
         ) const;

      ERRVALUE ConvertToLongRoundKeepDups (
         SIMPLE_ARRAY<LPOINT2D>& PointArray
         ) const;

      void DeleteVertex (                 
         int index                        
         );
         
      void Detach (
         MIDOUBLEARRAY& rhs
         );

      void DetachBuffer (
         MIDOUBLEARRAY& rhs
         );

      void DumpCoords (
         MISTRING& result,                   
         int indent,                         
         bool maxprec = false                
         ) const;

      ITERATOR End (                
         ) { return (ITERATOR(m_NumPoints, this)); }

      CONST_ITERATOR End (          
         ) const { return (CONST_ITERATOR(m_NumPoints, this)); }

      void Exchange (
         POLYLINE& other                     
         );

      ERRVALUE ExclusiveUnion (
         POLYLINE& OperPoly,
         POLYLINELIST& PolyLineList,         
         COMBINERESULT& CombineResult
         );
         
      void Extract (
         POLYLINE& NewLine,                  
         const DPOINT3D& BasePoint,          
         double Distance,
         EXTRACT ExtractPoint,
         bool ExtrudePastEnds = false
         ) const;
         
      void Extract (
         POLYLINE& NewLine,                  
         const DPOINT3D& StartPoint,         
         const DPOINT3D& EndPoint            
         ) const;
         
      void Extract (
         INT32 StartPosn,
         INT32 NumPoints,
         POLYLINE& ExtractLine
         ) const;
      
      double FindClosestPoint (
         const DPOINT2D& point,              
         DPOINT2D& retpt                     
         ) const;
      
      double FindClosestPoint (
         const DPOINT3D& point,              
         DPOINT3D& retpt                     
         ) const;

      double FindClosestPoint (
         const DPOINT3D& point,              
         double MaximumDistance,             
         DPOINT3D& retpt,                    
         INT32& Vertex                       
         ) const;

      int FindClosestSegment (
         const DPOINT2D& point,              
         double *distance = 0                
         ) const;
         
      double FindClosestVertex (
         const DPOINT2D& point,              
         INT32& index                        
         ) const;
      
      int FindClosestVertex (
         const DPOINT2D& point,              
         double *distance = 0                
         ) const;
      
      double FindClosestVertex (
         const DPOINT3D& point,              
         INT32& index                        
         ) const;

      void GenerateExtentOptimization (
         DRECT2D& Extents
         ) const;

      void GenerateExtentOptimization (
         ) const;

      ERRVALUE GenerateSectionOptimization (
         SECTIONS*& Sections,                         
         INT32 NumVertices = 64
         ) const;

      void GenerateSectionOptimization (
         INT32 NumVertices = 64
         ) const;

      ERRVALUE GenerateStripOptimization (
         STRIPS*& Strips,                             
         INT32 NumDivs = 0
         ) const;

      ERRVALUE GenerateStripOptimization (
         INT32 NumDivs = 0
         ) const;

      DIMENSION GetDimension (
         ) const { return ((m_NumDim == 2) ? DIMENSION_2D : DIMENSION_3D); }

      const DRECT2D* GetExtentsIfKnown () const;

      INT32 GetNumPoints (
         ) const { return (m_NumPoints); }

      #ifndef GENERATING_DOXYGEN_OUTPUT
      double* GetPointer (
         int index = 0
         ) { return (m_Points + GetOffset(index)); }
         
      const double* GetPointer (
         int index = 0
         ) const { return (m_Points + GetOffset(index)); }
      #endif // GENERATING_DOXYGEN_OUTPUT
      
      void GetTestPoint (
         DPOINT3D& pt
         ) const;
         
      const DPOINT2D& GetVertex (
         INT32 index
         ) const { return (*reinterpret_cast<const DPOINT2D*>(GetPointer(index))); }

      void GetVertex3D (
         INT32 index,
         DPOINT3D& pt
         ) const {
         const double *p = GetPointer(index);
         pt.x = p[0];
         pt.y = p[1];
         pt.z = (m_NumDim == 2) ? m_ZValue : p[2];
         return;
         }

      double GetVertexX (
         INT32 index
         ) const { return (GetPointer(index)[0]); }

      double GetVertexY (
         INT32 index
         ) const { return (GetPointer(index)[1]); }

      double GetVertexZ (
         INT32 index
         ) const { return ((m_NumDim == 2) ? (m_ZValue) : GetPointer(index)[2]); }

      ERRVALUE GetVertices (
         DOUBLE_ARRAY<DPOINT2D>& vertices       
         ) const;
         
      ERRVALUE GetVertices (
         DOUBLE_ARRAY<DPOINT3D>& vertices       
         ) const;
         
      ERRVALUE GetVertices (
         DPOLYGON& dpoly
         ) const;

      XMLNODE* GetXML (
         XMLNODE *parentnode,                
         const char *nodename = 0            
         ) const;
         
      double GetZValue (
         ) const { return (m_ZValue); }

      bool HasSectionOptimization (
         ) const;

      bool HasStripOptimization (
         ) const;

      int Intersect (
         POLYLINE& OperPoly,
         POLYLINELIST& PolyLineList,         
         COMBINERESULT& CombineResult
         );
         
      void IntersectClean (
         INTERSECTINFO& IntsInfo
         ) const;
         
      ERRVALUE IntersectSearch (
         INTERSECTINFO& IntsInfo,
         double threshold
         ) const;
         
      ERRVALUE IntersectSearch (
         INTERSECTINFO& IntsInfo,
         const POLYLINE& OtherLine,
         INTERSECTINFO* OtherIntsInfo,                
         double threshold
         ) const;
         
      ERRVALUE IntersectSplitLine (
         INTERSECTINFO& IntsInfo,
         SPLIT& SplitInfo,                            
         double threshold,
         bool CallBadSegment = false                  
         ) const;
         
      bool IsClosed (
         ) const { return (m_LineClosed); }

      bool IsEqual (
         const POLYLINE& rhs
         ) const;

      bool IsEquivalentTo (
         const POLYLINE& rhs,
         double threshold = 0.0
         ) const;

      bool IsPointInside (
         const DPOINT2D& pt                  
         ) const;

      bool IsRectangle (
         ) const;
      
      void MoveVertex (
         int index,              
         const DPOINT2D& delta,  
         int FixedVertex1 = -1,  
         int FixedVertex2 = -1   
         );

      bool RemoveColinearVertices (
         double thresh = 0.0,                
         bool KeepEndPoints = false
         );

      void RemoveDuplicates (
         double thresh = 0.0,                
         bool KeepEndPoints = false
         );

      bool RemoveDuplicateVertices (
         double thresh = 0.0                 
         );

      ERRVALUE Replace (
         INT32 StartVertex,
         INT32 EndVertex,                 
         const POLYLINE& RepLine,
         INT32 RepLineStartVertex = 0,
         INT32 RepLineEndVertex = INT32_MAX
         );

      ERRVALUE Reserve (
         INT32 NumPoints
         );
         
      void Reverse (
         );

      void SetClosed (
         bool closed
         );
         
      ERRVALUE SetDimension (
         DIMENSION dimension
         );
         
      void SetOrientation (
         ORIENTATION Orientation
         );

      void SetPrecision (
         int Precision
         );
         
      void SetupExtentOptimization (
         const DRECT2D& Extents
         ) const;

      void SetupOrientationOptimization (
         ORIENTATION Orientation
         ) const;

      void SetupSectionOptimization (
         const SECTIONS& Sections                  
         ) const;

      void SetupStripOptimization (
         const STRIPS& Strips
         ) const;

      void SetVertex (
         INT32 index,                        
         const DPOINT2D& pt                  
         );

      void SetVertex (
         INT32 index,                        
         const DPOINT3D& pt                  
         );
         
      void SetVertexX (
         INT32 index,                        
         double x                            
         );

      void SetVertexY (
         INT32 index,                        
         double y                            
         );

      void SetVertexZ (
         INT32 index,                        
         double z                            
         );

      void SetZValue (
         double ZValue
         ) {m_ZValue = ZValue; }

      void Spline (
         SPLINE SplineType,
         INT32 NumKnots,                        
         double tolerance,
         SPLINEFLAGS flags = SPLINEFLAG_None
         );

      void SplineZ (
         SPLINE SplineType,
         INT32 NumKnots,                        
         double tolerance,
         SPLINEFLAGS flags = SPLINEFLAG_None
         );

      void Straighten (
         );

      int Subtract (
         POLYLINE& OperPoly,
         POLYLINELIST& PolyLineList,         
         COMBINERESULT& CombineResult
         );
         
      void Thin (
         THINMETHOD Method,
         double Factor
         );
         
      void TransferOwnerFrom (
         DOUBLE_ARRAY<DPOINT2D>& rhs         
         );
         
      void TransferOwnerFrom (
         DOUBLE_ARRAY<DPOINT3D>& rhs         
         );
         
      void TransferOwnerTo (
         DOUBLE_ARRAY<DPOINT2D>& rhs         
         );
         
      void TransferOwnerTo (
         DOUBLE_ARRAY<DPOINT3D>& rhs         
         );
         
      int Union (
         POLYLINE& OperPoly,
         POLYLINELIST& PolyLineList,         
         COMBINERESULT& CombineResult
         );
         
      int ValidatePolygon (
         ) const;
         
      int ValidatePolygon (
         DELEGATE_ERRVALUE_POLYLINE DelegateOnValidated  
         ) const;
         
      int ValidatePolygon (
         CLIP& ClipTarget                 
         ) const;
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      POLYLINE (const POLYLINE& rhs, const SECTION& Section);
      
      void AddJoinPoints (const DPOINT2D& BasePt, double OffsetDistance, const DPOINT3D& op1, const DPOINT3D& op2, JOINTYPE JoinType);
      ERRVALUE AddVertexNoCopy (const DPOINT3D& point, INT32 index);
      int Combine (const POLYLINE& OperPoly, POLYLINELIST& PolyLineList, COMBINERESULT& CombineResult) const;     
      void ComputeExtentsRaw (DRECT2D& rect) const {ComputeExtentsRaw(rect, 0, m_NumPoints-1); }
      void ComputeExtentsRaw (DRECT2D& rect, INT32 StartVertex, INT32 EndVertex) const;
      double ComputeLengthRaw () const;
         
      void ComputeSegment (
         INT32 Index1,
         INT32 Index2,
         INT32 Index3,
         INT32 Index4,
         int NumKnots,
         double Tolerance,
         bool UseMinDist,
         const DOUBLE_ARRAY<double>& T,
         POLYLINE& TempLine
         ) const;
      
      void ComputeSegmentQ (
         INT32 Index1,
         INT32 Index2,
         INT32 Index3,
         int NumKnots,
         double Tolerance,
         bool UseMinDist,
         const DOUBLE_ARRAY<double>& T,
         POLYLINE& TempLine
         ) const;
      
      bool ComputeSegmentOffset (INT32 PointNum, double StartOffsetDistance, double EndOffsetDistance, DPOINT3D& op0, DPOINT3D& op1) const;
      ORIENTATION ComputeStatsRaw (double& area, DPOINT2D& centroid) const;

      struct INTPOINT;        
      ERRVALUE FindIntersections (const POLYLINE& ClipPoly, DOUBLE_ARRAY<INTPOINT>& IntPoints, bool& HasCommonVertex, bool& HasCommonSegment, MISTRING *pStrDebug = 0) const;
      void FixStartEndPoints (const DPOINT2D& Start, const DPOINT2D& End, double Tolerance);
      INT32 GetOffset (int index) const { return ((m_StartOffset + index) * m_NumDim); }
      DPOINT2D& GetVertexRef (INT32 index) { return (*reinterpret_cast<DPOINT2D*>(GetPointer(index))); }
         
      ERRVALUE IntersectSearchRaw (INTERSECTINFO& ThisIntsInfo, const POLYLINE& OtherLine, INTERSECTINFO *pOtherIntsInfo, double threshold, bool ReturnOnTrueCross, bool IgnoreLineEndPoints) const;

      ERRVALUE MakeCopy ();   
      void MoveVertexSub(int index, const DPOINT2D& delta, int fixed);
      ERRVALUE Resize (INT32 NewSize);
      void ResizeExc (INT32 NewSize);
      ERRVALUE ResizeNoCopy (INT32 NewSize);
      void SetVertexNoCopy (INT32 index, const DPOINT3D& pt);
         
      static bool TestPoint (const POLYLINE& LHS, const POLYLINE& RHS, const double *lhs, const double *rhs, double threshold);
      static bool TestDistance (const POLYLINE& P, const POLYLINE& Q, const double *p1, const double *p2, const double *q1, double threshold);
      void ValidateClosure ();

      bool m_LineClosed;            
      double m_ZValue;              
      int m_NumDim;                 
      INT32 m_NumPoints;            
      INT32 m_StartOffset;          
      double *m_Points;
      
      class PRIV;
      PRIV *m_Priv;
      
      class OPTIMIZE;
      friend class OPTIMIZE;
      mutable OPTIMIZE *m_Optimize;
      
      static const UINT32 s_AllocInc;     // Amount to increase buffer by
      static const double s_AngleStep;    // Amount increment angle by
      static const double s_MiterLimit;   // Maximum miter angle limit

      friend class POLYLINE::ITERATOR;
      friend class POLYLINE::STRIPS;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


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

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

inline bool operator< (       // for POLYLINELIST to compile
   const POLYLINE& lhs,
   const POLYLINE& rhs
   ) { return (lhs.GetNumPoints() < rhs.GetNumPoints()); }


class GEOMLIBCLASSEXPORT POLYLINELIST : public MILIST<POLYLINE> { };

class POLYLINE::CLIP {
   public:
      virtual ERRVALUE OnClip (
         const POLYLINE& PolyLine
         ) = 0;
      ERRVALUE DoClip (
         const POLYLINE& PolyLine
         ) { return (OnClip(PolyLine)); }
   };
   

#ifndef GENERATING_DOXYGEN_OUTPUT

GEOMLIBEXPORT void IntersectDumpInfo (const POLYLINE::INTERSECTINFO& ints, MISTRING& LogString, INT32 LineNum);

#endif // GENERATING_DOXYGEN_OUTPUT

class POLYLINE::INTERSECTINFO {
   public:
   
      struct CROSSPT {
         enum FLAGS {
            FLAG_KnowIsCross =   0x0001,     
            FLAG_IsCross =       0x0002,     
            };
         DPOINT3D m_point;
         INT32 m_index;
         UINT16 m_flags;
         UINT8 m_type;           
         UINT8 m_spare;
         
         CROSSPT (
            ) { memset(this, 0, sizeof(*this)); }
         };

      struct OVERLAP {
         DPOINT2D m_start;
         DPOINT2D m_end;
         INT32 m_index;
         #ifndef GENERATING_DOXYGEN_OUTPUT
         INT32 m_spare;       // For alignment
         #endif // GENERATING_DOXYGEN_OUTPUT

         OVERLAP (
            ) { memset(this, 0, sizeof(*this)); }
         };
         
      INTERSECTINFO (
         ) : m_IsCleaned(true) { }

      void Clean (
         const POLYLINE& PolyLine
         );

      void Clear (
         ) {
         m_CrossPts.Clear();
         m_Overlaps.Clear();
         m_IsCleaned = true;
         return;
         }
         
      void DumpInfo (
         MISTRING& LogString,
         INT32 LineNum                       
         ) const { IntersectDumpInfo (*this, LogString, LineNum); }
         
      const SIMPLE_ARRAY<CROSSPT>& GetCrossPoints (
         ) const { return (m_CrossPts); }
   
      SIMPLE_ARRAY<CROSSPT>& GetCrossPoints (
         ) { return (m_CrossPts); }
         
      INT32 GetNumCrossPoints (
         ) const { return (m_CrossPts.GetNumItems()); }
   
      INT32 GetNumOverlaps (
         ) const { return (m_Overlaps.GetNumItems()); }
   
      const SIMPLE_ARRAY<OVERLAP>& GetOverlaps (
         ) const { return (m_Overlaps); }
   
      SIMPLE_ARRAY<OVERLAP>& GetOverlaps (
         ) { return (m_Overlaps); }
         
      bool HasOverlaps (
         ) const { return (m_Overlaps.GetNumItems() != 0); }
   
      bool IsCleaned (
         ) const { return (m_IsCleaned); }
         
      bool IsEmpty (
         ) const { return (m_CrossPts.GetNumItems() == 0); }
   
      void SetCleaned (
         bool value = true
         ) {m_IsCleaned = value; }
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<CROSSPT> m_CrossPts;
      SIMPLE_ARRAY<OVERLAP> m_Overlaps;
      bool m_IsCleaned; 

      static int CompareCrossPt (
         CROSSPT *p1,
         CROSSPT *p2,
         void *vpPolyLine
         );

      static int CompareOverlap (
         OVERLAP *o1,
         OVERLAP *o2,
         void *vpPolyLine
         );

      void CleanCrossPts (
         const POLYLINE& PolyLine
         );
         
      void CleanOverlaps (
         const POLYLINE& PolyLine
         );
         
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


class GEOMLIBCLASSEXPORT POLYLINE::SECTIONS {
   public:
      SECTIONS (
         );

      SECTIONS (
         const SECTIONS& rhs
         );

      ~SECTIONS (
         );
         
      SECTIONS& operator= (
         const SECTIONS& rhs
         );

      void Clear (
         );

      ERRVALUE ComputeSections (
         const POLYLINE& PolyLine,     
         INT32 NumVertices = 64
         );
         
      const POLYLINE::SECTIONARRAY& GetSectionArray (
         ) const;
         
      bool IsValid (
         ) const;

      void SetSectionArray (
         const POLYLINE::SECTIONARRAY& SectionArray
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV *m_Priv;
      POLYLINE::SECTIONARRAY m_Empty;
      
      POLYLINE::SECTIONARRAY& GetSectionArrayRaw ();
      void GetUniqueSections (SECTIONS& NewSection) const;
      ERRVALUE ComputeSectionsRaw (const POLYLINE& PolyLine, INT32 NumVertices = 64);
      friend class POLYLINE;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
   
class POLYLINE::SPLIT {
   public:
      SPLIT (){ }
      virtual ~SPLIT (){ }

      ERRVALUE OnOverlap (
         const POLYLINE& PolyLine
         ) { return (v_OnOverlap(PolyLine)); }

      virtual ERRVALUE OnAdd (
         const POLYLINE& PolyLine
         ) = 0;

      virtual int OnBadSegment (
         const POLYLINE&               
         ) { return (0); }

      virtual ERRVALUE OnDelete (
         ) { return (0); }

   private:
      virtual ERRVALUE v_OnOverlap (
         const POLYLINE&               
         ) { return (0); }
   };
      

class GEOMLIBCLASSEXPORT POLYLINE::STRIPS {
   public:

      STRIPS (
         );

      STRIPS (
         const STRIPS& rhs
         );

      ~STRIPS (
         );
         
      STRIPS& operator= (
         const STRIPS& rhs
         );

      void Clear (
         );

      ERRVALUE ComputeStrips (
         const POLYLINE& PolyLine,     
         const DRECT2D& PolyExtents,
         INT32 NumDivs = 0             
         );
         
      ERRVALUE ComputeStrips (
         const POLYLINE& PolyLine,     
         INT32 NumDivs = 0             
         );
         
      const SIMPLE_ARRAY<INT32_RANGE>& GetStrip (
         double y
         ) const;

      ERRVALUE GetStrip (
         double yinit,
         double ylast,
         SIMPLE_ARRAY<INT32_RANGE>& Strip
         ) const;

      bool IsValid (
         ) const;

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      class PRIV;
      PRIV *m_Priv;
      SIMPLE_ARRAY<INT32_RANGE> m_Empty;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(POLYLINE::SPLINEFLAGS)
#endif

#undef GEOMLIBEXPORT
#undef GEOMLIBCLASSEXPORT
   
#endif      // INC_MI32_POLYLINE_H

---