rvc/vecttool.h

Go to the documentation of this file.

/****
*  \file rvc/vecttool.h
*  \brief Vector toolkit include file
*
*  \if NODOC
*  $Id: vecttool.h_v 1.67 2012/02/02 18:17:25 mju Exp $
*
*  $Log: vecttool.h_v $
*  Revision 1.67  2012/02/02 18:17:25  mju
*  Minor rearranging.
*
*  Revision 1.66  2011/12/28 14:25:21  mju
*  Remove redundant hdr.
*
*  Revision 1.64  2009/06/08 17:54:49  mju
*  Add polynum parm to SplitLineInPoly.
*
*  Revision 1.63  2009/04/07 17:01:14  mju
*  GetTable.
*
*  Revision 1.62  2008/03/27 21:29:28  scowan
*  Added node move method that takes a polyline list of lines.
*
*  Revision 1.59  2007/04/11 21:21:53  scowan
*  Add method to database element to get the table reference.
*
*  Revision 1.58  2007/03/09 18:04:48  scowan
*  Added open table array and extra dblist work buffer to database element subclass.
*
*  Revision 1.55  2006/07/27 19:27:02  scowan
*  Added build topology methods.
*
*  Revision 1.53  2006/06/15 16:33:31  scowan
*  Updated hyper index object changes.
*
*  Revision 1.52  2006/02/06 17:42:16  scowan
*  Added external support for building node line lists.
*
*  Revision 1.49  2006/01/13 23:32:35  scowan
*  Added point variants of qtree element management.
*
*  Revision 1.47  2005/10/20 17:01:40  scowan
*  Quadtree and geometric interface changes supported.
*
*  Revision 1.42  2004/09/14 22:09:09  scowan
*  Added validate flag to not build std attrib tables.
*
*  Revision 1.37  2004/02/04 21:44:30  scowan
*  Added panel for snap parms dialog.
*
*  Revision 1.36  2004/01/15 22:59:37  scowan
*  Added new clip to region methods.
*
*  Revision 1.25  2003/07/07 16:31:21  scowan
*  Added new observable option.
*
*  Revision 1.16  2003/01/17 20:13:28  scowan
*  Added methods to get the node database.
*
*  Revision 1.1  2001/09/18 13:56:22  scowan
*  Initial revision
*  \endif
****/

#ifndef  INC_RVC_VECTTOOL_H
#define  INC_RVC_VECTTOOL_H

#ifndef  INC_RVC_VECTOR_H
   #include <rvc/vector.h>
#endif

#ifndef  INC_RVC_HYPERINDEX_H
   #include <rvc/hyperidx.h>
#endif

#ifndef  INC_RVC_STYLE_H
   #include <rvc/style.h>
#endif

#ifndef  INC_RVC_MSTDATT_H
   #include <rvc/mstdatt.h>
#endif

#ifndef  INC_RVC_DBPOINT_H
   #include <rvc/dbpoint.h>
#endif

#ifndef  INC_RVC_DBNODE_H
   #include <rvc/dbnode.h>
#endif

#ifndef  INC_RVC_LIST_H
   #include <rvc/list.h>
#endif

#ifndef  INC_VECTOR
   #include <vector>
   #define INC_VECTOR
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class FILE_TEXT;
namespace RVC {
   class VECTORTOOLKITOBSERVER;
   }
#endif


namespace RVC {

class VECTORTOOLKIT : public SUBJECT<VECTORTOOLKITOBSERVER> {
   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class LINEELEMENT;
      #endif // GENERATING_DOXYGEN_OUTPUT
      
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class POLYGONDELETEFILTER;
      #endif // GENERATING_DOXYGEN_OUTPUT

      class SNAPOBJECT {
         public:
         
            SNAPOBJECT (
               );
               
            ~SNAPOBJECT (
               );
               
            const RVC::VECTOR& GetVectorObject (
               ) const { return (m_VectorObj); }
               
            const TRANS2D_MAPGEN& GetTransGen (
               ) const { return (m_VectorToObject); }
               
            bool IsSameAsEditor (
               ) const { return (m_SameAsEditor); }
               
            void SetValues (
               const VECTORTOOLKIT& vtk
               );
               
            void SetValues (
               const VECTOR& VectorObj,
               const TRANS2D_MAPGEN& VectorToObject
               );
               
         private:
         
            #ifndef GENERATING_DOXYGEN_OUTPUT
            bool m_SameAsEditor;
            VECTOR m_VectorObj;
            TRANS2D_MAPGEN m_VectorToObject;
            friend class VECTORTOOLKIT;
            friend class LINEELEMENT;
            
            SNAPOBJECT (const VECTORTOOLKIT& vtk);
               
            SNAPOBJECT& operator= (const SNAPOBJECT& rhs);
            #endif // GENERATING_DOXYGEN_OUTPUT
               
         };
      friend class SNAPOBJECT;
      
      class SNAPPARMS {
         public:
         
            class PANEL;

            enum SNAPTOELEM {
               SNAPTOELEM_AnyElement = 0,
               SNAPTOELEM_Line,
               SNAPTOELEM_Point,
               SNAPTOELEM_Node,
               SNAPTOELEM_Nothing,
               SNAPTOELEM_Vertex
               };

            enum SNAPTYPE {
               SNAPTYPE_AddVertexSnap = 0,
               SNAPTYPE_DirectSnap,
               SNAPTYPE_ContinueSnap
               };
               
            enum SNAPEND {
               SNAPEND_Both = 0,
               SNAPEND_Start,
               SNAPEND_End
               };
               
            SNAPPARMS (
               );
               
            bool CanCrossLines (
               ) const { return (!m_DontCrossLines); }

            bool CanRemoveOvershoots (
               ) const { return (m_RemOvershoots); }

            bool CanSnapToSelf (
               ) const { return (!m_DontSnapToSelf); }

            SNAPTOELEM GetElementSnap (
               ) const { return (m_SnapToElem); }

            UINT32 GetLegacyFlags (
               ) const;
               
            double GetSnapBackAngle (
               ) const { return (m_SnapBackAngle); }
               
            double GetSnapDist (
               ) const { return (m_SnapDist); }
               
            SNAPEND GetSnapEnd (
               ) const { return (m_SnapEnd); }
               
            SNAPTYPE GetSnapType (
               ) const { return (m_SnapType); }
               
            void SetCrossLines (
               bool CrossLines
               ) { m_DontCrossLines = !CrossLines; }

            void SetElementSnap (
               SNAPTOELEM element
               ) { m_SnapToElem = element; }
               
            void SetFromLegacyFlags (
               UINT32 flags
               );
               
            void SetRemoveOvershoots (
               bool RemoveOvershoots
               ) { m_RemOvershoots = RemoveOvershoots; }

            void SetSnapBackAngle (
               double angle
               ) { m_SnapBackAngle = bound(angle, 0.0, PI); }
               
            void SetSnapDist (
               double dist
               ) { m_SnapDist = dist; }
               
            void SetSnapEnd (
               SNAPEND SnapEnd
               ) { m_SnapEnd = SnapEnd; }
               
            void SetSnapToSelf (
               bool SnapToSelf
               ) { m_DontSnapToSelf = !SnapToSelf; }

            void SetSnapType (
               SNAPTYPE SnapType
               ) { m_SnapType = SnapType; }
               
         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            SNAPTOELEM m_SnapToElem;   
            SNAPTYPE m_SnapType; 
            SNAPEND m_SnapEnd;
            double m_SnapDist;
            double m_SnapBackAngle;             
            bool m_RemOvershoots;
            bool m_DontCrossLines;
            bool m_DontSnapToSelf;
            #endif // GENERATING_DOXYGEN_OUTPUT
            
         };
         
      enum CLIPFLAGS {
         CLIPFLAG_None = 0x00000000,               
         CLIPFLAG_ForceClipBorder = 0x00000200,    
         CLIPFLAG_NoClipBorder = 0x00000400,       
         CLIPFLAG_OnlyClipLines = 0x00000800,      
         CLIPFLAG_NoStdAttrib = 0x00001000,        
         CLIPFLAG_RemUnusedDBRec = 0x00002000      
         };
         
      enum DELETELINE {
         DELETELINE_None = 0x0000,
         DELETELINE_RemoveExcessNodes = 0x0001
         };
         
      enum DELETEPOLYGON {
         DELETEPOLYGON_None = 0x0000,
         DELETEPOLYGON_LongLineDelete = 0x0001,
         DELETEPOLYGON_NoDeleteSpurs = 0x0002,
         DELETEPOLYGON_CombineAttrib = 0x0004,
         DELETEPOLYGON_RemoveAllIslands = 0x0008
         };
         
      enum TOOLKITFLAG {
         TOOLKITFLAG_None = 0x00,
         TOOLKITFLAG_NoConvIfElemID = 0x01,        
         TOOLKITFLAG_RemExNodesDelLine = 0x02,     
         TOOLKITFLAG_NoStatusText = 0x04,          
         TOOLKITFLAG_NoSaveQTree = 0x08,           
         TOOLKITFLAG_NoCreateElemID = 0x10,        
         TOOLKITFLAG_NoQTrees = 0x20,              
         TOOLKITFLAG_KeepAttachedLabels = 0x40     
         };
         
      enum OPENFLAGS {
         OPENFLAGS_None = 0x00000000,
         OPENFLAGS_NoQtree = 0x00000001,
         OPENFLAGS_NoLineQtree = 0x00000002,
         OPENFLAGS_NoNodeQtree = 0x00000004,
         OPENFLAGS_NoPolygonQtree = 0x00000008,
         OPENFLAGS_NoPointQtree = 0x00000010,
         OPENFLAGS_NoLabelQtree = 0x00000020,
         OPENFLAGS_NoDatabase = 0x00000040,
         OPENFLAGS_NoCreateTables = 0x00000080,
         OPENFLAGS_NoCreateElemID = 0x00000100,
         OPENFLAGS_NoDBStatTable = 0x00000200,
         OPENFLAGS_NoCreateStyle = 0x00000400,
         OPENFLAGS_NoChangeTopoType = 0x00000800,
         OPENFLAGS_NoHyper = 0x00001000,
         OPENFLAGS_NoStyle = 0x00002000,
         OPENFLAGS_NoValidateNodes = 0x00004000,
         OPENFLAGS_WriteAbsolute = 0x00008000,
         OPENFLAGS_NoLegacyDelete = 0x00010000
         };
         
      enum SAVEFLAGS {
         SAVEFLAG_None = 0x0000,
         SAVEFLAG_RemoveExcessNodes = 0x0001,
         SAVEFLAG_RemoveExcessRecords = 0x0002,
         SAVEFLAG_Optimize = 0x0004
         };
         
      enum STDATTRIBSTATE {
         STDATTRIBSTATE_NonExistant = 1,
         STDATTRIBSTATE_NeedRebuilding,
         STDATTRIBSTATE_Valid
         };
         
      enum VALIDATEFLAG {
         VALIDATEFLAG_None =                    0x0000,
         VALIDATEFLAG_RebuildPolys =            0x0001,
         VALIDATEFLAG_RebuildIslands =          0x0002,
         VALIDATEFLAG_RebuildNodeLineList =     0x0004,
         VALIDATEFLAG_DontValidateZ =           0x0008,
         VALIDATEFLAG_NoRemoveNodes =           0x0080,
         VALIDATEFLAG_NoDBStatTable =           0x0100            
         };
         
      enum NODEFLAG {
         NODEFLAG_None =            0x0000,
         NODEFLAG_NoCheckDatabase = 0x0001,
         NODEFLAG_NoCheckHyper =    0x0002,
         NODEFLAG_NoStdAttrib =     0x0004,
         NODEFLAG_RemoveIfPoint =   0x0008
         };
         
      static ERRVALUE BuildNodeLineLists (
         VECTOR& VectObj
         );

      static ERRVALUE BuildPolygons (
         VECTOR& VectObj
         );

      static ERRVALUE BuildTopology (
         VECTOR& VectObj
         );

      static ERRVALUE DepthSortPolygons (
         VECTOR& VectObj
         );

      static ERRVALUE RemoveExcessNodes (
         VECTOR& VectObj,
         NODEFLAG flags
         );

      static int SplitLinesAtMaxPoints (
         const VECTOR& VectorObj,
         INT32 MaxPoints,
         OBJECT& ParentObj,
         VECTOR& NewObject
         );
         
      static ERRVALUE ValidateElementID (
         VECTOR& VectorObj
         );
         
      static ERRVALUE ValidateVectorTopology (
         VECTOR& VectorObj,
         FILE_TEXT& LogFile,        
         OPENFLAGS OpenFlags,
         VALIDATEFLAG flags
         );

      static ERRVALUE ValidateVectorTopology (
         VECTOR& VectorObj,
         OPENFLAGS OpenFlags,
         VALIDATEFLAG flags
         );

      VECTORTOOLKIT (
         );

      ~VECTORTOOLKIT (
         );
         
      ERRVALUE AddLabel (
         VECTOR::LABEL& label
         );
      
      ERRVALUE AddLine (
         POLYLINE& PolyLine
         );
      
      ERRVALUE AddLineSnapPoints (
         INT32 LineNum,
         POLYLINE& PolyLine
         );
         
      ERRVALUE AddNode (
         DPOINT3D& point         
         );
      
      ERRVALUE AddPoint (
         const DPOINT3D& pt
         );
      
      ERRVALUE AddPolygon (
         POLYLINE& PolyLine
         );
         
      ERRVALUE AddSnapPoints (
         POLYLINE& PolyLine,
         bool& SnappedStart,
         bool& SnappedEnd
         );
         
      ERRVALUE BuildNodeLineLists (
         );
      
      ERRVALUE BuildPolygons (
         );
         
      ERRVALUE BuildTopology (
         );

      ERRVALUE ChangeLabel (
         INT32 LabelNum,
         VECTOR::LABEL& label
         );
         
      ERRVALUE ChangeLine (
         INT32 LineNum,
         POLYLINE& PolyLine
         );
         
      DEPRECATED ERRVALUE ChangeNode (
         INT32 NodeNum,
         const DPOINT3D& NewPoint,
         const std::vector<POLYLINE>& NodeLines
         );
         
      ERRVALUE ChangeNode (
         INT32 NodeNum,
         const DPOINT3D& NewPoint,
         const POLYLINELIST& NodeLines
         );
         
      ERRVALUE ChangePoint (
         INT32 PointNum,
         const DPOINT3D& pt,
         bool IsNode = false
         );
      
      ERRVALUE ClipToRegion (
         const REGION2D& region,
         TESTCRITERIA RegionTest,
         const BITSET* PolygonSet,
         CLIPFLAGS flags
         );
         
      ERRVALUE Close (
         bool ForceClose
         );
         
      ERRVALUE CombineNodes (
         INT32 NodeNum,
         const DPOINT3D* NewPoint,                 
         const SIMPLE_ARRAY<INT32>& NodeList       
         );
         
      ERRVALUE ConvertForward (
         const TRANS2D_MAPGEN& tmg
         );
         
      ERRVALUE ConvertNodeToPoint (
         INT32 NodeNum
         );
      
      ERRVALUE ConvertPointType (
         GEOMETRIC::POINTTYPE NewPointType
         );
         
      ERRVALUE DeleteLabel (
         INT32 LabelNum
         );
         
      ERRVALUE DeleteLabels (
         const SIMPLE_ARRAY<INT32>& LabelList
         );
         
      ERRVALUE DeleteLine (
         INT32 LineNum,
         DELETELINE flags,
         POLYGONDELETEFILTER* PolyDelFilt = 0
         );
         
      ERRVALUE DeleteLines (
         const SIMPLE_ARRAY<INT32>& LineList,
         DELETELINE flags,
         POLYGONDELETEFILTER* PolyDelFilt = 0
         );
         
      INT32 DeleteNode (
         INT32 NodeNum,
         NODEFLAG NodeFlag
         );
         
      ERRVALUE DeleteNodes (
         const SIMPLE_ARRAY<INT32>& NodeList,
         NODEFLAG NodeFlag
         );
      
      ERRVALUE DeletePoint (
         INT32 PointNum
         );
         
      ERRVALUE DeletePoints (
         const SIMPLE_ARRAY<INT32>& PointList
         );
         
      ERRVALUE DeletePolygon (
         INT32 PolyNum,
         DELETEPOLYGON flags
         );
         
      ERRVALUE DeletePolygons (
         SIMPLE_ARRAY<INT32>& PolyList,
         DELETEPOLYGON flags
         );
         
      ERRVALUE ExtractToRegion (
         const REGION2D& region,
         TESTCRITERIA RegionTest,
         CLIPFLAGS flags
         );
         
      INT32 FindClosestLineVertex (
         INT32 LineNum,
         const DPOINT2D& testpt,
         DPOINT3D *retpt
         );
         
      ERRVALUE GenerateElementIDTables (
         );
         
      ERRVALUE GenerateIntersections (
         const POLYLINE& PolyLine,
         POLYLINE::INTERSECTINFO& ints,
         INT32 MaxIntersections = 0
         );
         
      const CREDENTIALS& GetCredentials (
         ) const { return (m_VectorObj.GetCredentials()); }
      
      DIMENSION GetDimension (
         ) const { return (m_VectorObj.GetDimension()); }
         
      ERRVALUE GetDatabaseObject (
         ELEMTYPE ElemType,
         DBASE_ELEMENT& DBaseObj
         );
         
      INT32 GetNumElements (
         ELEMTYPE ElemType
         ) const;
         
      ERRVALUE GetObjectItem (
         OBJITEM& ObjItem
         ) const;
         
      const SNAPOBJECT& GetSnapObject (
         ) { return (m_SnapObject); }

      const SNAPPARMS& GetSnapParms (
         ) const { return (m_SnapParms); }
         
      ERRVALUE GetStyleObject (
         STYLE& StyleObj
         ) const;
         
      TOOLKITFLAG GetToolkitFlags (
         ) const { return (m_ToolkitFlags); }
         
      ERRVALUE GetVectorObject (
         VECTOR& VectorObj
         ) const;
         
      ERRVALUE GetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         double& zvalue
         ) const;
         
      bool IsOpen (
         ) const { return (m_VectorObj.IsOpen()); }
      
      ERRVALUE LocateIslands (
         bool LineLeftRightValid
         );
            
      ERRVALUE Open (
         const RVC::OBJITEM& ObjItem,
         OPENFLAGS flags,
#ifdef RVC_CREDENTIALS_MANDATORY
         const CREDENTIALS* Credentials
#else
         const CREDENTIALS* Credentials = 0
#endif
         );
         
      ERRVALUE Open (
         const VECTOR& VectorObj,
         OPENFLAGS flags
         );
         
      ERRVALUE RecoverFromUndo (
         );
               
      int RemoveDangleLine (
         INT32 LineNum,
         double maxdist       
         );
         
      INT32 RemoveDangleLineSet (
         double maxdist
         );
         
      INT32 RemoveDangleLineSet (
         const SIMPLE_ARRAY<INT32>& LineList,
         double maxdist
         );
         
      ERRVALUE RemoveElementIDTables (
         );
         
      int RemoveExcessNodes (
         const BITSET *NodeSet = 0,
         NODEFLAG NodeFlags = NODEFLAG_None
         );
         
      INT32 RemoveIslandSet (
         double MaxArea,
         DELETEPOLYGON flags,
         INT32 *NumTotalIslands
         );
         
      ERRVALUE RemoveStandardAttributeTables (
         );
         
      ERRVALUE ReverseLines (
         const SIMPLE_ARRAY<INT32>& LineList
         );
         
      ERRVALUE Save (
         RVC::OBJITEM& ObjItem,
         SAVEFLAGS flags
         );
         
      ERRVALUE SnapLine (
         INT32 LineNum
         );
         
      ERRVALUE SnapLines (
         const BITSET_UNOWNED& LineSet,
         BITSET* UnsnappedSet,
         bool AttemptAllElements
         );
         
      ERRVALUE SetPrecision (
         int Precision
         );
         
      void SetSnapObject (
         );
         
      void SetSnapObject (
         const VECTOR& VectorObj,
         const TRANS2D_MAPGEN& VectorToObject
         );
         
      void SetSnapParms (
         const SNAPPARMS& SnapParms
         ) { m_SnapParms = SnapParms; }

      void SetToolkitFlags (
         TOOLKITFLAG ToolkitFlags
         ) { m_ToolkitFlags = ToolkitFlags; }

      ERRVALUE SetTopologyType (
         VECTOR::TOPOLOGYTYPE VectorType
         );
         
      ERRVALUE SetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         double zvalue
         );
         
      ERRVALUE SplineLine (
         INT32 LineNum,
         POLYLINE::SPLINE SplineType,
         INT32 NumKnots,
         double Tolerance,
         POLYLINE::SPLINEFLAGS flags
         );
         
      ERRVALUE SplineLines (
         const BITSET* LineList,       
         POLYLINE::SPLINE SplineType,
         INT32 NumKnots,
         double Tolerance,
         POLYLINE::SPLINEFLAGS flags,
         bool AttemptAllElements
         );
      
      ERRVALUE SplitLineAtMaxPoints (
         INT32 MaxPoints,
         bool SetMaxPoints
         );
         
      ERRVALUE StraightenLine (
         INT32 LineNum
         );
         
      ERRVALUE ThinLine (
         INT32 LineNum,
         POLYLINE::THINMETHOD method,
         double Factor,
         POLYLINE::SPLINE SplineType,
         POLYLINE::SPLINEFLAGS flags
         );
         
      ERRVALUE ThinLines (
         const BITSET* LineList,       
         POLYLINE::THINMETHOD method,
         double Factor,
         POLYLINE::SPLINE SplineType,
         POLYLINE::SPLINEFLAGS flags,
         bool AttemptAllElements
         );
         
      ERRVALUE Update (
         );
         
      ERRVALUE UpdateStandardAttrib (
         MSTDATT::ADDSTAT flags
         );
         
      STDATTRIBSTATE ValidateStandardAttribTables (
         );
         
      ERRVALUE ValidateTopology (
         VALIDATEFLAG flags,
         FILE_TEXT& LogFile         
         );
         
      ERRVALUE ValidateTopology (
         VALIDATEFLAG flags
         );
         
   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      enum LINEORIENT {
         LINEORIENT_Start = 0,
         LINEORIENT_End
         };

      class BASEELEMENT {
         public:
         
            BASEELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype
               );
               
            virtual ~BASEELEMENT (
               );

            virtual INT32 GetNumElements (
               ) const = 0;
               
            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const = 0;
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               ) = 0;
               
            ERRVALUE AddQTreeElem (
               INT32 elemnum,
               const DRECT2D& Extents
               );
               
            ERRVALUE AddQTreeElem (
               INT32 elemnum,
               const DPOINT2D& pt
               );
               
            ERRVALUE BuildQTree (
               );
               
            ERRVALUE ChangeQTreeElem (
               INT32 ElemNum,
               const DRECT2D& OldExtents,
               const DRECT2D& NewExtents
               );
               
            ERRVALUE ChangeQTreeElem (
               INT32 ElemNum,
               const DPOINT2D& OldPt,
               const DPOINT2D& NewPt
               );
               
            ERRVALUE ClearQTree (
               const DRECT2D& Extents,
               INT32 NumElements
               );
               
            void CloseBase (
               );
               
            ERRVALUE CopyQTreeElem (
               INT32 source,
               INT32 dest,
               const DRECT2D& Extents
               );
               
            ERRVALUE CopyQTreeElem (
               INT32 source,
               INT32 dest,
               const DPOINT2D& pt
               );
               
            ERRVALUE DeleteQTreeElem (
               INT32 elemnum,
               const DRECT2D& Extents
               );
               
            ERRVALUE DeleteQTreeElem (
               INT32 elemnum,
               const DPOINT2D& pt
               );
               
            void DisableQTree (
               ) { m_DisableQTree = true; }
               
            bool HasSearchTree (
               ) const { return (m_HasSearchTree); }
            
            bool IsQTreeDisabled (
               ) const { return (m_DisableQTree); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
               
            ERRVALUE RecoverFromUndo (
               );
               
         protected:
         
            ELEMTYPE m_ElemType;
            VECTORTOOLKIT& m_vtk;
            bool m_DisableQTree;
            bool m_HasSearchTree;
            
            friend class SNAPOBJECT;
            
         };
      friend class BASEELEMENT;

      class DATABASEELEMENT : public BASEELEMENT {
         public:
         
            DATABASEELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype,
               DBASE_ELEMENT& Database
               );
               
            virtual ~DATABASEELEMENT (
               );
               
            virtual INT32 GetElemIDCount (
               ) const = 0;
               
            virtual bool HasStatHandle (
               ) const { return (false); }
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               ) = 0;
               
            virtual ERRVALUE ValidateElementIDTable (
               );
         
            ERRVALUE AddElemDBList (
               INT32 ElemNum
               );
         
            ERRVALUE Close (
               );
               
            ERRVALUE CombineDBLists (
               INT32 SourceElem,
               INT32 DestElem
               );
               
            int CompareDBLists (
               INT32 ElemNum1,
               INT32 ElemNum2
               );
               
            INT32 CopyDBRecordRaw (
               RVC::DBTABLE& TableObj,
               INT32 SourceRecord,
               INT32 DestRecord
               );
               
            ERRVALUE CopyElemDBRecords (
               INT32 SourceElem,
               INT32 DestElem,
               bool DeleteIdentityRecord
               );
               
            ERRVALUE GenerateElementIDTable (
               );
               
            SIMPLE_ARRAY<DBLISTELMT>& GetDBListBuffer (
               ) { return (m_DBList); }
               
            ERRVALUE GetElementIDTable (
               ) const { return (m_ElemIDTableNum); }
               
            DBASE_ELEMENT& GetDatabase (
               ) { return (m_Database); }
               
            DBTABLE& GetTable (
               INT32 TableNum
               );
            
            bool HasElementIDTable (
               ) const { return (m_ElemIDTableNum >= 0); }
               
            ERRVALUE MakeElementIDTable (
               bool SetInvalid
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveElementIDTable (
               );
               
            ERRVALUE RemoveTable (
               INT32 TableNum
               );
               
            ERRVALUE SwapDBRecords (
               INT32 ElemNum1,
               INT32 ElemNum2,
               bool DeleteElemNum2Records       
               );
               
            ERRVALUE UpdateCurrentElemID (
               INT32 ElemNum
               );
               
            ERRVALUE UpdateNumElements (
               INT32 NumElements
               );
               
         protected:
         
            class LOCALOBSERVER : public DBASE::OBSERVER {
               public:
               
                  LOCALOBSERVER (
                     DATABASEELEMENT* DBaseElem
                     ) : DBASE::OBSERVER(DBaseElem->m_Database), m_DBaseElem(DBaseElem) {}
               
               private:
                  virtual void OnTableAdd (INT32 TableNum);
                  virtual void OnTableDropBegin (INT32 TableNum);
                  virtual void OnTableDropEnd (INT32 TableNum);
               
                  DATABASEELEMENT* m_DBaseElem;
               };
         
            DBASE_ELEMENT& m_Database;
            INT32 m_ElemIDTableNum;       
            DBTABLE::RECORD m_Record;
            SIMPLE_ARRAY<DBLISTELMT> m_DBList;
            SIMPLE_ARRAY<DBLISTELMT> m_DBList2;
            bool m_MaintainElementIDTables;
            LOCALOBSERVER* m_Observer;
            std::vector<DBTABLE> m_DBTableObjArray;
         
            void AllocateObserver (
               );

            friend class LOCALOBSERVER;
         };
      friend class DATABASEELEMENT;
      
      class STATELEMENT : public DATABASEELEMENT {
         public:
         
            class DISABLESTATS {
               public:
               
                  DISABLESTATS (
                     STATELEMENT& StatElem,
                     bool Condition
                     ) : m_StatElem(StatElem), m_TempSdh(0), m_Condition(Condition && StatElem.m_sdh != 0) {
                     if (Condition) {
                        m_TempSdh = StatElem.m_sdh;
                        StatElem.m_sdh = 0;
                        }
                     }
                     
                  ~DISABLESTATS (
                     ) {
                     if (m_Condition) {
                        m_StatElem.m_sdh = m_TempSdh;
                        if (m_StatElem.m_sdh != 0) {
                           ERRORPOSNDISABLE Disable;
                           m_StatElem.m_sdh->RebuildTable(MSTDATT::ADDSTAT_None);
                           }
                        }
                     }
                     
                  bool IsDisabled (
                     ) const { return (m_TempSdh != 0 && m_StatElem.m_sdh == 0); }
               
               private:
                  STATELEMENT& m_StatElem;
                  VECTSTDATT* m_TempSdh;
                  bool m_Condition;
               };
            friend class DISABLESTATS;
            
            STATELEMENT (
               VECTORTOOLKIT& vtk,
               ELEMTYPE elemtype,
               DBASE_ELEMENT& Database
               );
               
            virtual ~STATELEMENT (
               );
         
            virtual bool HasStatHandle (
               ) const { return (m_sdh != 0); }
               
            void CloseStat (
               );
               
            ERRVALUE Close (
               );
               
            INT32 GetNumRecords (
               ) const;
               
            bool IsInitialized (
               ) const { return (m_sdh != 0); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
               
            ERRVALUE RebuildTable (
               MSTDATT::ADDSTAT flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveStatTable (
               );
               
         protected:
            VECTSTDATT *m_sdh;               
            bool m_MaintainStdAttribIDTables;
         };
      friend class STATELEMENT;
      
      class LINEELEMENT : public STATELEMENT {
         public:
         
            enum LINESNAP {
               LINESNAP_None = 0x0000,
               LINESNAP_ForceNode = 0x0001
               };

            LINEELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~LINEELEMENT (
               );
               
            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            INT32 Add (
               const POLYLINE& PolyLine
               );
            
            int AddSnapPoint (
               LINEORIENT LineOrient,
               POLYLINE& PolyLine,
               LINESNAP LineSnap
               );
               
            ERRVALUE Change (
               INT32 LineNum,
               const POLYLINE& PolyLine
               );
            
            ERRVALUE ChangeLine (
               INT32 LineNum,
               const POLYLINE& PolyLine
               );
               
            ERRVALUE ChangeSnapLine (
               POLYLINE& PolyLine
               );
               
            int CheckIfIntersect (
               INT32 SkipLineNum,
               const POLYLINE& PolyLine
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Delete (
               INT32 LineNum
               );
               
            ERRVALUE FindLineAndSplit (
               const DPOINT3D& point, 
               DPOINT3D& retpt
               );
               
            BITSET& GetLineBitset (
               ) { return (m_ElemList); }
               
            ERRVALUE JoinLines (
               INT32 NodeNum,
               INT32 RepLineNum,
               INT32 DelLineNum
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE OtherLineIntersect (
               const POLYLINE& PolyLine
               );
               
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveOvershoots (
               POLYLINE& PolyLine
               ) const;
               
            ERRVALUE SelfLineIntersect (
               const POLYLINE& PolyLine
               );
               
            INT32 SplitLineAtVertex (
               INT32 OldLineNum,
               INT32 vertex,
               INT32& NewLineNum
               );
               
            INT32 SplitLineNearPoint (
               INT32 LineNum,
               const DPOINT2D& point,
               INT32& NewLineNum
               );
               
            ERRVALUE UpdateStats (
               INT32 ElemNum
               );
               
         private:
         
            class OTHERLINESPLIT;
            friend class OTHERLINESPLIT;
            class SELFLINESPLIT;
            friend class SELFLINESPLIT;
            
            BITSET m_ElemList;   
            DBASE_LINE m_LineDB;
            
            ERRVALUE AddLineSegment (const POLYLINE& PolyLine);
            ERRVALUE ChangeLineSegment (const POLYLINE& PolyLine);
            ERRVALUE ComputeLineExtents (INT32 LineNum, VECTOR::LINE& vline);
            INT32 FindBestLineSnapPoint (LINEORIENT LineOrient, const POLYLINE& Polyline, DPOINT3D& retpt, double& maxdist) const;
            int GenerateExtendSnapPoint (LINEORIENT LineOrient, const POLYLINE& PolyLine, DPOINT3D& retpt, LINESNAP LineSnap);
            int GenerateSnapToPoint (LINEORIENT LineOrient, const POLYLINE& PolyLine, DPOINT3D& retpt, LINESNAP LineSnap);
            int InsertLinePoint (INT32 LineNum, INT32 segment, DPOINT3D& insertpt);
            ERRVALUE ResetLineNodeLink (LINEORIENT LineOrient, INT32 LineNum);
               
            class EXTENDSPLIT;
            class SNAPFILTINFO;

            friend class VECTORTOOLKIT;
         };
      friend class LINEELEMENT;
      friend class LINEELEMENT::EXTENDSPLIT;
      friend class LINEELEMENT::SNAPFILTINFO;
      class LINEPOLYJOIN;
      friend class LINEPOLYJOIN;

      class POINTELEMENT : public DATABASEELEMENT {
         public:
         
            POINTELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~POINTELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            virtual ERRVALUE ValidateElementIDTable (
               );
         
            ERRVALUE Add (
               const DPOINT3D& point
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveElementIDRecord (
               INT32 PointNum
               );
               
         private:
            DBASE_POINT m_PointDB;
         };
      friend class POINTELEMENT;

      class POLYGONELEMENT : public STATELEMENT {
         public:
            class POLYLINEDELETE;
         
            POLYGONELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~POLYGONELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            ERRVALUE AddIsland (
               INT32 PolyNum,
               INT32 IslandNum
               );
               
            ERRVALUE Build (
               );
            
            ERRVALUE ChangeIsland (
               INT32 PolyNum,
               INT32 OldIsleNum,
               INT32 NewIsleNum
               );
               
            ERRVALUE ChangeLine (
               INT32 PolyNum,
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE Delete (
               INT32 PolyNum
               );
               
            ERRVALUE DeleteByLine (
               INT32 PolyNum,
               DELETEPOLYGON flags
               );
               
            ERRVALUE DeleteIsland (
               INT32 PolyNum,
               INT32 IslandNum
               );
               
            ERRVALUE DeleteLine (
               INT32 PolyNum,
               INT32 LineNum
               );
               
            int FindPolygons (
               INT32 StartLine,
               INT32 PolyInside
               );
               
            BITSET& GetPolygonBitset (
               ) { return (m_ElemList); }
               
            ERRVALUE MergePolygons (
               INT32 LeftPolyNum,
               INT32 RightPolyNum,
               INT32 LineNum,
               POLYGONDELETEFILTER* PolyDelFilt
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveIslandInfo (
               );
               
            ERRVALUE RemovePolygonInfo (
               bool IsPolyRebuild
               );
               
            ERRVALUE SplitLineInPolygons (
               INT32 OrigLineNum,
               const VECTOR::LINE& Origvline,
               INT32 NewLineNum
               );
               
            ERRVALUE SplitLineInPoly (
               INT32 PolyNum,
               INT32 OrigLineNum, 
               const VECTOR::LINE& Origvline, 
               INT32 NewLineNum, 
               SIMPLE_ARRAY<INT32>& LineList
               ) const;
               
            ERRVALUE SplitLineInSamePoly (
               INT32 OrigLineNum, 
               const VECTOR::LINE& Origvline, 
               INT32 NewLineNum, 
               SIMPLE_ARRAY<INT32>& LineList
               ) const;
            
            ERRVALUE Update (
               INT32 PolyNum
               );
               
            void UpdateStats (
               BITSET& PolySet
               );
               
            ERRVALUE ValidatePolyInside (
               );
               
         private:
            struct LOCATEPOLY;      
            
            DBASE_POLYGON m_PolyDB;
            BITSET m_ElemList;   
            
            ERRVALUE ComputePolyExtents (INT32 PolyNum);
            INT32 FindNextLine (LOCATEPOLY& LocatePoly);
            ERRVALUE GenerateShellPolyList (INT32 ParentPoly, const SIMPLE_ARRAY<INT32>& LineList, SIMPLE_ARRAY<INT32>& PolyList);
            ORIENTATION OrientList (const SIMPLE_ARRAY<INT32>& LineList, const SIMPLE_ARRAY<bool>& LineOrientList) const;
            ERRVALUE RemoveZeroAreaPolygon (INT32 StartLine, LOCATEPOLY& LocatePoly);
            ERRVALUE ReparentIslands (INT32 PolyNum, INT32 NewParent, bool MoveToNewParent);
            ERRVALUE ReparentNestedIslands (INT32 CheckPoly, const SIMPLE_ARRAY<INT32>& LineList);
            ERRVALUE SearchNestedIslands (INT32 PolyInside, INT32 IslePoly, bool AddingPolygon);
            ERRVALUE SetLeftRight (const LOCATEPOLY& LocatePoly, INT32 PolyNum, INT32 ParentPolyNum);
            ERRVALUE UnparentIslets (INT32 OldParentPoly, INT32 NewParentPoly, const INT32 *LineList, INT32 NumLines);
            void ValidatePoly (LOCATEPOLY& LocatePoly, INT32 StartLine);
               
         };
      friend class POLYGONELEMENT;
      friend class POLYGONELEMENT::POLYLINEDELETE;
      class POLYLISTDELETE;
      friend class POLYLISTDELETE;
      class POLYISLANDDELETE;
      
      struct NODELINEANGLE {
         double m_Angle;               
         INT32 m_LineNum;              
         bool m_Orient;                
         
         NODELINEANGLE (
            ) { memset(this, 0, sizeof(*this)); }     
            
         static int CompareAngle (
            NODELINEANGLE *d1,
            NODELINEANGLE *d2,
            void *data
            );

         };

      class NODEELEMENT : public DATABASEELEMENT {
         public:
            NODEELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~NODEELEMENT (
               );

            virtual INT32 GetElemIDCount (
               ) const;
               
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetElemIDCount (
               INT32 NewValue
               );
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            virtual ERRVALUE ValidateElementIDTable (
               ) { return (0); }
         
            INT32 AddNode (
               const DPOINT3D& point
               );
               
            ERRVALUE AddNodeLine (
               INT32 NodeNum,
               INT32 LineNum
               );
         
            ERRVALUE BuildNodeLineList (
               );
               
            ERRVALUE ChangeNode (
               INT32 NodeNum,
               const DPOINT3D& point
               );
               
            ERRVALUE ChangeNodeLine (
               INT32 NodeNum,
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            bool CheckIsPoint (
               INT32 NodeNum
               );
               
            ERRVALUE Close (
               );
               
            ERRVALUE ConvertNodePointToNode (
               INT32 NodeNum
               );
            
            ERRVALUE ConvertToPoint (
               INT32 NodeNum
               );
               
            ERRVALUE Delete (
               INT32 NodeNum
               );
               
            ERRVALUE DeleteNodeLine (
               INT32 NodeNum,
               INT32 LineNum
               );
               
            ERRVALUE FindNodeLineAngles (
               INT32 NodeNum,
               SIMPLE_ARRAY<NODELINEANGLE>& list
               ) const;
               
            DBASE_NODE& GetNodeDatabase (
               ) { return (m_NodeDB); }
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE ValidateNodes (
               );

         private:
            DBASE_NODE m_NodeDB;
         };
      friend class NODEELEMENT;

      class LABELELEMENT : public BASEELEMENT {
         public:
         
            LABELELEMENT (
               VECTORTOOLKIT& vtk
               );
               
            virtual ~LABELELEMENT (
               );

            // VIRTUAL METHODS
            virtual INT32 GetNumElements (
               ) const;

            virtual ERRVALUE GetZValue (
               INT32 ElemNum,
               double& zvalue
               ) const;
               
            virtual ERRVALUE SetZValue (
               INT32 ElemNum,
               double zvalue
               );
               
            // METHODS  
            ERRVALUE AddLabelAttach (
               INT32 LabelNum,
               const VECTOR::LABEL& label,
               bool CheckAttach = false
               );
               
            ERRVALUE ChangeAttachPosn (
               ELEMTYPE ElemType,
               INT32 ElemNum,
               const DPOINT3D& point
               );
               
            ERRVALUE ChangeLabelAttach (
               ELEMTYPE ElemType,
               INT32 OldElemNum,
               INT32 NewElemNum
               );
            
            ERRVALUE CheckAttachments (
               );
               
            void CheckLabelAttach (
               const VECTOR::LABEL& label
               );
                  
            void CleanupElemToLabelTrans (
               );
         
            ERRVALUE Close (
               );

            ERRVALUE DeleteLabelAttach (
               ELEMTYPE ElemType,
               INT32 ElemNum
               );
               
            ERRVALUE Open (
               OPENFLAGS flags
               );
         
            ERRVALUE PickLineLabelAttach (
               INT32 OldLineNum,
               INT32 NewLineNum
               );
               
            ERRVALUE PickPolyLabelAttach (
               INT32 OldPolyNum,
               INT32 NewPolyNum
               );
               
            ERRVALUE RecoverFromUndo (
               );
               
            ERRVALUE RemoveLabelAttach (
               INT32 LabelNum
               );
               
            ERRVALUE ResizeLabelAttach (
               ELEMTYPE ElemType,
               INT32 NumItems
               );
               
            ERRVALUE SetupElemToLabelTrans (
               );
               
            ERRVALUE SwapElementLabelAttach (
               ELEMTYPE ElemType,
               INT32 FirstElem,
               INT32 LastElem
               );
               
            ERRVALUE SwapLabelAttach (
               INT32 FirstLabel,
               INT32 LastLabel
               );
               
         private:
         
            LIST& GetTransList (ELEMTYPE ElemType);
            ERRVALUE ResizeLabelTransList (ELEMTYPE ElemType);
               
            OBJECT m_LabelTransFile;
            LIST m_LineToLabelID;
            LIST m_NodeToLabelID;
            LIST m_PointToLabelID;
            LIST m_PolygonToLabelID;
            LIST m_DummyID;
            
         };
      friend class LABELELEMENT;
      
      class OPENVECTOR : public VECTOR {
         public:
         
            OPENVECTOR (
               ) : VECTOR() {}
         
            OPENVECTOR (
               const OPENVECTOR& rhs
               ) : VECTOR(rhs) {}
         
            virtual ~OPENVECTOR (
               ) {}
               
            ERRVALUE ClearLinePointList (
               ) { return (VECTOR::ClearLinePointList()); }

            ERRVALUE ClearNodeLineList (
               ) { return (VECTOR::ClearNodeLineList()); }
         
            ERRVALUE ClearPolygonIslandList (
               ) { return (VECTOR::ClearPolygonIslandList()); }
         
            ERRVALUE ClearPolygonLineList (
               ) { return (VECTOR::ClearPolygonLineList()); }
         
            ERRVALUE SetNumLabels (
               INT32 NewNumLabels
               ) { return (VECTOR::SetNumLabels(NewNumLabels)); }
         
            ERRVALUE SetNumLines (
               INT32 NewNumLines
               ) { return (VECTOR::SetNumLines(NewNumLines)); }
         
            ERRVALUE SetNumNodes (
               INT32 NewNumNodes
               ) { return (VECTOR::SetNumNodes(NewNumNodes)); }
               
            ERRVALUE SetNumPoints (
               INT32 NewNumPoints
               ) { return (VECTOR::SetNumPoints(NewNumPoints)); }
            
            ERRVALUE SetNumPolygons (
               INT32 NewNumPolygons
               ) { return (VECTOR::SetNumPolygons(NewNumPolygons)); }
            
            ERRVALUE SwapLinePoints (
               INT32 Line1,
               INT32 Line2
               ) { return (VECTOR::SwapLinePoints(Line1, Line2)); }
               
            ERRVALUE SwapNodeLines (
               INT32 Node1,
               INT32 Node2
               ) { return (VECTOR::SwapNodeLines(Node1, Node2)); }
               
            ERRVALUE SwapPolyIslands (
               INT32 Poly1,
               INT32 Poly2
               ) { return (VECTOR::SwapPolyIslands(Poly1, Poly2)); }
               

            ERRVALUE SwapPolyLines (
               INT32 Poly1,
               INT32 Poly2
               ) { return (VECTOR::SwapPolyLines(Poly1, Poly2)); }
         };
      
      class DISABLETEXT {
         public:
         
            DISABLETEXT (
               VECTORTOOLKIT& vtk
               ) : m_vtk(vtk), m_OldFlags(TOOLKITFLAG_None) {
               m_OldFlags = vtk.GetToolkitFlags();
               vtk.SetToolkitFlags(static_cast<TOOLKITFLAG>(m_OldFlags | TOOLKITFLAG_NoStatusText));
               }
               
            ~DISABLETEXT (
               ) { m_vtk.SetToolkitFlags(m_OldFlags); }
               
            bool DoStatusText (
               ) const { return ((m_OldFlags & TOOLKITFLAG_NoStatusText) == 0); }
               
         private:
            TOOLKITFLAG m_OldFlags;
            VECTORTOOLKIT& m_vtk;
         };

      class BUILDPOLYINFO;
      class CLIPDATA;
      class CLIPDATA2;
      class DEPTHSORTINFO;
      class REMOVEEXCESSNODES;
      class REMPOLYREC;
      class SLIVEROBSERVER;
      class VALIDATE;
      friend class BUILDPOLYINFO;
      friend class CLIPDATA;
      friend class CLIPDATA2;
      friend class DEPTHSORTINFO;
      friend class REMOVEEXCESSNODES;
      friend class REMPOLYREC;
      friend class SLIVEROBSERVER;
      friend class VALIDATE;
      
      OPENVECTOR m_VectorObj;
      HYPERINDEX m_HyperObj;
      STYLE m_StyleObj;
      SIMPLE_ARRAY<INT32> m_LineList;
      SIMPLE_ARRAY<INT32> m_IsleList;
      SNAPPARMS m_SnapParms;
      double m_IntsThresh;
      LABELELEMENT m_Label;
      POINTELEMENT m_Point;
      NODEELEMENT m_Node;
      POLYGONELEMENT m_Polygon;
      LINEELEMENT m_Line;
      POLYLINE m_PointBuff;
      SNAPOBJECT m_SnapObject;
      bool m_InValidateFunc;
      bool m_HasAttachedLabels;
      bool m_IgnoreAddDBList;
      bool m_MultiLineSnap;
      bool m_TestEndLine;
      bool m_SnappedSelfLine;
      bool m_UseAddLineOverlapCallback;
      bool m_IgnoreBadMinMax;
      bool m_UseLegacyDelete;
      bool m_InPolygonDelete;
      TOOLKITFLAG m_ToolkitFlags;
      INT32 m_MaxLinePoints;                 
      UINT32 m_RecursiveCount;
      INT32 m_ModifyLineNum;
      INT32 m_ModifyNodeNum;

      static int IsDoubleEqual (double val1, double val2, double scale);

      void CallOnAdd (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnDelete (ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
      void CallOnJoinBegin (ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
      void CallOnJoinEnd (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnLineOverlap (const SIMPLE_ARRAY<POLYLINE::INTERSECTINFO::OVERLAP>& Overlaps);
      void CallOnMoveBegin (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnMoveEnd (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnNodeLineAdd (INT32 NodeNum, INT32 NumLines);
      void CallOnNodeLineDelete (INT32 NodeNum, INT32 NumLines);
      void CallOnNodeToPointBegin (INT32 NodeNum);
      void CallOnNodeToPointEnd (INT32 NodeNum);
      void CallOnSplitBegin (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnSplitEnd (ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
      void CallOnValidateSplitLine (ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
      void CallOnZeroAreaPolygon ();
      ERRVALUE ChangeElemInHyperShape (ELEMTYPE ElemType, INT32 OldElemNum, INT32 NewElemNum);
      ERRVALUE ChangeTypeInHyperShape (ELEMTYPE ElemType, INT32 elemnum, RVC::HYPERINDEX::SHAPE::TYPE newtype);
      ERRVALUE ClipToPolyLine (POLYLINE& PolyLine, CLIPDATA& ClipData, CLIPFLAGS flags, bool IsIsland);
      ERRVALUE ClipToPolyLine (POLYLINE& PolyLine, CLIPDATA2& ClipData, CLIPFLAGS flags, bool IsIsland);
      ERRVALUE CombineHyperLinks (ELEMTYPE ElemType, INT32 SourceElem, INT32 DestElem);
      INT32 CompareHyperShapes (ELEMTYPE ElemType, INT32 ElemNum1, INT32 ElemNum2);
      ERRVALUE ConflateRegion (POLYLINE& PolyLine);
      ERRVALUE CopyHyperLinks (ELEMTYPE ElemType, INT32 SourceElem, INT32 DestElem);
      ERRVALUE DeleteElemHyperShape (ELEMTYPE ElemType, INT32 ElemNum);
      ERRVALUE ExtractToRegion (const REGION2D& region, TESTCRITERIA RegionTest, const BITSET& LineNotTest, const BITSET& LineDelList, CLIPFLAGS flags);
      ERRVALUE FindLineDirection (NODELINEANGLE& nla) const;
      ERRVALUE GenerateIntersections (const POLYLINE& PolyLine, POLYLINE::INTERSECTINFO& ints, INT32 MaxIntersections, SNAPOBJECT& SnapObject);
      const BASEELEMENT *GetBaseElement (ELEMTYPE ElemType) const;
      BASEELEMENT *GetBaseElement (ELEMTYPE ElemType);
      double GenerateThreshold (double resolution) const;
      int MergeTwoNodes (INT32 LineNum, INT32 OldNode, INT32 NewNode, SIMPLE_ARRAY<INT32>& RemoveLineSet);
      ERRVALUE SetZState (double zvalue);
      bool TestSnapBackAngle (LINEORIENT LineOrient, const POLYLINE& PolyLine, const DPOINT3D& testpt) const;

      // Unimplemented
      VECTORTOOLKIT (const VECTORTOOLKIT&);
      VECTORTOOLKIT& operator=(const VECTORTOOLKIT&);
      
      #endif // GENERATING_DOXYGEN_OUTPUT

   };


class VECTORTOOLKIT::POLYGONDELETEFILTER {
   public:
      POLYGONDELETEFILTER() {}
      
      INT32 WhichPolygonDelete (
         INT32 LeftPolygon,
         INT32 RightPolygon
         ) { return (v_WhichPolygonDelete(LeftPolygon, RightPolygon)); }
         
   private:
      virtual INT32 v_WhichPolygonDelete (
         INT32 LeftPolygon,
         INT32 RightPolygon
         ) = 0;
   };
         

class VECTORTOOLKITOBSERVER : public OBSERVER_BASE {
   public:

      VECTORTOOLKITOBSERVER (
         VECTORTOOLKIT& vtk
         );
         
      virtual ~VECTORTOOLKITOBSERVER (
         );
         
      virtual void OnAdd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
      virtual void OnDelete (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 OtherElemNum
         );
         
      virtual void OnJoinBegin (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 OtherElemNum
         );

      virtual void OnJoinEnd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
      virtual void OnLineOverlap (
         const SIMPLE_ARRAY<POLYLINE::INTERSECTINFO::OVERLAP>& Overlaps
         );

      virtual void OnMoveBegin (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );

      virtual void OnMoveEnd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );

      virtual void OnNodeLineAdd (
         INT32 NodeNum,
         INT32 NumLines
         );

      virtual void OnNodeLineDelete (
         INT32 NodeNum,
         INT32 NumLines
         );

      virtual void OnNodeToPointBegin (
         INT32 NodeNum
         );

      virtual void OnNodeToPointEnd (
         INT32 NodeNum
         );

      virtual void OnSplitBegin (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
      virtual void OnSplitEnd (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 OtherElemNum
         );
            
      virtual void OnValidateSplitLine (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 OtherElemNum
         );
            
      virtual void OnZeroAreaPolygon (
         );
            
   };

#ifndef GENERATING_DOXYGEN_OUTPUT
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::CLIPFLAGS);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::DELETELINE);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::DELETEPOLYGON);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::NODEFLAG);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::OPENFLAGS);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::SAVEFLAGS);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::TOOLKITFLAG);
DEFINE_ENUM_OP_BITWISE(VECTORTOOLKIT::VALIDATEFLAG);
#endif   // GENERATING_DOXYGEN_OUTPUT

}     // End of RVC namespace

#endif      // INC_RVC_VECTTOOL_H 

---