vector.h

Go to the documentation of this file.

/**
 * \file rvc/vector.h 
 * \brief interface for the RVC::VECTOR class.
 *
 * \if NODOC
 * $Id: vector.h_v 1.106 2004/11/10 21:37:23 scowan Exp $
 *
 * $Log: vector.h_v $
 * Revision 1.106  2004/11/10 21:37:23  scowan
 * Added threshold parms to is equiv methods.
 *
 * Revision 1.105  2004/10/27 21:15:41  scowan
 * Added new private method to read label baseline.
 *
 * Revision 1.104  2004/09/08 17:06:50  scowan
 * No real change.
 *
 * Revision 1.103  2004/08/24 22:26:27  scowan
 * Added virtual methods to get and set total line length.
 *
 * Revision 1.102  2004/07/19 17:03:22  scowan
 *  Moved has min elem filter to geometric class.
 *
 * Revision 1.101  2004/07/14 21:13:40  scowan
 * Removed legacy forward declaration.
 *
 * Revision 1.100  2004/07/12 23:21:44  scowan
 * Removed use of geo region.
 *
 * Revision 1.99  2004/06/01 22:25:01  scowan
 * Added cad and region extract to methods.
 *
 * Revision 1.98  2004/05/28 20:35:48  scowan
 * Added new virtual method override.
 *
 * Revision 1.97  2004/03/20 18:24:13  scowan
 *  Added find closest elements override.
 *
 * Revision 1.96  2004/03/17 21:31:34  scowan
 * Added new label get extents method.
 *
 * Revision 1.95  2004/03/01 17:49:31  scowan
 * Added docs.
 *
 * Revision 1.94  2004/02/23 20:06:48  scowan
 * Make get obj filter derived class inherit publically.
 *
 * Revision 1.93  2004/02/10 23:12:57  scowan
 * Added makeparm ctor.
 *
 * Revision 1.92  2004/02/10 17:00:02  scowan
 * Added two new add methods.
 *
 * Revision 1.91  2004/02/06 21:54:34  scowan
 * Fixed warning.
 *
 * Revision 1.90  2004/01/08 22:53:30  scowan
 * Fixed op enum issue.
 *
 * Revision 1.89  2003/12/04 21:18:08  scowan
 * Added compare helper methods.
 *
 * Revision 1.88  2003/11/25 17:14:14  scowan
 * Added method to equate two vector objects..
 *
 * Revision 1.87  2003/11/21 22:17:12  scowan
 * Support new Capabilities system.
 *
 * Revision 1.86  2003/10/21 21:59:30  scowan
 * Added more filters.
 *
 * Revision 1.85  2003/10/10 23:01:05  scowan
 * Added filter.
 *
 * Revision 1.84  2003/10/07 19:43:43  scowan
 * nc.
 *
 * Revision 1.83  2003/10/07 17:30:04  scowan
 * Object virtual method changes.
 *
 * Revision 1.82  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.81  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.80  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.79  2003/08/27 21:26:25  scowan
 * Uses new rvc vector class interface and handle.
 *
 * Revision 1.78  2003/06/19 17:46:22  scowan
 * Added virtual method.
 *
 * Revision 1.77  2003/06/04 23:35:19  scowan
 * Added find element draw set.
 *
 * Revision 1.76  2003/05/12 23:33:25  scowan
 * Changes to virtual methods.
 *
 * Revision 1.75  2003/05/07 22:20:55  scowan
 * Changed virtual method format.
 *
 * Revision 1.74  2003/03/11 21:38:17  scowan
 * Changed label get extents to use 3d rect.
 *
 * Revision 1.73  2003/03/04 21:04:44  scowan
 * Changed to default to no element ID tables.
 *
 * Revision 1.72  2003/02/19 20:14:05  scowan
 * Something, I do not know what.
 *
 * Revision 1.71  2003/02/11 00:06:27  scowan
 * More const.
 *
 * Revision 1.70  2003/01/16 23:00:53  scowan
 * Added bool value to the class.
 *
 * Revision 1.69  2002/12/23 20:30:28  scowan
 * *** empty log message ***
 *
 * Revision 1.68  2002/11/07 16:58:32  scowan
 * Added optimize to method.
 *
 * Revision 1.67  2002/10/29 16:57:25  scowan
 * Changed method name.
 *
 * Revision 1.66  2002/10/23 14:56:56  scowan
 * Re-enable subregion and region reading code.
 *
 * Revision 1.65  2002/10/18 14:29:02  scowan
 * Comment out region code until I get it working again.
 *
 * Revision 1.64  2002/10/18 13:48:04  scowan
 * Damn mac compiler..
 *
 * Revision 1.63  2002/10/11 16:59:50  scowan
 * Uses bitset unwoned for read region.
 *
 * Revision 1.62  2002/10/11 16:45:12  scowan
 * Added read subregion and region.
 *
 * Revision 1.61  2002/10/07 23:23:27  scowan
 * Added another field.
 *
 * Revision 1.60  2002/10/07 17:39:55  scowan
 * More comment changes.
 *
 * Revision 1.59  2002/10/07 15:55:25  scowan
 * Fixed docs.
 *
 * Revision 1.58  2002/10/04 21:18:29  scowan
 * Added elem iterator decrement operator.
 * Added protected methods.
 *
 * Revision 1.57  2002/10/01 22:43:44  scowan
 * Another protected metod.
 *
 * Revision 1.56  2002/10/01 21:37:01  scowan
 * Added protected method.
 *
 * Revision 1.55  2002/09/30 23:22:12  scowan
 * Made element search code const.
 *
 * Revision 1.54  2002/09/18 15:41:05  scowan
 * Added clip polygon method.
 *
 * Revision 1.53  2002/09/18 14:31:52  scowan
 * Added comments.
 *
 * Revision 1.52  2002/09/17 22:49:03  scowan
 * More virtual method adjustment.
 *
 * Revision 1.51  2002/09/03 22:18:24  scowan
 * More virtual method moves.
 *
 * Revision 1.50  2002/08/29 22:13:16  scowan
 * Virtual metho adjustment.
 *
 * Revision 1.49  2002/08/19 15:09:11  scowan
 * Added finding text style object method.
 *
 * Revision 1.48  2002/06/21 15:14:43  scowan
 * SOme const changes.
 *
 * Revision 1.47  2002/06/21 14:46:08  scowan
 * Transfer node attributes correctly.
 *
 * Revision 1.46  2002/06/19 22:24:05  scowan
 * More method changes.
 *
 * Revision 1.45  2002/06/19 14:55:50  scowan
 * Made more methods const.
 *
 * Revision 1.44  2002/06/18 22:15:16  scowan
 * Added extract interface.
 *
 * Revision 1.43  2002/05/01 17:43:25  scowan
 * Added prototype.
 *
 * Revision 1.42  2002/04/30 22:30:52  scowan
 * Added max label method.
 *
 * Revision 1.41  2002/04/30 17:34:02  scowan
 * Change base make parm class name.
 *
 * Revision 1.40  2002/04/30 14:03:04  scowan
 * More const.
 *
 * Revision 1.39  2002/04/26 22:45:01  scowan
 * Added more virtual methods.
 *
 * Revision 1.38  2002/03/13 23:28:28  scowan
 * Added label to not be attached to elements, according to Merri.
 *
 * Revision 1.37  2002/03/01 16:19:16  scowan
 * Added virtual methods.
 *
 * Revision 1.36  2002/02/27 23:24:34  scowan
 * Added get element extents methods.
 *
 * Revision 1.35  2002/02/27 16:55:09  scowan
 * Added Add method for leader lines.
 *
 * Revision 1.34  2002/02/07 14:57:21  scowan
 * Added style index method.
 *
 * Revision 1.33  2002/02/04 20:58:27  scowan
 * Added conglomerate line reader.
 *
 * Revision 1.32  2002/01/08 17:52:14  scowan
 * Added template makeparm constructor.
 *
 * Revision 1.31  2002/01/08 17:01:46  scowan
 * Removed rvc prefix for nested classes while in rvc namespace.
 *
 * Revision 1.30  2002/01/03 23:01:17  scowan
 * Added mnethods for labels and extents.
 * Moved classes around for genator docs.
 *
 * Revision 1.29  2001/10/08 20:49:47  scowan
 * Added element region method.
 *
 * Revision 1.28  2001/10/02 14:43:16  scowan
 * Disable error position code when iterating.
 *
 * Revision 1.27  2001/09/28 15:01:39  scowan
 * Added extents settings to the makeparm class.
 *
 * Revision 1.26  2001/09/27 21:43:28  scowan
 * Finish adding flags.
 *
 * Revision 1.25  2001/09/27 21:40:47  scowan
 * *** empty log message ***
 *
 * Revision 1.24  2001/09/27 21:39:29  scowan
 * Updated with vector flags.
 *
 * Revision 1.23  2001/09/06 22:16:26  scowan
 * *** empty log message ***
 *
 * Revision 1.22  2001/07/31 16:40:31  scowan
 * Added new interface methods.
 *
 * Revision 1.21  2001/07/16 16:46:26  scowan
 * Added generate island shell list.
 *
 * Revision 1.20  2001/06/21 16:30:09  scowan
 * Added methods to get and saet label description.;
 *
 * Revision 1.19  2001/06/18 15:48:01  scowan
 * Added more settings for MAKEPARMS class.
 *
 * Revision 1.18  2001/06/14 16:08:11  scowan
 * Changed source type.
 *
 * Revision 1.17  2001/06/13 22:24:13  scowan
 * Added to RVC namespace.
 *
 * Revision 1.16  2001/06/13 15:14:38  scowan
 * Changed objtype enum.
 * New make method.
 *
 * Revision 1.15  2001/06/12 15:40:31  scowan
 * Added comments.
 *
 * Revision 1.14  2001/06/05 15:12:28  scowan
 * Added typedef for label leader line lists.
 *
 * Revision 1.13  2001/06/01 14:35:15  scowan
 * Added point in polygon method.
 *
 * Revision 1.12  2001/05/25 19:26:12  scowan
 * *** empty log message ***
 *
 * Revision 1.11  2001/05/24 17:37:27  scowan
 * Added virtual methods for finding objects.
 *
 * Revision 1.10  2001/04/23 22:52:16  scowan
 * Added find closest methods.
 *
 * Revision 1.9  2001/04/23 17:46:06  scowan
 * Added update extents.
 *
 * Revision 1.8  2001/04/23 15:23:48  scowan
 * Added set element id valie methods.
 *
 * Revision 1.7  2001/04/20 16:29:51  scowan
 * Add methods for vector flags.
 *
 * Revision 1.6  2000/12/01 16:00:22  scowan
 * Fixed MAC errors.
 *
 * Revision 1.5  2000/11/29 15:29:43  scowan
 * Added more methods.
 *
 * Revision 1.4  2000/11/24 22:53:43  scowan
 * Added set extents virtual method.
 *
 * Revision 1.3  2000/11/24 21:08:30  scowan
 * Added method to read vector label header style link information.
 *
 * Revision 1.2  2000/10/19 21:17:55  scowan
 * Checked in for vacation.
 *
 * Revision 1.1  2000/10/02 17:40:07  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::VECTOR rvc/vector.h
//!   \brief Manages RVC::OBJTYPE_Vector RVC objects.  
//!   The interface currently wraps the MfVector functions.
//!   
//!   RVC Object Types that this class supports: RVC::OBJTYPE_Vector.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_Vector.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_File
//!      - RVC::OBJTYPE_Folder

#ifndef INC_RVC_VECTOR_H
#define INC_RVC_VECTOR_H

#ifndef INC_RVC_GEOMETRC_H
   #include <rvc/geometrc.h>
#endif

#ifndef INC_MI32_RVCVECT_H
   #include <mi32/rvcvect.h>
#endif

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

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

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

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

// Forward Declarations
class BITSET_UNOWNED;
class REGION2D;
class SUBREGION2D;
class TRANS2D_MAPGEN;

namespace RVC {

// Forward Declarations
class SPATIALTREE;
class STYLE;
class VECTORHANDLE;
class DBASE_ELEMENT;

class VECTOR : public GEOMETRIC {
   public:

      enum FLAGS {
         FLAG_None = 0,
         FLAG_NoStdAttribTables = 0x0001,
         FLAG_NoElementIDTables = 0x0002,
         FLAG_CannotReduceExtents = 0x0004,
         FLAG_CannotExpandExtents = 0x0008
         };

      enum TOPOLOGYTYPE {
         TOPOLOGYTYPE_Polygonal = 0,      //!< Vector object has polygons and full polygon-line-node topology
         TOPOLOGYTYPE_Planar,          //!< Vector object has no polygons and full line-node topology
         TOPOLOGYTYPE_Network,         //!< Vector object has no polygons and connected line-node topology
         TOPOLOGYTYPE_None          //!< Vector object has no topology, lines only
         };

      enum SUBTYPE {
         SUBTYPE_2DPolygonal = 0,
         SUBTYPE_2DPlanar,
         SUBTYPE_2DNetwork,
         SUBTYPE_3DPolygonal,
         SUBTYPE_3DPlanar,
         SUBTYPE_3DNetwork,
         SUBTYPE_3DNone
         };

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class CONGLOMERATELINEFILTER;
      class GETOBJFILTER_HASGEOMETRICELEMENTS;
      class GETOBJFILTER_HASLABELS;
      class GETOBJFILTER_HASLINES;
      class GETOBJFILTER_HASPOINTS;
      class GETOBJFILTER_HASPOLYGONS;
      class LABEL;
      class MAKEPARMS;
      #endif // GENERATING_DOXYGEN_OUTPUT

      //! Constant iterator class
      //!
      //! This class is used to iterate through a vector objects elements
      //! See methods ElementBegin() and ElementEnd() for obtaining an element iterator
      template <class _ELEM>  
      class ELEMITERATOR {
         public:

            //! Default constructor
            ELEMITERATOR (
               ) : 
               m_ElemNum(-1),
               m_CurrentObj(0)
               {}

            //! Idiot constructor for G++
            ELEMITERATOR (
               int WorthlessValue
               ) : 
               m_ElemNum(-1),
               m_CurrentObj(0)
               {}

            //! Internal constructor used by ElementEnd() methods
            ELEMITERATOR (
               const RVC::VECTOR* vector,
               INT32 ElemNum
               ) : 
               m_ElemNum(ElemNum),
               m_CurrentObj(vector)
               {}

            //! Copy constructor
            ELEMITERATOR (
               const ELEMITERATOR<_ELEM>& rhs
               ) : 
               m_ElemNum(rhs.m_ElemNum),
               m_CurrentObj(rhs.m_CurrentObj),
               m_Element(rhs.m_Element)
               {}

            //! Internal constructor used by ElementBegin() methods
            ELEMITERATOR (
               const RVC::VECTOR* vector
               ) :
               m_ElemNum(-1),
               m_CurrentObj(vector)
               {
               ERRVALUE err = 0;
               do {           //! Scan to the first valid element
                  m_ElemNum ++;
                  ERRORPOSNDISABLE disable;
                  err = m_CurrentObj->Read(m_ElemNum, m_Element);
                  if (err < 0) m_ElemNum = -1;
                  } while (err >= 0 && !m_Element.IsValid());
               }

            //! Destructor
            virtual ~ELEMITERATOR (
               ) {}

            //! Assignment
            ELEMITERATOR<_ELEM>& operator= (
               const ELEMITERATOR<_ELEM>& rhs
               ) {
               if (this != &rhs) {
                  m_ElemNum = rhs.m_ElemNum;
                  m_CurrentObj = rhs.m_CurrentObj;
                  m_Element = rhs.m_Element;    //!< If LABEL, this can be expensive, so check first
                  }
               return (*this);
               }

            //! Dereference
            const _ELEM& operator* (
               ) const { return (m_Element); }

            //! Dereference arrow
            const _ELEM* operator-> (
               ) const { return (&**this); }

            //! Pre-increment
            ELEMITERATOR<_ELEM>& operator++ (
               ) {
               ERRVALUE err = 0;
               do {           //! Scan to the next valid element
                  m_ElemNum ++;
                  ERRORPOSNDISABLE disable;
                  err = m_CurrentObj->Read(m_ElemNum, m_Element);
                  if (err < 0) m_ElemNum = -1;
                  } while (err >= 0 && !m_Element.IsValid());
               return (*this);
               }        

            //! Pre-decrement
            ELEMITERATOR<_ELEM>& operator-- (
               ) {
               if (m_ElemNum < 0) return (*this);
               ERRVALUE err = 0;
               do {           //! Scan to the next valid element
                  m_ElemNum --;
                  ERRORPOSNDISABLE disable;
                  err = m_CurrentObj->Read(m_ElemNum, m_Element);
                  if (err < 0) m_ElemNum = -1;
                  } while (err >= 0 && !m_Element.IsValid());
               return (*this);
               }        

            //! Comparison for equality
            bool operator== (
               const ELEMITERATOR<_ELEM>& rhs
               ) const { return (m_ElemNum == rhs.m_ElemNum && m_CurrentObj == rhs.m_CurrentObj); }

            //! Comparison for inequality
            bool operator!= (
               const ELEMITERATOR<_ELEM>& rhs
               ) const { return (!(*this == rhs)); }
               
            INT32 GetElementNumber (
               ) const { return (m_ElemNum); }

         protected:
            INT32 m_ElemNum;
            const VECTOR *m_CurrentObj;
            _ELEM m_Element;
         };

      typedef ELEMITERATOR<LABEL> LABELITERATOR;
      typedef ELEMITERATOR<RVCVECTLINE> LINEITERATOR;
      typedef ELEMITERATOR<RVCVECTNODE> NODEITERATOR;
      typedef ELEMITERATOR<RVCVECTPOINT> POINTITERATOR;
      typedef ELEMITERATOR<RVCVECTPOLY> POLYGONITERATOR;
      
      //! Default constructor
      VECTOR (
         );

      //! Copy constructor
      VECTOR (
         const RVC::VECTOR& rhs
         );

      //! Destructor
      virtual ~VECTOR (
         );

      //! Assignment, will close and re-open object if possible
      RVC::VECTOR& operator= (
         const RVC::VECTOR& rhs
         );

      //! Add a label to the vector object
      //! @return Number of the added label element or < 0 if error
      INT32 Add (
         LABEL& label
         );

      //! Add a line to the vector object
      //! @return Number of the added line element or < 0 if error
      INT32 Add (
         const RVCVECTLINE& line
         );

      //! Add a node to the vector object
      //! @return Number of the added node element or < 0 if error
      INT32 Add (
         const RVCVECTNODE& node
         );

      //! Add a point to the vector object
      //! @return Number of the added point element or < 0 if error
      INT32 Add (
         const RVCVECTPOINT& point
         );

      //! Add a polygon to the vector object
      //! @return Number of the added polygon element or < 0 if error
      INT32 Add (
         const RVCVECTPOLY& polygon
         );
         
      //! Add a line to the vector object from a POLYLINE
      //! Will correctly set the RVCVECTLINE and update the extents of the vector
      //! Will not add nodes nor correct topology
      //! @return Number of the added line element or < 0 if error
      INT32 AddLine (
         const POLYLINE& PolyLine
         );
         
      //! Add a polygon to the vector object
      //! Will correctly set the RVCVECTPOLY and update the extents of the vector
      //! Will add the line and set RVCVECTLINE correctly
      //! Will not add nodes nor correct topology
      //! 'PolyLine' element MUST be closed, or an error is returned
      //! @return Number of the added polygon element or < 0 if error
      INT32 AddPolygon (
         const POLYLINE& Polygon
         );
         
      //! Mark an element as deleted
      ERRVALUE DeleteElement (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
      //! Obtain an element iterator to the beginning of the element list
      template <class _ELEM> ELEMITERATOR<_ELEM> ElementBegin (
         ELEMITERATOR<_ELEM> item
         ) const {
         return (ELEMITERATOR<_ELEM>(this));
         }

      //! Obtain an element iterator to the end of the element list
      template <class _ELEM> ELEMITERATOR<_ELEM> ElementEnd (
         ELEMITERATOR<_ELEM> item
         ) const {
         return (ELEMITERATOR<_ELEM>(this, -1));
         }

      //! Locate label style object referenced by 'this'
      //! 'StyleObj' will be attached if one is found, unattached if not
      ERRVALUE FindLabelStyleObject (
         RVC::STYLE& StyleObj
         ) const;

      //! Generate the list of islend shell lines for a specific polygon
      ERRVALUE GenerateIsleShellList (
         INT32 ParentPolygon,                //!< Parent polygon, -1 for external polygon shell list
         ORIENTATION orient,
         SIMPLE_ARRAY<INT32>& NumShellLines,
         SIMPLE_ARRAY<INT32>& ShellList,
         SIMPLE_ARRAY<DRECT2D>* RectList = 0
         ) const;
      
      //! Generate a point inside of a polygon     
      ERRVALUE GeneratePointInPolygon (
         INT32 PolyNum,
         DPOINT2D& PointInPoly
         ) const;
         
      //! Get vector object flags
      //! @return VECTOR::FLAGS
      RVC::VECTOR::FLAGS GetFlags (
         ) const;

      //! Obtain style object refered to by the label header
      ERRVALUE GetLabelStyleInfo (
         FILEPATH& filepath, 
         RVC::OBJECTNAME& StyleName
         ) const;

      //! Get MAKEPARM values from current vector object instance       
      ERRVALUE GetMakeParms (
         RVC::VECTOR::MAKEPARMS& MakeParms
         ) const;
         
      //! Obtain maximum number of islands in a polygon
      //! @return Maximum number of islands
      INT32 GetMaxIslands (
         ) const;

      //! Obtain maximum length of a label string
      //! @return Maximum length of a label string
      INT32 GetMaxLabelStringLength (
         ) const;

      //! Obtain maximum number of lines in a polygon or node line list
      //! @return Maximum number of lines
      INT32 GetMaxLines (
         ) const;

      //! Obtain the maximum number of points a line has
      //! @return Maximum number of points in a line
      INT32 GetMaxPoints (
         ) const;

      //! Obtain next available line ID for line ID table
      //! @return Next available line ID
      INT32 GetNextLineID (
         ) const;

      //! Obtain next available point ID for point ID table
      //! @return Next available point ID
      INT32 GetNextPointID (
         ) const;

      //! Obtain next available polygon ID for polygon ID table
      //! @return Next available polygon ID
      INT32 GetNextPolygonID (
         ) const;

      //! Obtain number of labels in the vector object
      //! @return Number of labels
      INT32 GetNumLabels (
         ) const;

      //! Obtain number of points in a line
      //! @return Number of line points
      INT32 GetNumLinePoints (
         INT32 LineNum
         ) const;

      //! Obtain number of lines in the vector object
      //! @return Number of lines
      INT32 GetNumLines (
         ) const;

      //! Obtain number of lines in a node
      //! @return Number of node lines
      INT32 GetNumNodeLines (
         INT32 NodeNum
         ) const;

      //! Obtain number of nodes in the vector object
      //! @return Number of nodes
      INT32 GetNumNodes (
         ) const;

      //! Obtain number of points in the vector object
      //! @return Number of points
      INT32 GetNumPoints (
         ) const;

      //! Obtain number of polygons in the vector object
      //! @return Number of polygons
      INT32 GetNumPolygons (
         ) const;

      //! Obtain number of islands in a polygon
      //! @return Number of polygon islands
      INT32 GetNumPolyIslands (
         INT32 PolyNum
         ) const;

      //! Obtain number of lines in a polygon
      //! @return Number of polygon lines
      INT32 GetNumPolyLines (
         INT32 PolyNum
         ) const;

      //! Obtain vector sub-type
      //! @return Vector object subtype
      SUBTYPE GetSubType (
         ) const;

      //! Obtain vector topology type for vector
      //! @return vector RVC::VECTOR::TOPOLOGYTYPE
      TOPOLOGYTYPE GetTopologyType (
         ) const;

      //! Obtain limit on the maximum number of vertices a line can have
      //! @return Maximum number of verticies
      INT32 GetVertexLimit (
         ) const;

      //! Determine if we are able to generate element ID tables for the vector object
      bool IsElementIDTablesValid (
         ) const;

      //! Determine if the two vector objects are equivalent 
      //! This method uses "Fuzzy" vertex comparisons and the direction and order of the elements are not relevant
      //! @return 'True' if they are, 'False' if not
      bool IsEquivalentTo (
         const VECTOR& rhs,
         double threshold
         ) const;

      //! Is this point inside the vector polygon specified    
      bool IsPointInPolygon (
         INT32 PolyNum,
         const DPOINT2D& point
         ) const;
         
      //! Determine if we are able to generate standard attribute tables for the vector object
      bool IsStdAttribTablesValid (
         ) const;
      
      //! Create new vector object given parent object, name, description, creation parameters, and source
      ERRVALUE Make (
         const RVC::OBJECT& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );
      
      //! Create new vector object given parent object, name, description, creation parameters, and source
      ERRVALUE Make (
         const RVC::OBJITEM& ObjItem,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );
         
      //! Optimize vector object
      ERRVALUE OptimizeTo (
         RVC::OBJECT& DestParentObj,         //!< Parent object to optimize vector object and copy children to
         RVC::VECTOR& DestVectObj            //!< Destination vector object RETURNED
         );
      
      //! Read a vector label given a label number
      ERRVALUE Read (
         INT32 LabelNum,
         LABEL& vlabel
         ) const;

      //! Read a vector line header given a line number
      ERRVALUE Read (
         INT32 LineNum,
         RVCVECTLINE& vline
         ) const;

      //! Read a vector node given a node number
      ERRVALUE Read (
         INT32 NodeNum,
         RVCVECTNODE& vnode
         ) const;

      //! Read a vector point given a point number
      ERRVALUE Read (
         INT32 PointNum,
         RVCVECTPOINT& vpoint
         ) const;

      //! Read a vector polygon given a polygon number
      ERRVALUE Read (
         INT32 PolyNum,
         RVCVECTPOLY& vpoly
         ) const;
         
      ERRVALUE ReadConglomerateLinePoints (
         INT32 StartLineNum,
         POLYLINE& ConglomerateLine,
         CONGLOMERATELINEFILTER& filter
         ) const;
         
      //! Read a vector line point
      ERRVALUE ReadLinePoint (
         INT32 LineNum,
         INT32 PointNum,
         DPOINT3D& point
         ) const;

      //! Read a vector line point list using the vector POINTYPE into a POLYLINE
      //! The DIMENSION of the POLYLINE will be set to the DIMENSION of the vector object
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         POLYLINE& LinePoints
         ) const;

      //! Read a vector line point list using the vector POINTYPE into a POLYLINE
      //! Define 'dimension' to get 2D or 3D lines
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         POLYLINE& LinePoints,
         DIMENSION dimension
         ) const;

      //! Read a partial vector line point list into a POLYLINE
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         INT32 Start,
         INT32 Length,
         POLYLINE& LinePoints
         ) const;

      //! Read a partial vector line point list into a POLYLINE
      //! Define 'dimension' to get 2D or 3D lines
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         INT32 Start,
         INT32 Length,
         POLYLINE& LinePoints,
         DIMENSION dimension
         ) const;

      //! Read a partial vector line point list into a POLYLINE
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         INT32 Start,
         INT32 Length,
         DPOINT2D *pts
         ) const;

      //! Read a partial vector line point list into a POLYLINE
      //! Will set the "Extents" optimization in the POLYLINE
      //! @return Number of points read or error if < 0
      INT32 ReadLinePoints (
         INT32 LineNum,
         INT32 Start,
         INT32 Length,
         DPOINT3D *pts
         ) const;

      //! Read a vector node line list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadNodeLines (
         INT32 NodeNum,
         SIMPLE_ARRAY<INT32>& LineList
         ) const;

      //! Read a partial vector node line list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadNodeLines (
         INT32 NodeNum,
         INT32 Start,
         INT32 Length,
         SIMPLE_ARRAY<INT32>& LineList
         ) const;

      //! Read a vector polygon line list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadPolyLines (
         INT32 PolyNum,
         SIMPLE_ARRAY<INT32>& LineList
         ) const;

      //! Read a partial vector polygon line list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadPolyLines (
         INT32 PolyNum,
         INT32 Start,
         INT32 Length,
         SIMPLE_ARRAY<INT32>& LineList
         ) const;

      //! Read a vector polygon island list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadPolyIslands (
         INT32 PolyNum,
         SIMPLE_ARRAY<INT32>& IsleList
         ) const;

      //! Read a partial vector polygon island list into a SIMPLE_ARRAY<INT32>
      ERRVALUE ReadPolyIslands (
         INT32 PolyNum,
         INT32 Start,
         INT32 Length,
         SIMPLE_ARRAY<INT32>& IsleList
         ) const;
      
      //! Read a vector polygon point list using the vector POINTYPE into a POLYLINE
      //! Will set the "Extents" and "Orientation" optimizations in the POLYLINE
      //! Define 'dimension' to get 2D or 3D lines
      ERRVALUE ReadPolyPoints (
         INT32 PolyNum,
         POLYLINE& LinePoints,
         DIMENSION dimension
         ) const;

      //! Read a set of vector polygon and possibly its islands into a REGION2D
      ERRVALUE ReadRegion (
         const BITSET_UNOWNED& PolySet,   //!< Set of polygons to generate region from
         REGION2D& Region,                //!< Region to set
         DIMENSION dim,
         BITSET* LineSet = 0,             //!< Set of lines that made up the region, can be NULL
         bool NoIslands = false           //!< 'True' of no islands wanted
         ) const;
   
      //! Read a set of vector polygon and possibly its islands into a REGION2D
      ERRVALUE ReadRegion (
         const BITSET_UNOWNED& PolySet,   //!< Set of polygons to generate region from
         REGION2D& Region,                //!< Region to set
         BITSET* LineSet = 0,             //!< Set of lines that made up the region, can be NULL
         bool NoIslands = false           //!< 'True' of no islands wanted
         ) const;
   
      //! Read a vector polygon and possibly its islands into a SUBREGION2D
      ERRVALUE ReadSubRegion (
         INT32 PolyNum,          //!< Polygon to generate region from
         SUBREGION2D& SubRegion,
         DIMENSION dim,
         bool NoIslands = false
         ) const;
         
      //! Read a vector polygon and possibly its islands into a SUBREGION2D
      ERRVALUE ReadSubRegion (
         INT32 PolyNum,          //!< Polygon to generate region from
         SUBREGION2D& SubRegion,
         bool NoIslands = false
         ) const;
         
      //! Set vector object flags
      ERRVALUE SetFlags (
         RVC::VECTOR::FLAGS flags
         );

      //! Set style object refered to by the label header
      ERRVALUE SetLabelStyleInfo (
         const FILEPATH& filepath, 
         const RVC::OBJECTNAME& StyleName
         );
         
      //! Set next available line ID for line ID table
      ERRVALUE SetNextLineID (
         INT32 NewValue
         );
      
      //! Set next available point ID for point ID table
      ERRVALUE SetNextPointID (
         INT32 NewValue
         );
      
      //! Set next available polygon ID for polygon ID table
      ERRVALUE SetNextPolygonID (
         INT32 NewValue
         );
      
      //! Set vector object point coordinate type
      ERRVALUE SetPointType (
         POINTTYPE PointType
         );

      //! Set vector topology type
      ERRVALUE SetTopologyType (
         TOPOLOGYTYPE TopologyType
         );
            
      //! Set vector line vertex limit
      ERRVALUE SetVertexLimit (
         INT32 MaxVertices
         );
            
      //! Write a vector label given a label number
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 LabelNum,
         LABEL& vlabel
         );

      //! Write a vector line given a line number
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 LineNum,
         const RVCVECTLINE& vline
         );

      //! Write a vector node given a node number
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 NodeNum,
         const RVCVECTNODE& vnode
         );

      //! Write a vector point given a point number
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 PointNum,
         const RVCVECTPOINT& vpoint
         );

      //! Write a vector polygon given a polygon number
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 PolyNum,
         const RVCVECTPOLY& vpoly
         );

      //! Write a vector line point
      //! Does not update element nor object extents
      ERRVALUE WriteLinePoint (
         INT32 LineNum,
         INT32 vertex,
         const DPOINT3D& point
         );

      //! Write a vector line point list
      //! Does not update element nor object extents
      //! @return Number of line points written or error if < 0
      INT32 WriteLinePoints (
         INT32 LineNum,
         const POLYLINE& PointList
         );

      //! Write a partial vector line point list
      //! Does not update element nor object extents
      //! @return Number of line points written or error if < 0
      INT32 WriteLinePoints (
         INT32 LineNum,
         INT32 Start,
         INT32 Length,
         const POLYLINE& PointList
         );

      //! Write a vector node line list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of node lines written or error if < 0
      INT32 WriteNodeLines (
         INT32 NodeNum,
         const SIMPLE_ARRAY<INT32>& LineList
         );

      //! Write a partial vector node line list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of node lines written or error if < 0
      INT32 WriteNodeLines (
         INT32 NodeNum,
         INT32 NumLines,
         INT32 Start,
         INT32 Length,
         const SIMPLE_ARRAY<INT32>& LineList
         );

      //! Write a vector polygon line list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of polygon lines written or error if < 0
      INT32 WritePolyLines (
         INT32 PolyNum,
         const SIMPLE_ARRAY<INT32>& LineList
         );

      //! Write a partial vector polygon line list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of polygon lines written or error if < 0
      INT32 WritePolyLines (
         INT32 PolyNum,
         INT32 NumLines,
         INT32 Start,
         INT32 Length,
         const SIMPLE_ARRAY<INT32>& LineList
         );

      //! Write a vector polygon island list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of polygon islands written or error if < 0
      INT32 WritePolyIslands (
         INT32 PolyNum,
         const SIMPLE_ARRAY<INT32>& IsleList
         );

      //! Write a partial vector polygon island list from a SIMPLE_ARRAY<INT32>
      //! Does not update element nor object extents
      //! @return Number of polygon islands written or error if < 0
      INT32 WritePolyIslands (
         INT32 PolyNum,
         INT32 NumIslands,
         INT32 Start,
         INT32 Length,
         const SIMPLE_ARRAY<INT32>& IsleList
         );
         
   protected:

      ERRVALUE ClearLinePointList (
         );

      ERRVALUE ClearNodeLineList (
         );

      ERRVALUE ClearPolygonIslandList (
         );
         
      ERRVALUE ClearPolygonLineList (
         );
         
      ERRVALUE SetNumLabels (
         INT32 NewNumLabels
         );

      ERRVALUE SetNumLines (
         INT32 NewNumLines
         );

      ERRVALUE SetNumNodes (
         INT32 NewNumNodes
         );

      ERRVALUE SetNumPoints (
         INT32 NewNumPolygons
         );

      ERRVALUE SetNumPolygons (
         INT32 NewNumPolygons
         );
         
      ERRVALUE SwapLinePoints (
         INT32 Line1,
         INT32 Line2
         );

      ERRVALUE SwapNodeLines (
         INT32 Node1,
         INT32 Node2
         );

      ERRVALUE SwapPolyIslands (
         INT32 Poly1,
         INT32 Poly2
         );

      ERRVALUE SwapPolyLines (
         INT32 Poly1,
         INT32 Poly2
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      ERRVALUE ExtractLabelsTo (VECTOR& DestObj, const GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg) const;
      ERRVALUE ExtractLinesTo (VECTOR& DestObj, GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractNodesTo (VECTOR& DestObj, const GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractPointsTo (VECTOR& DestObj, GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractPolygonsTo (VECTOR& DestObj, const GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;

      ERRVALUE ExtractToCAD (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToRegion (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      ERRVALUE ExtractToVector (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      
      INT32 FindBestRgnLine (SIMPLE_ARRAY<INT32>& TestList, INT32 LineNum, INT32 NodeNum) const;
      ERRVALUE ReadLabelBaselinePoints (INT32 LabelNum, POLYLINE& Baseline, DIMENSION dim, double Height) const;
      int SetupLabelTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      int SetupLineTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, BITSET& LineSet, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      int SetupPointTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      int SetupPolygonTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, BITSET& LineSet, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      int TestDatabaseEquivalence (const VECTOR& RhsVectObj, DBASE_ELEMENT& LhsDBaseobj, DBASE_ELEMENT& RhsDBaseobj, SIMPLE_ARRAY<INT32>& TableMatch) const;
         
      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);

      //! Implementation of RVC::GEOSPATIAL virtual methods
      virtual void v_GetExtents (DRECT3D &extents) const;
      virtual void v_GetScale (double& xscale, double& yscale) const;
      virtual double v_GetZScale () const;
      virtual double v_GetZOffset () const;
      virtual bool v_HasCapability (int Capability) const;
      virtual void v_SetScale (double xscale, double yscale);
      virtual void v_SetZOffset (double zoffset);
      virtual void v_SetZScale (double zscale);

      //! Implementation of RVC::GEOMETRIC virtual methods
      virtual ERRVALUE v_AddSearchTreeElement (INT32 elemnum, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_BuildSearchTree (INT32 InitialNumElements, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_ClearSearchTree (INT32 InitialNumElements, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_CopySearchTreeElement (INT32 SourceElement, INT32 DestElement, ELEMTYPE ElemType, const DRECT2D& Extents);
      virtual ERRVALUE v_DeleteSearchTreeElement (INT32 elemnum, ELEMTYPE ElemType);
      virtual ERRVALUE v_ExtractTo (RVC::GEOMETRIC& DestObj, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, const TRANS2D_MAPGEN& tmg, RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags) const;
      virtual INT32 v_FindClosestElementLow (ELEMTYPE ElemType, const DPOINT2D& SearchPt, GEOMETRIC::SEARCHFILTER* SearchFilter, double SearchDist, double* DistFromElem) const;
      virtual ERRVALUE v_FindClosestElementsLow (const DPOINT2D& SearchPt, double SearchDist, SEARCHFILTER* SearchFilter, SIMPLE_ARRAY<RVC::ELEMENT>& ElementList) const;
      virtual ERRVALUE v_FindElementDrawSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual ERRVALUE v_FindElementSearchSet (ELEMTYPE ElemType, const DRECT2D& SearchExtents, SEARCHRESULT& SearchResult) const;
      virtual INT32 v_GetAttachmentIndex (const RVC::ELEMENT& Element) const;
      virtual ERRVALUE v_GetElementExtents (ELEMTYPE ElemType, INT32 ElemNum, DRECT3D& Extents) const;
      virtual INT32 v_GetNextElementID (ELEMTYPE ElemType) const;
      virtual INT32 v_GetNumElements (ELEMTYPE ElemType) const;
      virtual POINTTYPE v_GetPointType () const;
      virtual INT32 v_GetPointSize () const;
      virtual double v_GetTotalLineLength () const;
      virtual bool v_IsElementDeleted (const RVC::ELEMENT& Element) const;
      virtual bool v_IsEmpty () const;
      virtual ERRVALUE v_SaveSearchTrees ();
      virtual ERRVALUE v_SetExtents (const DRECT3D &extents);
      virtual ERRVALUE v_SetNextElementID (ELEMTYPE ElemType, INT32 NextElementID);
      virtual bool v_SetSearchTree (ELEMTYPE ElemType, RVC::QSEARCHTREE* SearchTree, bool ReplaceExisting);
      virtual ERRVALUE v_SetTotalLineLength (double length);
      virtual int v_SetupElemTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      virtual bool v_TestElementAgainstRegion (const RVC::ELEMENT& Element, const REGION2D& region, TESTCRITERIA TestMode) const;
      virtual ERRVALUE v_UpdateExtents (const DRECT3D &extents);

      //! No values are unchangeable in header

      VECTORHANDLE* m_VectorHandle;
      POINTTYPE m_PointType;              //!< Changed when callback changes it
      TOPOLOGYTYPE m_TopologyType;        //!< Changed when callback changes it
      mutable QSEARCHTREE *m_LabelSearchTree;
      mutable QSEARCHTREE *m_LineSearchTree;
      mutable QSEARCHTREE *m_NodeSearchTree;
      mutable QSEARCHTREE *m_PointSearchTree;
      mutable QSEARCHTREE *m_PolySearchTree;
      mutable SPATIALTREE *m_SpatialTree;
      class OPTIMIZE;
      mutable OPTIMIZE* m_Optimize;
      mutable bool m_SetInstanceData;     //!< This object set the instance data if true, it needs to remove it on closing
      
      friend class LABEL;
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


class VECTOR::CONGLOMERATELINEFILTER {
   public:
      //! Virtual method to determine if the line is to be conglomerated
      virtual bool Filter (
         const VECTOR& VectObj,
         INT32 TestLineNum
         ) = 0;
   };


//! GETOBJFILTER derived class to determine if the vector object has points or lines or polygons to
//! perform geometric operations on.  The RVC::GEOMETRIC::ISNOTEMPTY class will let vector objects with
//! only label elements to be valid.
class VECTOR::GETOBJFILTER_HASGEOMETRICELEMENTS : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASGEOMETRICELEMENTS () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! GETOBJFILTER derived class to determine if the vector object has the minimum number of labels
class VECTOR::GETOBJFILTER_HASLABELS : public GEOMETRIC::GETOBJFILTER_HASMINIMUMELEMENTS {
   public:
      GETOBJFILTER_HASLABELS (
         INT32 MinLabels = 1
         ) : GETOBJFILTER_HASMINIMUMELEMENTS(ELEMTYPE_Label, MinLabels) {}
   };

//! GETOBJFILTER derived class to determine if the vector object has the minimum number of labels
class VECTOR::GETOBJFILTER_HASLINES : public GEOMETRIC::GETOBJFILTER_HASMINIMUMELEMENTS {
   public:
      GETOBJFILTER_HASLINES (
         INT32 MinLines = 1
         ) : GETOBJFILTER_HASMINIMUMELEMENTS(ELEMTYPE_Line, MinLines) {}
   };
   
//! GETOBJFILTER derived class to determine if the vector object has the minimum number of labels
class VECTOR::GETOBJFILTER_HASPOINTS : public GEOMETRIC::GETOBJFILTER_HASMINIMUMELEMENTS {
   public:
      GETOBJFILTER_HASPOINTS (
         INT32 MinPoints = 1
         ) : GETOBJFILTER_HASMINIMUMELEMENTS(ELEMTYPE_Point, MinPoints) {}
   };
   
//! GETOBJFILTER derived class to determine if the vector object has the minimum number of labels
class VECTOR::GETOBJFILTER_HASPOLYGONS : public GEOMETRIC::GETOBJFILTER_HASMINIMUMELEMENTS {
   public:
      GETOBJFILTER_HASPOLYGONS (
         INT32 MinPolygons = 1
         ) : GETOBJFILTER_HASMINIMUMELEMENTS(ELEMTYPE_Polygon, MinPolygons) {}
   };

//! Vector label class
class VECTOR::LABEL {
   public:
   
      class LEADERLINE {
         public:

            //! Default constructor
            LEADERLINE (
               );

            //! Copy constructor
            LEADERLINE (
               const LEADERLINE& rhs
               );

            //! Destructor
            ~LEADERLINE (
               );

            //! Assignment
            LEADERLINE& operator= (
               const LEADERLINE& rhs
               );

            INT32 GetElemNum (
               ) const {return (m_LeaderLine.ElemNum);}

            ELEMTYPE GetElemType (
               ) const {return (static_cast<ELEMTYPE>(m_LeaderLine.ElemType));}

            //! Determine extents of this leader line
            void GetExtents (
               DRECT3D& extents
               ) const;
               
            const POLYLINE& GetLeaderPoints (
               ) const {return (m_LeaderPts);}
               
            const DPOINT3D& GetTiePoint (
               ) const {return (m_LeaderLine.TiePoint);}

            //! Determine if the two label leader lines are equivalent 
            //! This method uses "Fuzzy" vertex comparisons and the direction and order of the elements are not relevant
            //! @return 'True' if they are, 'False' if not
            bool IsEquivalentTo (
               const LEADERLINE& rhs,
               double threshold
               ) const;

            void SetElemNum (
               INT32 ElemNum
               ) {m_LeaderLine.ElemNum = ElemNum;}

            void SetElemType (
               ELEMTYPE ElemType
               ) {m_LeaderLine.ElemType = static_cast<INT16>(ElemType);}

            void SetLeaderPoints (
               const POLYLINE& LeaderPts
               ) {m_LeaderPts = LeaderPts;}
               
            void SetTiePoint (
               const DPOINT3D& NewTiePoint
               ) {m_LeaderLine.TiePoint = NewTiePoint;}

            //! Translate label leader line through a generic coordinate transformation
            ERRVALUE Translate (
               const TRANS2D_MAPGEN& tmg
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            ERRVALUE Add (VECTORHANDLE* VectorHandle, INT32 LabelNum, INT32 NumLeaderLines, INT32 LeaderLineIndex);
            ERRVALUE Copy (const LEADERLINE& rhs);
            ERRVALUE Read (VECTORHANDLE* VectorHandle, INT32 LabelNum, INT32 LeaderLineNum);
            ERRVALUE Write (VECTORHANDLE* VectorHandle, INT32 LabelNum, INT32 NumLeaderLines, INT32 LeaderLineIndex);

            RVCLEADERLINE m_LeaderLine;
            RVCLABELSTYLE m_StyleIndex;
            POLYLINE m_LeaderPts;

            friend class LABEL;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      typedef MILIST<LEADERLINE>::ITERATOR LEADERLINEITERATOR;
      typedef MILIST<LEADERLINE>::CONST_ITERATOR CONST_LEADERLINEITERATOR;

      //! Default constructor
      LABEL (
         );

      //! Copy constructor
      LABEL (
         const LABEL& rhs
         );

      //! Destructor
      ~LABEL (
         );

      //! Assignment
      LABEL& operator= (
         const LABEL& rhs
         );

      //! Add a leader line to the label
      void AddLeaderLine (
         const LEADERLINE& LeaderLine
         );

      //! Clear the label of the string and base points and leader lines
      void Clear (
         );
         
      //! Clear the leader lines of the label
      void ClearLeaderLines (
         ) {m_LeaderLines.Clear();}
         
      //! Delete a leader line from the label
      void DeleteLeaderLine (
         MILIST<LEADERLINE>::ITERATOR it
         ) {m_Lead