polyline.h

Go to the documentation of this file.

/**
 * \file polyline.h <mi32/polyline.h>
 * \brief Definitions for 2D and/or 3D poly lines
 *
 * \if NODOC
 * $Id: polyline.h_v 1.83 2004/11/24 21:04:27 scowan Exp $
 *
 * $Log: polyline.h_v $
 * Revision 1.83  2004/11/24 21:04:27  scowan
 * Update comments.
 *
 * Revision 1.82  2004/11/24 18:45:06  scowan
 * Major update of find intersections and combine methods.
 *
 * Revision 1.81  2004/11/16 21:55:24  scowan
 * Fixed unix issue of convewrt to long.
 *
 * Revision 1.80  2004/11/16 17:14:24  dwilliss
 * Added variation of ConvertToLong that just takes an LPOINT2D array so taht
 * region2d's new ConvertToLongTruncate can call it.
 *
 * Revision 1.79  2004/10/27 21:25:57  scowan
 * Updated docs.
 *
 * Revision 1.78  2004/10/27 21:13:41  scowan
 * Moved internal closest point searching from conflate to its own method.
 *
 * Revision 1.77  2004/10/25 19:44:07  scowan
 * No real change, just some shortcuts added..
 *
 * Revision 1.76  2004/10/15 17:50:42  scowan
 * Added sections class and added and removed methos.
 *
 * Revision 1.75  2004/09/17 22:06:43  scowan
 * Fill in the spaces.
 *
 * Revision 1.74  2004/08/21 21:41:29  scowan
 *  Moved changes from 6.9 to here regarding conflate.
 *
 * Revision 1.73  2004/08/17 21:30:20  mju
 * Change combineresult enum names to be clearer and not specific to 'clipping'.
 *
 * Revision 1.72  2004/08/06 16:42:07  dwilliss
 * Added MoveVertex method
 *
 * Revision 1.71  2004/07/29 14:53:14  scowan
 * Added set precision method.
 *
 * Revision 1.70  2004/07/14 21:10:22  scowan
 * Removed methods that used legacy region code.
 *
 * Revision 1.69  2004/06/23 22:56:23  scowan
 * Added methods to transform the polyline points via a coord op transformation.
 *
 * Revision 1.68  2004/05/21 16:32:37  scowan
 * Added method to apply a zscale to the z coordinates of the line.
 *
 * Revision 1.67  2004/03/03 15:30:00  scowan
 * Fixed annoying warning issue.,
 *
 * Revision 1.66  2004/03/02 22:50:15  scowan
 * Export strip class.
 *
 * Revision 1.65  2004/03/02 15:23:56  scowan
 * Add function to allow milist < polyline >.
 *
 * Revision 1.64  2004/03/02 15:11:57  scowan
 * Removed defines when done.
 * Export poly line list.
 * Make dump ints info inline again.
 *
 * Revision 1.63  2004/03/02 00:24:38  scowan
 * Export from geom the class.
 *
 * Revision 1.62  2004/02/11 16:07:26  scowan
 * Added inline bool methods.
 *
 * Revision 1.61  2004/02/10 23:13:28  scowan
 * Added virtual method.
 *
 * Revision 1.60  2003/12/17 22:12:19  scowan
 * Added method for is equivalent to.
 *
 * Revision 1.59  2003/11/28 15:58:08  scowan
 * Changed is eqiv to method.
 *
 * Revision 1.58  2003/11/25 00:30:14  scowan
 * Added is equivalent to methods.
 *
 * Revision 1.57  2003/11/06 18:24:51  scowan
 * Added parameter to remove duplicate method.
 *
 * Revision 1.56  2003/10/16 20:16:30  scowan
 * Passed mi string instead of file pointer for log in validate.
 *
 * Revision 1.55  2003/09/25 21:29:07  dwilliss
 * Don't capitalize enum any more. Genitor needed it, doxygen doesn't like it.
 *
 * Revision 1.54  2003/09/15 13:49:56  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.53  2003/09/09 17:56:29  scowan
 * Added another convert to long method.
 *
 * Revision 1.52  2003/09/04 22:02:36  scowan
 * More class friends.
 *
 * Revision 1.51  2003/09/04 17:09:40  scowan
 * Added detach buffer method.
 *
 * Revision 1.50  2003/08/11 20:34:10  scowan
 * Added compute longest segment method and added length optimization.
 *
 * Revision 1.49  2003/07/22 22:15:37  scowan
 * Reset add join end method.
 *
 * Revision 1.48  2003/07/22 00:00:27  scowan
 * Added two more compute offset methods.
 *
 * Revision 1.47  2003/06/04 22:03:05  scowan
 * Added method to determine if extents are available and get them if they are.
 *
 * Revision 1.46  2003/04/29 17:26:17  scowan
 * Added typedef for poly line list.
 *
 * Revision 1.45  2003/01/09 19:21:04  scowan
 * Added new ctor.
 *
 * Revision 1.44  2002/12/18 23:17:36  scowan
 * Added trianglulate.
 *
 * Revision 1.43  2002/11/21 18:57:16  dwilliss
 * Added IsRectangle() method
 *
 * Revision 1.42  2002/11/14 16:48:34  scowan
 * Change parameter type.
 *
 * Revision 1.41  2002/11/12 20:18:14  dwilliss
 * Ok, so I don't have the points as a SIMPLE_ARRAY.
 * Implemented constructor/Assign that take array of LPOINT2D and NumPoints so
 *   we don't have to make a temporary copy.
 *
 * Revision 1.40  2002/11/12 20:09:34  dwilliss
 * Added constructor and Assign method taking SIMPLE_ARRAY<LPOINT2D>
 *
 * Revision 1.39  2002/10/18 13:52:14  scowan
 * Changed combine parameters.
 *
 * Revision 1.38  2002/10/14 16:24:38  scowan
 * Added equal method and operator overloads.
 *
 * Revision 1.37  2002/10/09 22:26:23  scowan
 * Added combination methods.
 *
 * Revision 1.36  2002/10/07 17:39:41  scowan
 * More comments.
 *
 * Revision 1.35  2002/10/04 21:14:36  scowan
 * Added orientation optimization.
 * Renamed swap to reverse.
 *
 * Revision 1.34  2002/09/20 19:38:10  scowan
 * Added check for strip optimization.
 *
 * Revision 1.33  2002/09/19 14:44:06  scowan
 * Removed use of vector include file.
 *
 * Revision 1.32  2002/09/18 19:22:55  scowan
 * Added 3d trans methods.
 *
 * Revision 1.31  2002/09/18 16:55:21  scowan
 * Added more comments.
 *
 * Revision 1.30  2002/09/16 15:12:08  scowan
 * Added methods for optimization, ref counting and Z coordinate settings.
 *
 * Revision 1.29  2002/07/11 15:50:04  scowan
 * nothing rteally.
 *
 * Revision 1.28  2002/07/05 19:41:01  scowan
 * Added method for 3d rect assignment.
 *
 * Revision 1.27  2002/06/20 15:51:57  scowan
 * Split up intersection clean.
 *
 * Revision 1.26  2002/06/03 23:58:26  scowan
 * nc
 *
 * Revision 1.25  2002/06/03 23:57:38  scowan
 * Added clip to arbitrary region.
 *
 * Revision 1.24  2002/05/10 19:33:48  scowan
 * Added another long to round.
 *
 * Revision 1.23  2002/04/23 16:27:37  scowan
 * Return value change and docs for clip.
 *
 * Revision 1.22  2002/04/23 15:59:55  scowan
 * Added more comments.
 *
 * Revision 1.21  2002/04/17 21:28:11  scowan
 * Added clip methods and classes.
 *
 * Revision 1.20  2002/03/14 18:21:57  scowan
 * Moved mid point comp inside.
 *
 * Revision 1.19  2002/02/28 18:58:52  scowan
 * Updated docs.
 *
 * Revision 1.18  2002/02/28 18:56:06  scowan
 * Updated documentation.
 *
 * Revision 1.17  2001/12/28 16:25:09  scowan
 * Added get test point method.
 *
 * Revision 1.16  2001/12/26 20:48:22  scowan
 * Added method and more const.
 *
 * Revision 1.15  2001/11/07 21:43:33  scowan
 * Added conflate method.
 *
 * Revision 1.14  2001/10/24 21:00:01  scowan
 * Nothing.
 *
 * Revision 1.13  2001/10/23 15:20:00  scowan
 * New extract method.
 *
 * Revision 1.12  2001/09/07 22:02:07  scowan
 * Added parameter.
 *
 * Revision 1.11  2001/05/24 17:00:22  scowan
 * Added many more methods, including intersect, thin, and spline.
 * Uses new MIDOUBLEARRAY for base operations.
 *
 * Revision 1.10  2001/02/13 23:31:52  scowan
 * Added methods to find point given distance and extract a sub-line given distance.
 *
 * Revision 1.9  2001/01/26 17:32:40  scowan
 * Fixed line closure ambiguity.
 *
 * Revision 1.8  2001/01/22 17:09:20  mju
 * Add GetVertices().
 *
 * Revision 1.7  2001/01/17 15:49:36  mju
 * Change default ctor to put ReservePoints at end.
 *
 * Revision 1.6  2001/01/17 15:19:38  mju
 * Add FindClosestSegment().
 *
 * Revision 1.5  2001/01/17 14:45:26  mju
 * Add FindClosestVertex which returns index.
 *
 * Revision 1.4  2001/01/12 22:56:42  scowan
 * Chagned compression method names.
 *
 * Revision 1.3  2001/01/11 16:42:27  scowan
 * Added compression methods.
 *
 * Revision 1.2  2001/01/05 20:58:02  scowan
 * Major changes suggested by Mike.
 *
 * Revision 1.1  2001/01/04 22:54:20  scowan
 * Initial revision
 *
 * \endif
**/

#ifndef INC_MI32_POLYLINE_H
#define INC_MI32_POLYLINE_H

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

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

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

#ifndef  INC_MI32_POINT_H
   #include <mi32/point.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

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

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

#ifndef GENERATING_DOXYGEN_OUTPUT
//! Forward declarations
class BITSET_UNOWNED;
class TRANS2D_AFFINE;
class TRANS2D_MAPGEN;
class TRANS3D;
namespace SPATREF { class COORDOP; }
#endif //!< GENERATING_DOXYGEN_OUTPUT

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

enum TESTCRITERIA {
  TESTCRITERIA_FullOutside = 0,  //!< Test if fully outside region
  TESTCRITERIA_PartOutside = 1,  //!< Test if any part is outside region
  TESTCRITERIA_FullInside = 2,   //!< Test if fully inside region
  TESTCRITERIA_PartInside = 3    //!< Test if any part is inside region
  };


//--------------------------------------------------------------------------------------------------------------------
//! The POLYLINE class encapsulates a 2D or 3D polyline.  Its primary use is for manipulation of
//! coordinates whether in 2D or 3D.  It does not maintain polygon topology (i.e. crossing segments are not
//! resolved).  The base storage method is a MIDOUBLEARRAY, by which alignment is maintained.
//!
//! A POLYLINE instance can have associated with it certain optimization setups to improve some of the methods
//! response times.  They are currently "Extents", "Section", and "Strip" optimizations.  The methods that can
//! make use of these optimizations will state that in the documentation for that method.
//--------------------------------------------------------------------------------------------------------------------

class GEOMLIBCLASSEXPORT POLYLINE {
   public:
   
      enum COMPRESULT {
         COMPRESULT_Outside = 1,       //!< Both elements are outside of each other
         COMPRESULT_Inside,            //!< One element is completely inside the other
         COMPRESULT_Intersect,         //!< Both elements intersect
         COMPRESULT_Overlap            //!< One element overlaps the other
         };

      //! Values returned for Union(), Intersect(), Subtract() and ExclusiveUnion()
      enum COMBINERESULT {
         COMBINERESULT_Disjoint =      1, //!< Polygons are disjoint
         COMBINERESULT_OperInsideSrc = 2, //!< Operator polygon inside source polygon, may share border point(s)
         COMBINERESULT_SrcInsideOper = 3, //!< Source polygon inside operator polygon, may share border point(s)
         COMBINERESULT_Equal =         4, //!< Source polygon equals operator polygon
         COMBINERESULT_Intersect =     5, //!< Source and operator polygons intersect
         // 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;

      //! Constant iterator.
      class CONST_ITERATOR {
      public:

         CONST_ITERATOR (                 //! Default constructor
            ) :
            m_Index(0),
            m_PolyLine(0)
            {}

         CONST_ITERATOR (                 //! Internal constructor
            INT32 index,
            const POLYLINE*const PolyLine
            ) : 
            m_Index(index),
            m_PolyLine(PolyLine)
            {}

         CONST_ITERATOR (                 //! Copy constructor
            const CONST_ITERATOR& rhs
            ) : 
            m_Index(rhs.m_Index),
            m_PolyLine(rhs.m_PolyLine)
            {}

         CONST_ITERATOR (                 //! Copy constructor
            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* (      //! Dereference operator, returns reference to templated item
            ) const {return (m_PolyLine->GetVertex(m_Index));}

         const DPOINT2D* operator-> (     //! Dereference operator, returns pointer to templated item
            ) const {return (&**this);}

         //! Pre-increment operator.
         CONST_ITERATOR& operator++ (
            ) {
            m_Index ++;
            return (*this);
            }

         //! Post-increment operator.
         CONST_ITERATOR operator++(int
            ) {
            CONST_ITERATOR temp = *this;
            ++*this;
            return (temp);
            }

         //! Pre-decrement operator.
         CONST_ITERATOR& operator-- (
            ) {
            m_Index --;
            return (*this);
            }

         //! Post-decrement operator.
         CONST_ITERATOR operator--(int
            ) {
            CONST_ITERATOR temp = *this;
            --*this;
            return (temp);
            }

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

         bool operator!= (          //! Inequality operator
            const CONST_ITERATOR& rhs
            ) const {return (!(*this == rhs));}
            
         INT32 GetIndex (
            ) const {return (m_Index);}

      protected:
         INT32 m_Index;
         const POLYLINE* m_PolyLine;
         };

      //! Non-const iterator.
      class ITERATOR {
      public:

         ITERATOR (                 //! Default constructor
            ) :
            m_Index(0),
            m_PolyLine(0)
            {}

         ITERATOR (                 //! Internal constructor
            INT32 index,
            POLYLINE* PolyLine
            ) : 
            m_Index(index),
            m_PolyLine(PolyLine)
            {}

         ITERATOR (                 //! Copy constructor
            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* (            //! Dereference operator, returns reference to templated item
            ) const {return (m_PolyLine->GetVertexRef(m_Index));}

         DPOINT2D* operator-> (        //! Dereference operator, returns pointer to templated item
            ) const {return (&**this);}

         //! Pre-increment operator.
         ITERATOR& operator++ (
            ) {
            m_Index ++;
            return (*this);
            }

         //! Post-increment operator.
         ITERATOR operator++(int
            ) {
            ITERATOR temp = *this;
            ++*this;
            return (temp);
            }

         //! Pre-decrement operator.
         ITERATOR& operator-- (
            ) {
            m_Index --;
            return (*this);
            }

         //! Post-increment operator.
         ITERATOR operator--(int
            ) {
            ITERATOR temp = *this;
            --*this;
            return (temp);
            }

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

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

      protected:
         INT32 m_Index;
         POLYLINE *m_PolyLine;
         
         friend class CONST_ITERATOR;
         };
         
      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:
            DRECT2D m_Extents;
            INT32_RANGE m_VertexRange;
            
            friend class POLYLINE;
         };
      typedef DOUBLE_ARRAY<SECTION> SECTIONARRAY;

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CLIP;
      class INTERSECTINFO;
      class SECTIONS;
      class SPLIT;
      class STRIPS;
      #endif //!< GENERATING_DOXYGEN_OUTPUT
      
      //! Default constructor
      POLYLINE (
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0,                //!< Initial Z value for POLYLINE if NumDim != 3
         UINT32 ReservePoints = 1            //!< Initial number of points to reserve in buffer
         );

      //! Constructor from DRECT2D, sets closed flag
      //! Sets "Extents" optimization
      explicit POLYLINE (
         const DRECT2D& rect,                //!< DRECT2D to create a line from
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DRECT3D, sets closed flag
      //! Sets "Extents" optimization
      explicit POLYLINE (
         const DRECT3D& rect                 //!< DRECT3D to create a line from
         );
         
      //! Constructor from legacy DPOLYGON
      explicit POLYLINE (
         const DPOLYGON& dpoly,              //!< Legacy DPOLYGON to create a line from
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DPOINT2D array and number of points
      POLYLINE (
         const DPOINT2D* pts,
         INT32 NumPoints,
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DOUBLE_ARRAY<double>
      //! This constructor transfers ownership from the DOUBLE_ARRAY<>
      explicit POLYLINE (
         DOUBLE_ARRAY<double>& rhs,
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DOUBLE_ARRAY<DPOINT2D>
      explicit POLYLINE (
         const DOUBLE_ARRAY<DPOINT2D>& rhs,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DOUBLE_ARRAY<DPOINT2D>
      explicit POLYLINE (
         const SIMPLE_ARRAY<LPOINT2D>& rhs,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from an array of LPOINT2D
      explicit POLYLINE (
         const LPOINT2D* points,
         INT32 NumPoints,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
         
      //! Constructor from DOUBLE_ARRAY<DPOINT3D>
      explicit POLYLINE (
         const DOUBLE_ARRAY<DPOINT3D>& rhs,
         bool closed = false                 //!< Create and maintain a closed polyline
         );
         
      //! Copy constructor
      //! Will use any optimizations associated with "rhs"
      POLYLINE (
         const POLYLINE& rhs
         );

      //! Section copy constructor
      //! NO optimizations associated with "rhs" will be used
      POLYLINE (
         const POLYLINE& rhs,                //!< POLYLINE to copy from
         INT32 StartVertex,                  //!< Start vertex of 'rhs
         INT32 EndVertex                     //!< End vertex of 'rhs' (Inclusive)
         );
      
      //! Destructor    
      ~POLYLINE (
         );

      //! Assignment
      //! Will keep any optimizations associated with "rhs"
      //! If POLYLINE::Reserved() was called on 'this' to pre-allocate the point buffer, do not call this method,
      //! call POLYLINE::operator+=() or POLYLINE::Append().
      POLYLINE& operator= (
         const POLYLINE& rhs
         );

      //! Append 'rhs' to 'this'
      //! If both 'rhs' and 'this' have "Extents" optimization, this method update 'this' Extents optimization
      POLYLINE& operator+= (
         const POLYLINE& rhs
         );

      //! Add a vertex to the line
      ERRVALUE AddVertex (
         const DPOINT2D& point,              //!< Point to add
         INT32 index = -1                    //!< Default location is the end of the line
         );

      //! Add a vertex to the line
      ERRVALUE AddVertex (
         const DPOINT3D& point,              //!< Point to add
         INT32 index = -1                    //!< Default location is the end of the line
         );
         
      //! Append a POLYLINE to this one, by default removing duplicates and collinear points at the joined section
      //! This method will update the "Extents" optimization for 'this' if both 'this' and 'rhs' have that optimization
      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                       //!< Z Scale factor to apply to z coordinate (pt[i].z *= zscale)
         );
         
      //! Assign point values from legacy DPOLYGON structure
      ERRVALUE Assign (
         const DPOLYGON& dpoly,
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );

      //! Assign point values from DPOINT2D array and number of points
      ERRVALUE Assign (
         const DPOINT2D* pts,
         INT32 NumPoints,
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
               
      //! Assign point values from SIMPLE_ARRAY<LPOINT2D> buffer
      ERRVALUE Assign (
         const SIMPLE_ARRAY<LPOINT2D>& rhs,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );

      //! Assign point values from SIMPLE_ARRAY<LPOINT2D> buffer
      ERRVALUE Assign (
         const LPOINT2D* rhs,
         int NumPoints,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
               
      //! Assign point values from DOUBLE_ARRAY<DPOINT2D> buffer
      ERRVALUE Assign (
         const DOUBLE_ARRAY<DPOINT2D>& rhs,
         bool closed = false,                //!< Create and maintain a closed polyline
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );
               
      //! Assign point values from DOUBLE_ARRAY<DPOINT3D> buffer
      ERRVALUE Assign (
         const DOUBLE_ARRAY<DPOINT3D>& rhs,
         bool closed = false                 //!< Create and maintain a closed polyline
         );
         
      //! Assign point values from a DRECT2D
      ERRVALUE Assign (
         const DRECT2D& rect,                //!< DRECT2D to crete a line from
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE
         );
         
      //! Assign point values from a DRECT3D
      ERRVALUE Assign (
         const DRECT3D& rect                 //!< DRECT2D to crete a line from
         );
         
      //! Attach a MIDOUBLEARRAY instance to 'this' by taking ownership of the MIDOUBLEARRAY buffer.  After this call, the 
      //! MIDOUBLEARRAY buffer is no longer valid
      void Attach (
         MIDOUBLEARRAY& rhs,
         INT32 NumPoints,
         bool closed = false,                //!< Create and maintain a closed polyline
         DIMENSION dimension = DIMENSION_2D, //!< Create a 2D or 3D line
         double ZValue = 0.0                 //!< Initial Z value for POLYLINE if NumDim != 3
         );

      //! Return a CONST_ITERATOR that refers to the beginning of the POLYLINE
      CONST_ITERATOR Begin (       
         ) const {return (CONST_ITERATOR(0, this));}

      //! Return an ITERATOR that refers to the beginning of the POLYLINE
      ITERATOR Begin (              
         ) {return (ITERATOR(0, this));}

      //! Clear POLYLINE of point data 
      void Clear (
         );

      //! Clear POLYLINE of all optimizations
      void ClearOptimizations (
         );

      //! Clear POLYLINE of point data 
      void ClearPoints (
         INT32 StartPosn = 0,
         INT32 EndPosn = INT32_MAX           //!< Inclusive
         );
         
      //! Clip a polyline to a rectangle, call the ClipTarget for each segment
      //! Uses the "Extent" optimization
      //! @return TRUE if part of the line is inside the clipping area, FALSE if not,  < 0 error
      int Clip (
         const DRECT2D& ClipRect,
         CLIP& ClipTarget,
         CLIPMODE ClipMode = CLIPMODE_Inside
         );

      //! Compare the two lines and return the result of the comparison.
      //! Uses "Extent" and "Section" optimizations
      //! @return COMPRESULT depending on the relationship of 'OtherLine' to 'this'
      COMPRESULT CompareLineToLine (
         const POLYLINE& OtherLine
         ) const;

      //! Compare the line against the polygon and return the result of the comparison.
      //! Uses "Extent", "Section" and "Strip" optimizations
      //! @return COMPRESULT depending on the relationship of 'Polygon' to 'this'
      COMPRESULT CompareLineToPolygon (
         const POLYLINE& Polygon
         ) const;

      //! Compare the line against the polygon and return the result of the comparison.
      //! Uses "Extent", "Section" and "Strip" optimizations
      //! @return COMPRESULT depending on the relationship of 'Polygon' to 'this'
      COMPRESULT CompareLineToPolygon (
         const DRECT2D& rect
         ) const;

      //! Compare the two polygons and return the result of the comparison.
      //! Uses "Extent", "Section" and "Strip" optimizations
      //! @return COMPRESULT depending on the relationship of 'OtherPoly' to 'this'
      COMPRESULT ComparePolygonToPolygon (
         const POLYLINE& OtherPoly
         ) const;

      //! Compute the angle for the line using the sum of all the angles in the line
      //! @return Angle summation of the angles between segments
      double ComputeAngle (
         ) const;

      //! Find area of polygon if the line is closed
      //! This method assumes that the polygon is topologically correct (i.e. it does not cross itself)
      //! @return: Area of the polygon if a polygon, Zero otherwize
      double ComputeArea (
         ) const {
         double area;
         ComputeStats(&area, 0);
         return (area);
         }
         
      //! Find centroid of polygon if the line is closed
      //! This method assumes that the polygon is topologically correct (i.e. it does not cross itself)
      void ComputeCentroid (
         DPOINT2D& cent
         ) const {ComputeStats(0, &cent);}
         
      //! Compute the shortest distance between the two lines.  If the lines cross, return zero.
      //! Uses "Section" optimization
      //! @return The shortest distance between the two lines
      double ComputeDistance (
         const POLYLINE& OtherLine,
         bool ExtentsOverlap = true       //!< Set to false if the extents of the two lines DO NOT overlap.  If set to 'false' this method does not need to check for segment intersections
         ) const;

      //! Determine a point on the line given a distance from the start or end of the line
      //! @return: True if point found on the line, false if not
      bool ComputeDistPointOnLine (
         double Distance,
         DPOINT3D& NewPoint,              //!< Computed point based on distance RETURNED
         bool DistanceFromStart = true
         ) const;
         
      //! Determine the extents of the line
      //! Uses and / or sets the "Extent" optimization
      void ComputeExtents (
         DRECT3D& rect
         ) const;
      
      //! Determine the extents of a sub-section of the line
      void ComputeExtents (
         DRECT3D& rect,
         INT32 StartVertex,
         INT32 EndVertex            //!< Inclusive
         ) const;
         
      //! Determine the extents of the line
      //! Uses and / or sets the "Extent" optimization
      void ComputeExtents (
         DRECT2D& rect
         ) const;
      
      //! Determine the extents of a sub-section of the line
      void ComputeExtents (
         DRECT2D& rect,
         INT32 StartVertex,
         INT32 EndVertex            //!< Inclusive
         ) const;
      
      //! Determine length of the line
      //! @return: Length of the line in line units
      double ComputeLength (
         ) const;
         
      //! Determine length of the line to the point specified
      //! @return: Length of the line in line units to the point specified
      double ComputeLength (
         const DPOINT3D& point            //!< Compute distance from start of line to point given
         ) const;
         
      //! Determine length of the longest segment of the line
      //! @return: Length of the longest segment of the line in line units
      double ComputeLongestSegmentLength (
         ) const;

      //! Determine maximum length between two vertices on the polygon
      //! Uses the "Section" and "Extent" optimizations
      //! @return Maximum dimension of the polygon       
      double ComputeMaxDimension (
         ) const;
         
      //! Determine line mid-point
      void ComputeMidPoint (
         DPOINT3D& MidPoint               //!< Computed mid-point RETURNED
         ) const;

      //! Compute an offset from the line using a distance and a join type.      
      //! Positive buffer distances will result in a buffer to the right of the line
      //! assuming Cartesian coordinates (+ right/up, - left/down)
      ERRVALUE ComputeOffset (
         double OffsetDistance,
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      //! Compute an offset from the line using a start distance, end distance and a join type.
      //! Positive buffer distances will result in a buffer to the right of the line
      //! assuming Cartesian coordinates (+ right/up, - left/down)
      ERRVALUE ComputeOffset (
         double StartOffsetDistance,
         double EndOffsetDistance,
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      //! Compute an offset from the line using a start distance, end distance and a join type.
      //! Positive buffer distances will result in a buffer to the right of the line
      //! assuming Cartesian coordinates (+ right/up, - left/down)
      ERRVALUE ComputeOffset (
         const SIMPLE_ARRAY<double>& OffsetDistance,        //!< One entry for each vertex in the line, sign of each distance needs to be the same
         POLYLINE& OffsetLine,
         JOINTYPE JoinType = JOINTYPE_Miter
         ) const;
         
      //! Find orientation of polygon if the line is closed
      //! This method assumes that the polygon is topologically correct (i.e. it does not cross itself)
      //! @return: Orientation of the polygon, ORIENTATION_Unknown otherwize
      ORIENTATION ComputeOrientation (
         ) const {return (ComputeStats(0, 0));}
         
      //! Determine a point on the line given a percentage from the start or end of the line
      void ComputePercentPointOnLine (
         double Percent,                  //!< Value between 0.0 and 1.0
         DPOINT3D& NewPoint,              //!< Computed point based on distance RETURNED
         bool DistanceFromStart = true
         ) const;
         
      //! Compute statistics for the polygon
      //! This method assumes that the polygon is topologically correct (i.e. it does not cross itself)
      //! @return: Orientation of the polygon, ORIENTATION_Unknown otherwize
      ORIENTATION ComputeStats (
         double *const area,                 //!< Area value RETURNED, NULL if not needed
         DPOINT2D *const centroid            //!< Centroid value RETURNED, NULL if not needed
         ) const;
         
      //! Conflate a set of POLYLINE's with the changed vertex priority assigned to the set.
      //! If there is a change to be made to get the lines to match along a set of segments, the 'LineList' will
      //! be picked to change its points before 'this' will.
      //! Uses the "Section" and "Extent" optimizations
      ERRVALUE Conflate (
         MILIST<POLYLINE>& LineList,
         double thresh,
         bool& LineChanged,
         BITSET_UNOWNED& LineListSet         //!< Matches the 'LineList' and tells which lines have been changed
         );
      
      //! Convert point coordinates using affine transformation      
      void ConvertForward (
         const TRANS2D_AFFINE& taf
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertForwardDense (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using 3D perspective transformation    
      void ConvertForward (
         const TRANS3D& t3d
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertForward (
         const SPATREF::COORDOP& Op
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertForwardDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );

      //! Convert point coordinates using affine transformation      
      void ConvertInverse (
         const TRANS2D_AFFINE& taf
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertInverse (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertInverseDense (
         const TRANS2D_MAPGEN& tmg
         );

      //! Convert point coordinates using 3D perspective transformation    
      void ConvertInverse (
         const TRANS3D& t3d
         );
      
      //! Convert point coordinates using generic transformation     
      ERRVALUE ConvertReverse (
         const SPATREF::COORDOP& Op
         );

      //! Convert point coordinates using generic transformation with densification
      ERRVALUE ConvertReverseDense (
         const SPATREF::COORDOP& Op,
         double tolerance
         );

      //! Convert polygon from double's to INT32's (no rounding), removes duplicate points
      ERRVALUE ConvertToLong (
         SIMPLE_ARRAY<LPOINT2D>& LPointList
         ) const;

      //! Convert polygon from double's to INT32's (no rounding), removes duplicate points
      INT32 ConvertToLong (
         LPOINT2D* LPointList
         ) const;

      //! Convert polygon from double's to INT32's with rounding, removes duplicate points
      ERRVALUE ConvertToLongRound (
         SIMPLE_ARRAY<LPOINT2D>& LPointList
         ) const;

      //! Convert polygon from double's to INT32's with rounding, removes duplicate points
      //!
      //! @return Number of points converted into 'LPointList'
      INT32 ConvertToLongRound (
         LPOINT2D* LPointList
         ) const;

      //! Convert polygon from double's to INT32's with rounding, keep duplicate points
      ERRVALUE ConvertToLongRoundKeepDups (
         SIMPLE_ARRAY<LPOINT2D>& LPointList
         ) const;

      //! Delete a line vertex
      //! If the line is a closed polygon and removing a vertex causes less than 4 vertices
      //! to remain, the line is opened
      void DeleteVertex (                 //! Remove a vertex from the line
         int index                        //!< Index of vertex to remove
         );
         
      //! Detach the MIDOUBLEARRAY from 'this' to 'rhs'.  'this' does not have control of the buffer after this call
      void Detach (
         MIDOUBLEARRAY& rhs
         );

      //! Detach the MIDOUBLEARRAY from 'this' to 'rhs'.  'this' is not usable until Attach() is called, if you try, your process will die.
      void DetachBuffer (
         MIDOUBLEARRAY& rhs
         );


      //! Return an ITERATOR that refers to the end of the POLYLINE, not a valid point
      ITERATOR End (                
         ) {return (ITERATOR(m_NumPoints, this));}

      //! Return a CONST_ITERATOR that refers to the end of the POLYLINE, not a valid point
      CONST_ITERATOR End (          
         ) const {return (CONST_ITERATOR(m_NumPoints, this));}

      //! Exclusive Union (XOR) operator polygon with 'this'
      //! 'this' and 'PolyLineList' must be conflated using POLYLINE::Conflate()
      //! "PolyLineList" will contain ORIENTATION_Clockwise for shell polygons and ORIENTATION_CounterClockwise for islands
      ERRVALUE ExclusiveUnion (
         POLYLINE& OperPoly,
         MILIST<POLYLINE>& PolyLineList,        //!< Results of operation returned here
         COMBINERESULT& CombineResult
         );
         
      //! Extract a portion of the line into a new line based on a basepoint and distance from that basepoint
      void Extract (
         POLYLINE& NewLine,                  //!< Result of extraction
         const DPOINT3D& BasePoint,          //!< Point to extract from based on "ExtractPoint"
         double Distance,
         EXTRACT ExtractPoint,
         bool ExtrudePastEnds = false
         ) const;
         
      //! Extract a portion of the line into a new line based on two point on the line
      void Extract (
         POLYLINE& NewLine,                  //!< Result of extraction
         const DPOINT3D& StartPoint,         //!< Point to start extraction from
         const DPOINT3D& EndPoint            //!< Point to end extraction from
         ) const;
         
      //! Extract a portion of the line into a new line based on position and number of points
      void Extract (
         INT32 StartPosn,
         INT32 NumPoints,
         POLYLINE& ExtractLine
         ) const;
      
      //! Find closest point on the line (not necessarily at a vertex) to specified point.
      //! @return: Distance to closest point on the line, not necessarily a vertex point
      double FindClosestPoint (
         const DPOINT2D& point,              //!< Point to check
         DPOINT2D& retpt                     //!< Point on line found RETURNED
         ) const;
      
      //! Find closest point on the line (not necessarily at a vertex) to specified point.
      //! This method uses linear interpolation to determine the correct z value.
      //! @return: Distance to closest point on the line, not necessarily a vertex point
      double FindClosestPoint (
         const DPOINT3D& point,              //!< Point to check
         DPOINT3D& retpt                     //!< Point on line found RETURNED
         ) const;

      //! Find closest point on the line (not necessarily at a vertex) to specified point.
      //! This method uses linear interpolation to determine the correct z value.
      //! This method is faster than the above 'FindClosestPoint' methods because it will 
      //!   make less calls to DistPointLineSegD().
      //! @return: Distance to closest point on the line, may not be smaller than 'MaxmimumDistance'
      double FindClosestPoint (
         const DPOINT3D& point,              //!< Point to check
         double MaximumDistance,             //!< Maximum distance allowed between point on the line and 'point'
         DPOINT3D& retpt,                    //!< Point on line found RETURNED
         INT32& Vertex                       //!< Index of vertex BEFORE the location of the point RETURNED
         ) const;

      //! Find closest segment to specified point.
      //! @return Index of first vertex of segment, may be last polyline vertex if closed.
      int FindClosestSegment (
         const DPOINT2D& point,              //!< Point to check
         double *distance = 0                //!< Distance returned, 0 if don't need
         ) const;
         
      //! Find closest vertex to specified 2D point.
      //! @return: Distance to closest vertex on the line.
      double FindClosestVertex (
         const DPOINT2D& point,              //!< Point to check
         INT32& index                        //!< Index of closest vertex returned
         ) const;
      
      //! Find closest vertex to specified 2D point.
      //! @return: Index of closest vertex.
      int FindClosestVertex (
         const DPOINT2D& point,              //!< Point to check
         double *distance = 0                //!< Distance returned, 0 if don't need
         ) const;
      
      //! Find closest vertex to specified 3D point.
      //! This method uses linear interpolation to determine the Z value.
      //! @return: Distance to closest vertex on the line
      double FindClosestVertex (
         const DPOINT3D& point,              //!< Point to check
         INT32& index                        //!< Index of closest vertex returned
         ) const;

      //! Generate the "Extent" optimization.
      //! Used mostly for Compare...() methods and to setup the "Strip" optimization
      void GenerateExtentOptimization (
         DRECT2D& Extents
         ) const;

      //! Generate the "Extent" optimization.
      //! Used mostly for Compare...() methods and to setup the "Strip" optimization
      void GenerateExtentOptimization (
         ) const;

      //! Generate the "Section" optimization.
      //! Used for many methods.  A "Section" is defined as piece of the source line (defined by "NumVertices")
      //! and that sections extents.
      ERRVALUE GenerateSectionOptimization (
         SECTIONS*& Sections,                         //!< Section information RETURNED, you must free pointer
         INT32 NumVertices = 64
         ) const;

      //! Generate the "Section" optimization.
      //! Used for many methods.  A "Section" is defined as piece of the source line (defined by "NumVertices")
      //! and that sections extents.  
      void GenerateSectionOptimization (
         INT32 NumVertices = 64
         ) const;

      //! Generate the "Strip" optimization.
      //! Used for IsPointInside() method.  A "Strip" is defined as a list of segments that fall within a range of y values.
      ERRVALUE GenerateStripOptimization (
         STRIPS*& Strips,                             //!< Strip information RETURNED, you must free pointer
         INT32 NumDivs = 0
         ) const;

      //! Generate the "Strip" optimization.
      //! Used for IsPointInside() method.  A "Strip" is defined as a list of segments that fall within a range of y values.
      ERRVALUE GenerateStripOptimization (
         INT32 NumDivs = 0
         ) const;

      //! Get current line dimension
      DIMENSION GetDimension (
         ) const {return ((m_NumDim == 2) ? DIMENSION_2D : DIMENSION_3D);}

      //! Get the extents of the POLYLINE if it exists, this method will NOT compute the extents
      //! @return 'True' if the extent optimization is valid, 'false' if not
      bool GetExtentsOptimization (
         DRECT2D& Extents
         ) const;

      //! Get the number of points in the line
      //! @return: Number of points in the line
      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
      
      //! Get Test Point
      //! Obtains valid test point for the line, either the middle vertex or. 
      //! if a two point line, the midpoint
      void GetTestPoint (
         DPOINT3D& pt
         ) const;
         
      //! Get 2D vertex.
      //! @return: Constant reference to a 2D point
      const DPOINT2D& GetVertex (
         INT32 index
         ) const { return (*reinterpret_cast<const DPOINT2D*>(GetPointer(index))); }

      //! Get a 3D point 
      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;
         }

      //! Get 'Z' coordinate of a vertex
      //! @return: 'Z' coordinate
      double GetVertexZ (
         INT32 index
         ) const { 
         if (m_NumDim == 2) return (m_ZValue);
         const double *p = GetPointer(index);
         return (p[2]);
         }

      //! Get vertices into DOUBLE_ARRAY<DPOINT2D> array.
      ERRVALUE GetVertices (
         DOUBLE_ARRAY<DPOINT2D>& vertices       //!< Vertices returned
         ) const;
         
      //! Get vertices into DOUBLE_ARRAY<DPOINT3D> array.
      ERRVALUE GetVertices (
         DOUBLE_ARRAY<DPOINT3D>& vertices       //!< Vertices returned
         ) const;
         
      //! Get vertices into DPOLYGON
      ERRVALUE GetVertices (
         DPOLYGON& dpoly
         ) const;
         
      //! Get polyline Z value, only useful for 2D lines
      double GetZValue (
         ) const {return (m_ZValue);}

      //! Does 'this' have strip optimization
      bool HasSectionOptimization (
         ) const;

      //! Does 'this' have strip optimization
      bool HasStripOptimization (
         ) const;

      //! Intersect operator polygon with 'this'
      //! "PolyLineList" will contain ORIENTATION_Clockwise for shell polygons and ORIENTATION_CounterClockwise for islands
      //! 'this' and 'PolyLineList' must be conflated using POLYLINE::Conflate()
      //! @return '1' if "PolylineList" has one entry and is the same as 'this', 0 for all other cases, < 0 error
      int Intersect (
         POLYLINE& OperPoly,
         MILIST<POLYLINE>& PolyLineList,        //!< Results of operation returned here
         COMBINERESULT& CombineResult
         );
         
      //! Remove redundant and overlapping intersection entries from INTERSECTINFO.    
      void IntersectClean (
         INTERSECTINFO& IntsInfo
         ) const;
         
      //! Search for intersections against itself.  Intersection information is stored in the INTERSECTINFO
      //! Uses the "Section" and "Extent" optimizations
      ERRVALUE IntersectSearch (
         INTERSECTINFO& IntsInfo,
         double threshold
         ) const;
         
      //! Search for intersections against another line.  Intersection information is stored in the INTERSECTINFO instance.  
      //! If information already exists in the INTERSECTINFO, any new intersection information will be appended.
      //! Uses the "Section" and "Extent" optimizations
      ERRVALUE IntersectSearch (
         INTERSECTINFO& IntsInfo,
         const POLYLINE& OtherLine,
         INTERSECTINFO* OtherIntsInfo,                //!< Optional, used if you want to keep intersection info about "OtherLine'
         double threshold
         ) const;
         
      //! Split the line according to the INTERSECTINFO information.
      ERRVALUE IntersectSplitLine (
         INTERSECTINFO& IntsInfo,
         SPLIT& SplitInfo,                            //!< Callback base class for line splitting
         double threshold,
         bool CallBadSegment = false                  //!< Set to true if an intersection causes invalid lines to be generated
         ) const;
         
      //! Check if the line is marked closed
      //! @return: True if the line is marked closed
      bool IsClosed (
         ) const {return (m_LineClosed);}

      //! Determine if the two lines are exactly equal 
      //! This method uses "Exact" point comparisons
      //! @return 'True' if they are, 'False' if not
      bool IsEqual (
         const POLYLINE& rhs
         ) const;

      //! Determine if the two lines are equivalent 
      //! This method uses "Fuzzy" point comparisons and the direction of the lines are not relevant
      //! @return 'True' if they are, 'False' if not
      bool IsEquivalentTo (
         const POLYLINE& rhs,
         double threshold = 0.0
         ) const;

      //! Check if the point is inside the polygon
      //! Uses the "Strip" optimization if exists
      //! @return: True if the point is in, False if not or the line is not closed
      bool IsPointInside (
         const DPOINT2D& pt                  //!< Point to check
         ) const;

      //! Returns true if the POLYLINE describes a simple, unrotated rectangle
      bool IsRectangle (
         ) const;
      
      //! Move a vertex by some dx,dy
      //! If FixedVertex1 and/or FixedVertex2 are specified, all points
      //! between the vertex being moved and the fixed verticies will also
      //! be moved by an ammount inversely proportional to their distance
      //! from the vertex being moved.
      //! If you specify two fixed verticies, one had better be less than
      //! index and one greater than index or you will get weird results.
      //! Also, specifying a FixedVertex which is just index +/- 1 is the
      //! same as not specifying it.
      void MoveVertex (
         int index,              //!< Vertex to move
         const DPOINT2D& delta,  //!< Move distance
         int FixedVertex1 = -1,  //!< Vertex to keep in place
         int FixedVertex2 = -1   //!< Vertex to keep in place
         );

      //! Remove duplicate and colinear points along the line
      void RemoveDuplicates (
         double thresh = 0.0,                //!< Threshold value to test for same point or colinear point
         bool KeepEndPoints = false
         );

      //! Reserve space for given number of points    
      //! The POLYLINE::operator=() will not use the reserved buffer, 
      //! call POLYLINE::Clear() then POLYLINE::operator+=() or POLYLINE::Append() to use the reserved buffer.
      ERRVALUE Reserve (
         INT32 NumPoints
         );
         
      //! Reverse the vertices of the line
      //! This method will retain the "Extents" and "Orientation" optimizations
      void Reverse (
         );

      //! Close or open the line
      //! Will add closure point if set to 'true'
      void SetClosed (
         bool closed
         );
         
      //! Set line dimension from 2D->3D or 3D->2D          
      ERRVALUE SetDimension (
         DIMENSION dimension
         );
         
      //! Set polygon orientation
      //! Uses the "Orientation" optimization
      void SetOrientation (
         ORIENTATION Orientation
         );

      //! Set the precision of the coordinates in the POLYLINE
      //! 'Precision' is the number of decimal places to keep, '0' for precision of whole numbers, < '0' for the left of the decimal point,
      //! > '0' for right of the decimal point
      void SetPrecision (
         int Precision
         );
         
      //! Setup the "Extent" optimization.
      //! Used mostly for Compare...() methods and to setup the "Strip" optimization
      void SetupExtentOptimization (
         const DRECT2D& Extents
         ) const;