geometrc.h

Go to the documentation of this file.

/**
 * \file rvc/geometrc.h 
 * \brief interface for the RVC::GEOMETRIC class.
 *
 * \if NODOC
 * $Id: geometrc.h_v 1.71 2004/08/30 17:24:01 scowan Exp $
 *
 * $Log: geometrc.h_v $
 * Revision 1.71  2004/08/30 17:24:01  scowan
 * Added new capability enum's.
 *
 * Revision 1.70  2004/08/24 22:26:41  scowan
 * Added virtual methods to get and set total line length.
 *
 * Revision 1.69  2004/07/19 17:03:05  scowan
 * Moved has min elem filter to geometric class.
 *
 * Revision 1.68  2004/07/14 21:15:35  scowan
 * Changed comment
 *
 * Revision 1.67  2004/07/12 23:21:07  scowan
 * Removed use of geo region.
 *
 * Revision 1.66  2004/07/01 19:57:42  scowan
 * Removed use of legacy region code.
 *
 * Revision 1.65  2004/05/28 20:34:44  scowan
 * Added virtual method.
 *
 * Revision 1.64  2004/04/28 22:04:18  scowan
 * Added extract flag.
 *
 * Revision 1.63  2004/04/09 20:47:03  scowan
 * Update some docs.
 *
 * Revision 1.62  2004/03/16 00:22:22  scowan
 * Added a new virtual method.
 *
 * Revision 1.61  2004/03/01 17:42:49  scowan
 * Added more elem select parm methods.
 *
 * Revision 1.60  2004/02/11 20:01:32  scowan
 * Added new filter class override.
 *
 * Revision 1.59  2004/02/09 20:13:40  scowan
 * Added methods to get the bitset and bitset deque from a elem trans list.
 *
 * Revision 1.58  2004/02/04 14:35:26  scowan
 * Added region 2d to elem select parms.
 *
 * Revision 1.57  2003/11/21 22:17:04  scowan
 * Support new Capabilities system.
 *
 * Revision 1.56  2003/10/22 16:31:07  mju
 * Add GETOBJFILTER_HASNOIMPLIEDGEOREF.
 *
 * Revision 1.55  2003/10/22 16:17:20  scowan
 * Added get objtype set static method.
 *
 * Revision 1.54  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.53  2003/09/25 21:56:37  dwilliss
 * doxygen
 *
 * Revision 1.52  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.51  2003/09/11 20:09:31  scowan
 * Added is geometric function.
 *
 * Revision 1.50  2003/06/25 14:49:56  scowan
 * Added set array.
 *
 * Revision 1.49  2003/06/24 21:03:48  scowan
 * Added more capability flags.
 *
 * Revision 1.48  2003/06/19 17:45:27  scowan
 * Added virtual method and enum.
 *
 * Revision 1.47  2003/06/04 23:34:55  scowan
 * Added find element draw set.
 *
 * Revision 1.46  2003/05/30 21:33:19  scowan
 * Added is selectable filter.
 *
 * Revision 1.45  2003/05/27 16:36:30  scowan
 * Added new filters and un-inlined a method.
 *
 * Revision 1.44  2003/05/12 23:32:59  scowan
 * Changes to virtual methods.
 *
 * Revision 1.43  2003/03/07 18:44:07  scowan
 * Added on poin type change callback.
 *
 * Revision 1.42  2003/02/19 20:13:49  scowan
 * Added extract flag.
 *
 * Revision 1.41  2003/02/06 21:26:40  scowan
 * *** empty log message ***
 *
 * Revision 1.40  2003/02/06 21:25:06  scowan
 * Added another combine styles.
 *
 * Revision 1.39  2003/02/06 16:03:31  scowan
 * Added new standard empty object filter class.
 *
 * Revision 1.38  2002/12/06 16:49:03  scowan
 * More const.
 *
 * Revision 1.37  2002/11/06 20:52:26  scowan
 * More const.
 *
 * Revision 1.36  2002/10/23 21:06:55  scowan
 * Added another get element set.
 *
 * Revision 1.35  2002/09/30 23:21:31  scowan
 * Made element search code const.
 *
 * Revision 1.34  2002/09/26 15:02:03  mju
 * Fix SEARCHRESULT iterator initialization/increment for ranges case.
 *
 * Revision 1.33  2002/09/17 22:48:56  scowan
 * More virtual method adjustment.
 *
 * Revision 1.32  2002/09/12 22:10:07  mju
 * Add addl ctor for searchfilter_bitset.
 *
 * Revision 1.31  2002/09/12 21:28:11  mju
 * Add SEARCHFILTER_BITSET.
 *
 * Revision 1.30  2002/09/03 22:17:59  scowan
 * More virtual method moves.
 *
 * Revision 1.29  2002/08/29 22:12:50  scowan
 * Virtual method adjustment.
 *
 * Revision 1.28  2002/08/19 15:05:05  scowan
 * Fixed g++3.1 warnings.
 *
 * Revision 1.27  2002/06/19 22:23:59  scowan
 * More methods changes.
 *
 * Revision 1.26  2002/06/18 22:15:09  scowan
 * Added extract interface.
 *
 * Revision 1.25  2002/05/01 17:42:40  scowan
 * Method change.
 *
 * Revision 1.24  2002/04/30 17:33:43  scowan
 * Changed makr parm class name.
 *
 * Revision 1.23  2002/04/26 22:44:20  scowan
 * Added more virtual methods.
 *
 * Revision 1.22  2002/03/01 16:19:05  scowan
 * Added virtual methods.
 *
 * Revision 1.21  2002/02/28 18:56:23  scowan
 * Added sort search restul.
 *
 * Revision 1.20  2002/02/27 23:24:07  scowan
 * Added get geometric and get element extents methods.
 *
 * Revision 1.19  2002/01/30 15:56:41  scowan
 * Added sml context creation method.
 *
 * Revision 1.18  2002/01/29 17:26:47  scowan
 * Added inline method to get the object dimension.
 *
 * Revision 1.17  2002/01/07 20:24:46  scowan
 * Fixed access to observer class.
 * Arranged classes for genator docs.
 *
 * Revision 1.16  2002/01/03 22:56:56  scowan
 * Added extents management methods and an exttents changed callback.
 *
 * Revision 1.15  2001/10/08 20:49:39  scowan
 * Added element region method.
 *
 * Revision 1.14  2001/09/28 15:32:54  scowan
 * Add observer class.
 *
 * Revision 1.13  2001/07/31 16:40:23  scowan
 * Added new interface methods.
 *
 * Revision 1.12  2001/06/13 21:51:33  scowan
 * Added to RVC namespace.
 *
 * Revision 1.10  2001/05/24 17:37:14  scowan
 * Added vurtual methods for finding elements.
 *
 * Revision 1.9  2001/04/23 22:52:04  scowan
 * Added find closest methods.
 *
 * Revision 1.8  2001/04/23 17:40:48  scowan
 * Fixed const stuff.
 *
 * Revision 1.7  2001/04/23 17:38:33  scowan
 * Added update extents method.
 *
 * Revision 1.6  2001/01/18 23:17:57  scowan
 * Removed inline constructor / destructor calls.
 *
 * Revision 1.5  2001/01/16 16:51:52  scowan
 * Must have virtual destructor body.
 *
 * Revision 1.4  2000/12/01 15:57:30  scowan
 * Fixed MAC errors.
 *
 * Revision 1.3  2000/11/24 22:53:23  scowan
 * Added set extents pure virtual method.
 *
 * Revision 1.2  2000/10/19 17:55:45  scowan
 * Checked in for vacation.
 *
 * Revision 1.1  2000/10/02 17:39:43  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::GEOMETRIC rvc/geometrc.h
//!   \brief Interface for RVC objects that support line work paradigm.
//!
//!   RVC Object Types that this class supports: Derived class
//!
//!   Default RVC Object Type for this class: Derived class
//!
//!   Valid parents for this class: Derived class

#ifndef INC_RVC_GEOMETRC_H
#define INC_RVC_GEOMETRC_H

#ifndef INC_RVC_GEOSPATL_H
   #include <rvc/geospatl.h>
#endif

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

#ifndef INC_MI32_ELEMTYPE_H
   #include <mi32/elemtype.h>
#endif

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

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

#ifndef INC_RVC_GETOBJF_H
   #include <rvc/getobjf.h>
#endif

#ifndef INC_MI32_REGION2D_H
   #include <mi32/region2d.h>
#endif

#ifndef INC_MI32_BITSET_H
   #include <mi32/bitset.h>
#endif

#ifndef INC_MI32_ELEMTYPESET_H
   #include <mi32/elemtypeset.h>
#endif

#ifndef GENERATING_DOXYGEN_OUTPUT
struct SMLCONTEXT;      //!< Forward Declarations
class TRANS2D_MAPGEN;
class BITSET_DEQUE;
#endif // GENERATING_DOXYGEN_OUTPUT

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
class ELEMENT;          //!< Forward Declarations
class QSEARCHTREE;
class SPATIALTREE;
#endif // GENERATING_DOXYGEN_OUTPUT

class GEOMETRIC : public GEOSPATIAL {
   public:

      //Ignore
      class ELEMSELECTFILTER;
      class ELEMSELECTPARMS;
      class ELEMTRANSLIST;
      class GETOBJFILTER_HASMINIMUMELEMENTS;
      class GETOBJFILTER_HASNOIMPLIEDGEOREF;
      class GETOBJFILTER_ISDISPLAYABLE;
      class GETOBJFILTER_ISNOTEMPTY;
      class GETOBJFILTER_ISSELECTABLE;
      class MAKEPARMSBASE;
      class OBSERVER;
      class SEARCHFILTER;
      class SEARCHFILTER_BITSET;
      class SEARCHFILTER_ELEMTRANSLIST;
      class SEARCHRESULT;
      //End Ignore
      
      enum CAPABILITY {
         CAPABILITY_None =             0,
         CAPABILITY_OwnSearchMethods = 512,  //!< Object has its own search methods (Oracle, MySQL, ...)
         CAPABILITY_CanAddToEnd,             //!< Object can be modified by adding elements to the end of the object
         CAPABILITY_CanChangeElements,       //!< Existing object elements can be modified 
         CAPABILITY_HasStyleByElement,       //!< Each element can have its own style settings
         CAPABILITY_ElementHasExtents,       //!< Each element has extents stored with it, except labels
         CAPABILITY_HasLabels,               //!< Object has labels
         CAPABILITY_LabelHasExtents,         //!< Each label has extents stored with it
         CAPABILITY_CanDeleteLastElement,    //!< Can delete the last element in the set
         CAPABILITY_CanDeleteAnyElement      //!< Can delete any element in the set
         };

      enum EXTRACTFLAGS {
         EXTRACTFLAG_None =                  0,
         EXTRACTFLAG_RegionMethod =          0x00000001,    //!< SelectMethod is a REGION2D
         EXTRACTFLAG_RemExRecords =          0x00000002,    //!< Remove Excess (Unattached) database records
         EXTRACTFLAG_RemStdAttTables =       0x00000004,    //!< Remove Standard Attribute database tables
         EXTRACTFLAG_IgnoreMissingLines =    0x00000008,    //!< Ignore missing lines from extraction operation, polygon and node line lists
         EXTRACTFLAG_TableJoinNameStruct =   0x00000010,    //!< Join tables in Append functions if names alike and compatable structures
         EXTRACTFLAG_TableJoinStruct =       0x00000020,    //!< Join tables in Append functions if compatable structures
         EXTRACTFLAG_TableRemoveDupRec =     0x00000040,    //!< Do not copy over records if exists in dest table
         EXTRACTFLAG_IgnorePolygonTables =   0x00000080,    //!< Do not copy over polygon databases
         EXTRACTFLAG_RemoveTables =          0x00000100,    //!< Remove destination tables
         EXTRACTFLAG_CopyHyperIndexSub =     0x00000200,    //!< Copy Hyper index subobjects
         EXTRACTFLAG_DensifyPoints =         0x00000400     //!< Densify line points using transformation parameters
         };

      enum POINTTYPE {
         POINTTYPE_2DXY = 1,           //!< 2-D coordinates, X and Y given (default)
         POINTTYPE_3DXY = 4,           //!< 3-D coordinates, X, Y given, Z constant
         POINTTYPE_3DXYZ = 7           //!< 3-D coordinates, X, Y and Z given
         };

      //! Default constructor
      GEOMETRIC (
         );

      //! Copy constructor
      GEOMETRIC (
         const RVC::GEOMETRIC& rhs
         );
      
      //! Destructor
      virtual ~GEOMETRIC (
         ) = 0;

      //! Assignment
      RVC::GEOMETRIC& operator= (
         const RVC::GEOMETRIC& rhs
         );

      //! Add an element to the search tree
      ERRVALUE AddSearchTreeElement (
         INT32 elemnum,
         ELEMTYPE ElemType,
         const DRECT2D& Extents
         ) { return (v_AddSearchTreeElement(elemnum, ElemType, Extents)); }

      //! Populate a search tree given existing elements
      ERRVALUE BuildSearchTree (
         INT32 InitialNumElements,
         ELEMTYPE ElemType,
         const DRECT2D& Extents
         ) { return (v_BuildSearchTree(InitialNumElements, ElemType, Extents)); }
         
      //! Re-Initialize search tree to a state with no elements
      ERRVALUE ClearSearchTree (
         INT32 InitialNumElements,
         ELEMTYPE ElemType,
         const DRECT2D& Extents
         ) { return (v_ClearSearchTree(InitialNumElements, ElemType, Extents)); }

      //! Combine styles from source object 'this' to the destination object 'DestObj'.
      //! this method deals with style links from source tables
      ERRVALUE CombineStylesTo (
         RVC::GEOMETRIC& DestObj
         ) const;

      //! Combine styles from source object 'this' to the destination object 'DestObj'.
      //! this method deals with style links from source tables
      //! Used for objects with direct style attachments (a.k.a CAD)
      ERRVALUE CombineStylesTo (
         RVC::GEOMETRIC& DestObj,
         SIMPLE_ARRAY<INT32>& FontTrans,
         SIMPLE_ARRAY<INT32> PattTrans[STYLE::PATTERN_NumTypes]
         ) const;

      //! Copy an element from one part of the search tree to another (atomic method)
      ERRVALUE CopySearchTreeElement (
         INT32 SourceElement,
         INT32 DestElement,
         ELEMTYPE ElemType,
         const DRECT2D& Extents
         ) { return (v_CopySearchTreeElement(SourceElement, DestElement, ElemType, Extents)); }
         
      //! Create an SML context for the given derived class instance
      ERRVALUE CreateSMLContext (
         SMLCONTEXT **pcontext               //!< SML context allocated and RETURNED
         ) const;

      //! Delete an element from the search tree
      ERRVALUE DeleteSearchTreeElement (
         INT32 elemnum,
         ELEMTYPE ElemType
         ) { return (v_DeleteSearchTreeElement(elemnum, ElemType)); }

      //! Extract elements from source 'this' object to existing destination object
      //! Deals with database attachments and element transfers
      //! Not implemented for CAD or TIN yet
      ERRVALUE ExtractTo (
         RVC::GEOMETRIC& DestObj,
         RVC::GEOMETRIC::ELEMTRANSLIST& TransList,
         const TRANS2D_MAPGEN& tmg,
         RVC::GEOMETRIC::EXTRACTFLAGS ExtractFlags = EXTRACTFLAG_None
         ) const { return (v_ExtractTo(DestObj, TransList, tmg, ExtractFlags)); }
         
      //! Determine closest element based on point and search distance
      //! @return Element found, -1 if no elements are close enough, < -1 if error
      INT32 FindClosestElement (
         ELEMTYPE ElemType,
         const DPOINT2D& SearchPt,
         double SearchDist,
         double* DistFromElem
         ) const { return (v_FindClosestElementLow(ElemType, SearchPt, 0, SearchDist, DistFromElem)); }
      
      //! Determine closest element based on point and search distance with filter
      //! @return Element found, -1 if no elements are close enough, < -1 if error
      INT32 FindClosestElement (
         ELEMTYPE ElemType,
         const DPOINT2D& SearchPt,
         SEARCHFILTER& SearchFilter,
         double SearchDist,
         double* DistFromElem
         ) const { return (v_FindClosestElementLow(ElemType, SearchPt, &SearchFilter, SearchDist, DistFromElem)); }
      
      //! Determine set of elements that are within the 'SearchDist' of the 'SearchPt'
      ERRVALUE FindClosestElements (
         const DPOINT2D& SearchPt, 
         double SearchDist, 
         SIMPLE_ARRAY<RVC::ELEMENT>& ElementList
         ) const { return (v_FindClosestElementsLow(SearchPt, SearchDist, 0, ElementList)); }
         
      //! Determine set of elements that are within the 'SearchDist' of the 'SearchPt' with filter
      ERRVALUE FindClosestElements (
         const DPOINT2D& SearchPt, 
         double SearchDist, 
         SEARCHFILTER& SearchFilter,
         SIMPLE_ARRAY<RVC::ELEMENT>& ElementList
         ) const { return (v_FindClosestElementsLow(SearchPt, SearchDist, &SearchFilter, ElementList)); }
      
      //! Obtain set of elements that fall within the rectangle, return list in 'SearchResult'
      //! This method will NOT build search trees to determine the elements that fall within the rectangle.
      //! If a search or spatial tree is not available to limit the search, all elements will be returned
      ERRVALUE FindElementDrawSet (
         ELEMTYPE ElemType,
         const DRECT2D& SearchExtents,
         SEARCHRESULT& SearchResult
         ) const;
         
      //! Obtain set of elements that fall within the rectangle, return list in 'SearchResult'
      //! This method will build search trees, if needed, to determine the elements that fall within the rectangle.
      ERRVALUE FindElementSearchSet (
         ELEMTYPE ElemType,
         const DRECT2D& SearchExtents,
         SEARCHRESULT& SearchResult
         ) const;

      //! Obtain the DBASE_ELEMENT Attachement index from the element specified
      //! @return '-1' if element does not have a database attachment, >= 0 if it does.
      INT32 GetAttachmentIndex (
         const RVC::ELEMENT& Element
         ) const { return (v_GetAttachmentIndex(Element)); }
      
      //! Obtain DIMENSION type
      //! @return DIMENSION type
      DIMENSION GetDimension (
         ) const { return ((GetPointType() == POINTTYPE_3DXYZ) ? DIMENSION_3D : DIMENSION_2D); }
         
      //! Obtain element extents using element type and element number
      ERRVALUE GetElementExtents (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         DRECT3D& Extents              //!< Element extents RETURNED, set to invalid if error or element is deleted
         ) const { return (v_GetElementExtents(ElemType, ElemNum, Extents)); }

      //! Get geometric object referred to by 'object'
      //! @return Allocated instance of RVC::GEOMETRIC object (must be 'delete'd) or 0 if error
      static RVC::GEOMETRIC* GetGeometric (
         const RVC::OBJECT& object
         );
         
      //! Get geometric object referred to by 'ObjItem'
      //! @return Allocated instance of RVC::GEOMETRIC object (must be 'delete'd) or 0 if error
      static RVC::GEOMETRIC* GetGeometric (
         const RVC::OBJITEM& ObjItem
         );
         
      //! Obtain next element ID depending on element type
      //! @return Element ID to be used for the next element
      INT32 GetNextElementID (
         ELEMTYPE ElemType
         ) const { return (v_GetNextElementID(ElemType)); }

      //! Obtain number of elements based on element type
      //! Specifying ELEMTYPE_All will return the total combination of elements in the object
      //! @return Number of elements if valid ELEMTYPE for object, -1 if not
      INT32 GetNumElements (
         ELEMTYPE ElemType
         ) const { return (v_GetNumElements(ElemType)); }
      
      //! Get correct OBJTYPESET for all geometric OBJTYPE's
      //! @return OBJTYPESET for all geometric OBJTYPE's
      static RVC::OBJTYPESET GetObjTypeSet (
         );
         
      //! Obtain number of point coordinate dimensions
      //! @return Number of dimensions
      INT32 GetPointDimension (
         ) const { return (GetPointSize() / sizeof(double)); }
         
      //! Obtain point coordinate type
      //! @return POINTTYPE coordinate type
      POINTTYPE GetPointType (
         ) const { return (v_GetPointType()); }

      //! Obtain size of point coordinate
      //! @return Size of point in bytes
      INT32 GetPointSize (
         ) const { return (v_GetPointSize()); }

      //! Obtain the total line length of all of the lines in the geometric object combined
      //! @return Total length of all of the lines combined or zero if not computed    
      double GetTotalLineLength (
         ) const { return (v_GetTotalLineLength()); }
      
      //! Determine if the element in this object is deleted.
      //! @return 'true' if the element is deleted, 'false' if not.
      bool IsElementDeleted (
         const RVC::ELEMENT& Element
         ) const { return (v_IsElementDeleted(Element)); }

      //! Determine if the object has any elements.
      //! @return 'true' if the object is empty, 'false' if not.
      bool IsEmpty (
         ) const { return (v_IsEmpty()); }

      //! Determine if the object type is a geometric object
      static bool IsGeometric (
         RVC::OBJTYPE ObjType
         );

      //! Save search tree objects
      ERRVALUE SaveSearchTrees (
         ) { return (v_SaveSearchTrees()); }
         
      //! Set the extents of an object
      //! Only use if you have a write lock on the entire object
      ERRVALUE SetExtents (
         const DRECT3D &extents
         ) { return (v_SetExtents(extents)); }
         
      //! Set next element ID depending on element type
      ERRVALUE SetNextElementID (
         ELEMTYPE ElemType,
         INT32 NextElementID
         ) { return (v_SetNextElementID(ElemType, NextElementID)); }

      //! Set search tree handle for all open instances of this object
      bool SetSearchTree (
         ELEMTYPE ElemType,
         RVC::QSEARCHTREE* SearchTree,
         bool ReplaceExisting = false
         ) { return (v_SetSearchTree(ElemType, SearchTree, ReplaceExisting)); }
         
      //! Set the total line length of all of the lines in the geometric object combined
      ERRVALUE SetTotalLineLength (
         double length
         ) { return (v_SetTotalLineLength(length)); }
      
      //! Generate element translation lists dependent on the selection parameters.
      //! @return > 0 if elements are found to meet the selection parameters, '0' if no elements found, < 0 error 
      int SetupElemTransList (
         const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms,
         RVC::GEOMETRIC::ELEMTRANSLIST& TransList
         ) const { return (SetupElemTransList(SelectParms, TransList, 0)); }
         
      //! Generate element translation lists dependent on the selection parameters.
      //! @return > 0 if elements are found to meet the selection parameters, '0' if no elements found, < 0 error 
      int SetupElemTransList (
         const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms,
         RVC::GEOMETRIC::ELEMTRANSLIST& TransList,
         RVC::GEOMETRIC::ELEMSELECTFILTER& SelectFilter
         ) const { return (SetupElemTransList(SelectParms, TransList, &SelectFilter)); }
         
      //! Test element against region
      //! The REGION2D needs to be in 'object' coordinates, no conversion is done internally
      //! @return True if test against region was sucessful
      bool TestElementAgainstRegion (
         const RVC::ELEMENT& Element, 
         const REGION2D& region,
         TESTCRITERIA TestMode
         ) const { return (v_TestElementAgainstRegion(Element, region, TestMode)); }
      
      //! Update the extents of an object, this is a thread safe method
      ERRVALUE UpdateExtents (
         const DRECT3D &extents
         ) { return (v_UpdateExtents(extents)); }
         
   protected:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      static void GeometricCallbackFunc (MfAnyCallbackStruct *cb, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT

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

      #ifndef GENERATING_DOXYGEN_OUTPUT
      int SetupElemTransList (const RVC::GEOMETRIC::ELEMSELECTPARMS& SelectParms, RVC::GEOMETRIC::ELEMTRANSLIST& TransList, RVC::GEOMETRIC::ELEMSELECTFILTER* SelectFilter) const;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

DEFINE_ENUM_OP_BITWISE(GEOMETRIC::EXTRACTFLAGS);


class GEOMETRIC::ELEMSELECTFILTER {
   public:
      ELEMSELECTFILTER () {}

      //! Filter elements based on some external criteria
      //! @return '1' for element acceptance, '0' to reject element, < 0 for an error     
      int FilterElement (
         RVC::ELEMENT& Element
         ) { return (v_FilterElement(Element)); }
         
   private:
      // Pure virtual
      virtual int v_FilterElement (RVC::ELEMENT& element) = 0;
   };


class GEOMETRIC::ELEMSELECTPARMS {
   public:
   
      enum EXTRACT {
         EXTRACT_All,
         EXTRACT_PartInside,
         EXTRACT_FullInside,
         EXTRACT_ClipInside,
         EXTRACT_PartOutside,
         EXTRACT_FullOutside,
         EXTRACT_ClipOutside
         };
   
      struct ITEM {
         enum SELECT {
            SELECT_None = 0,
            SELECT_All,
            SELECT_ByRecord,
            SELECT_ByScript,
            SELECT_ByElement,
            SELECT_Last
            };
            
         ITEM (
            );
      
         SELECT m_SelectType;
         MISTRING m_QueryStr;
         RVC::OBJECTNAME m_TableName;     //!< Table that 'RecordList' is selected from
         BITSET m_RecordList;             //!< List of records in 'TableNum' that the user has selected (bit array)
         BITSET m_ElemList;               //!< List of elements (bit array)
         };
   
      ELEMSELECTPARMS (
         );
      
      const REGION2D& GetRegion2D (
         ) const { return (m_Region); }
      
      EXTRACT GetRegionExtractMode (
         ) const { return (m_ExtractMode); }

      TESTCRITERIA GetRegionTestCriteria (
         ) const { 
         TESTCRITERIA TestCriteria = TESTCRITERIA_PartInside;
         switch (m_ExtractMode) {
            case EXTRACT_FullOutside:  TestCriteria = TESTCRITERIA_FullOutside; break;
            case EXTRACT_PartOutside:  TestCriteria = TESTCRITERIA_PartOutside; break;
            case EXTRACT_ClipOutside:  TestCriteria = TESTCRITERIA_PartOutside; break;
            case EXTRACT_FullInside:   TestCriteria = TESTCRITERIA_FullInside; break;
            case EXTRACT_PartInside:   TestCriteria = TESTCRITERIA_PartInside; break;
            case EXTRACT_ClipInside:   TestCriteria = TESTCRITERIA_PartInside; break;
            }  
         return (TestCriteria); 
         }
      
      const ITEM& GetSelectParmItem (
         ELEMTYPE ElemType
         ) const;    
   
      ITEM& GetSelectParmItem (
         ELEMTYPE ElemType
         );
         
      bool HasRegion (
         ) const { return (!m_Region.IsEmpty()); }
   
      void SetRegion (
         const REGION2D& Region
         ) { m_Region = Region; }
      
      void SetRegionExtractMode (
         EXTRACT ExtractMode
         ) { m_ExtractMode = ExtractMode; }
      
      void SetSelectAll (
         );
         
      void SetSelectNone (
         );
         
      void SetSelectParmItem (
         ELEMTYPE ElemType,
         const ITEM& item
         );    
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ITEM m_SelectParm[6];
      REGION2D m_Region;
      EXTRACT m_ExtractMode;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Class to manage element translation lists from source to destination elements
//! Eg: 'DestElemNum = TransList[SourceElemNum]' where 'TransList' is an array of INT32's
//! The value '-1' states that the source element does not translate to a destination number.
class GEOMETRIC::ELEMTRANSLIST {
   public:

      //! Constructor   
      ELEMTRANSLIST (
         ) {}
   
      //! Copy Constructor 
      ELEMTRANSLIST (
         const ELEMTRANSLIST& rhs
         );
   
      //! Destructor 
      ~ELEMTRANSLIST (
         ) {}
         
      //! Assignment Operator
      ELEMTRANSLIST& operator= (
         const ELEMTRANSLIST& rhs
         );
   
      //! Obtain the element translation array for a particular element type (ELEMTYPE)
      //! @return Element Translation List
      const SIMPLE_ARRAY<INT32>& GetElementTransList (
         ELEMTYPE ElemType
         ) const;
         
      //! Obtain the element translation array for a particular element type (ELEMTYPE)
      //! @return Element Translation List
      SIMPLE_ARRAY<INT32>& GetElementTransList (
         ELEMTYPE ElemType
         );
         
      //! Obtain the element bitset for a particular element type (ELEMTYPE)
      ERRVALUE GetElementBitset (
         ELEMTYPE ElemType,
         BITSET& Bitset
         ) const;
         
      //! Obtain the element bitset deque for a particular element type (ELEMTYPE)
      ERRVALUE GetElementBitsetDeque (
         ELEMTYPE ElemType,
         BITSET_DEQUE& BitsetDeque
         ) const;
         
      ERRVALUE GetReverseTransList (
         ELEMTYPE ElemType,
         SIMPLE_ARRAY<INT32>& ReverseTrans,
         INT32 NumDestElems
         ) const;
         
      //! Set an element translation list entry to a pre-built list
      void SetElementTransList (
         const SIMPLE_ARRAY<INT32>& TransList,
         ELEMTYPE ElemType
         );
         
      //! Set an element translation list entry to a pre-built list
      ERRVALUE SetElementTransList (
         INT32* TransList,
         INT32 NumItems,
         ELEMTYPE ElemType
         );

      //! Set translation list to a one-to-one (Identity) mapping
      ERRVALUE SetIdentity (
         const RVC::GEOMETRIC& GeoObj        //!< Geometric object used to set identity arrays using the object type and number of elements per element type
         );
   
      //! Set an element translation list entry to a one-to-one (Identity) mapping 
      ERRVALUE SetIdentity (
         const RVC::GEOMETRIC& GeoObj,       //!< Geometric object used to set identity arrays using the object type
         ELEMTYPE ElemType                   //!< Element Type used to set the identity array entry using the number of elements for this type
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<INT32> m_TransList[6];
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! GETOBJFILTER derived class to determine if the geometric object has the minimum number of elements of the specified types
class GEOMETRIC::GETOBJFILTER_HASMINIMUMELEMENTS : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASMINIMUMELEMENTS (
         const ELEMTYPESET& ElemTypeSet,
         INT32 MinElements = 1
         ) : m_ElemTypeSet(ElemTypeSet), m_MinElements(MinElements) {}
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      ELEMTYPESET m_ElemTypeSet;
      INT32 m_MinElements;
      
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

//! Geometric object selection filter to disallow selection of geometric objects already having implied georeference.
class GEOMETRIC::GETOBJFILTER_HASNOIMPLIEDGEOREF : public GETOBJFILTER {
   public:
      GETOBJFILTER_HASNOIMPLIEDGEOREF () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//! Geometric object selection filter to disallow selection of empty and invalid extent geometric objects
class GEOMETRIC::GETOBJFILTER_ISDISPLAYABLE : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISDISPLAYABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//! Geometric object selection filter to disallow selection of empty geometric objects
class GEOMETRIC::GETOBJFILTER_ISNOTEMPTY : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISNOTEMPTY () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
//! Geometric object selection filter to disallow selection of non geometric objects
class GEOMETRIC::GETOBJFILTER_ISSELECTABLE : public GETOBJFILTER {
   public:
      GETOBJFILTER_ISSELECTABLE () {}
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual bool v_IsSelectable (const RVC::OBJITEM& ObjItem, int position);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
      
//! Make parameter base class for RVC::GEOMETRIC objects.
class GEOMETRIC::MAKEPARMSBASE {
   public:
   
      //! Default constructor
      MAKEPARMSBASE (
         POINTTYPE PointType
         ) :
         m_PointType(PointType),
         m_XScale(1.0),
         m_YScale(1.0),
         m_ZScale(1.0)
         {}
         
      //! Get vector object extents
      //! @return Extents of the vector object
      const DRECT3D& GetExtents (
         ) const {return (m_Extents);}
   
      //! Obtain point coordinate type for vector creation
      //! @return RVCGEOMETRIC::POINTTYPE coordinate type
      POINTTYPE GetPointType (
         ) const {return (m_PointType);}

      //! Get vector x scale value
      //! @return Vector X scale value
      double GetXScale (
         ) const {return (m_XScale);}
         
      //! Get vector y scale value
      //! @return Vector Y scale value
      double GetYScale (
         ) const {return (m_YScale);}
         
      //! Get vector z scale value
      //! @return Vector Z scale value
      double GetZScale (
         ) const {return (m_ZScale);}

      //! Set vector object extents
      void SetExtents (
         const DRECT3D& rect
         ) {m_Extents = rect;}
      
      //! Set coordinate point type for vector creation
      void SetPointType (
         POINTTYPE PointType
         ) {m_PointType = PointType;}

      //! Set vector x scale value
      void SetXScale (
         double xscale
         ) {m_XScale = xscale;}
         
      //! Set vector y scale value
      void SetYScale (
         double xscale
         ) {m_XScale = xscale;}
         
      //! Set vector x scale value
      void SetZScale (
         double xscale
         ) {m_XScale = xscale;}
         
   protected:
   
      DRECT3D m_Extents;
      POINTTYPE m_PointType;
      double m_XScale;
      double m_YScale;
      double m_ZScale;
   };

//! OBSERVER class for RVC::GEOMETRIC objects.
class GEOMETRIC::OBSERVER : public RVC::OBJECTOBSERVER {
   public:  
      enum TYPE {
         TYPE_ExtentsChange = 0x00000108,
         TYPE_PointTypeChange = 0x00000110
//!         TYPE_AddElement = 0x00000201
         };

      explicit OBSERVER (
         RVC::GEOMETRIC& object
         ) : OBJECTOBSERVER(object) {}
         
      virtual ~OBSERVER (
         ) {}
         
//!      virtual void OnAddElement (
//!         ELEMTYPE ElemType,
//!         INT32 ElemNum
//!         ) { return; }
      
      //! Called when the geoemtric object extents has changed
      virtual void OnExtentsChanged (
         const DRECT3D& NewExtents
         ) { return; }

      //! Called when the geoemtric object extents has changed
      virtual void OnPointTypeChanged (
         GEOMETRIC::POINTTYPE NewPointType
         ) { return; }

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      virtual void OnNotifyRaw (UINT32 reason, void *data);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Filter search class for FindClosestElement() method
class GEOMETRIC::SEARCHFILTER {
   public:
      //! Element filter for locating correct elements.
      //! @return True to use element in search, False to not use element in search
      virtual bool Filter (
         const RVC::GEOMETRIC& object,
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) = 0;
         
   protected:
      //! Destructor 
      virtual ~SEARCHFILTER () {}
   };
   

//! Filter search class for FindClosestElement() method supporting bit-set.
class GEOMETRIC::SEARCHFILTER_BITSET : public GEOMETRIC::SEARCHFILTER {
   public:

      //! Construct from BITSET_UNOWNED.
      SEARCHFILTER_BITSET (
         const BITSET_UNOWNED& bitset
         ) : m_bitset(bitset) { }

      //! Construct from bit array and count.
      SEARCHFILTER_BITSET (
         const UINT8 *set,
         UINT32 NumEntries
         ) : m_bitset(const_cast<UINT8*>(set),NumEntries) { }

      //! Destructor 
      virtual ~SEARCHFILTER_BITSET () {}

   protected:

      //! Element filter for locating correct elements.
      //! @return True if element in set, false if not.
      virtual bool Filter (
         const RVC::GEOMETRIC& object,
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      BITSET_UNOWNED m_bitset;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

//! Filter search class for FindClosestElement() method supporting bit-set.
class GEOMETRIC::SEARCHFILTER_ELEMTRANSLIST : public GEOMETRIC::SEARCHFILTER {
   public:

      //! Construct from ELEMTRANSLIST
      SEARCHFILTER_ELEMTRANSLIST (
         const GEOMETRIC::ELEMTRANSLIST& ElemTransList
         ) : m_ElemTransList(ElemTransList) { }

      //! Destructor 
      virtual ~SEARCHFILTER_ELEMTRANSLIST () {}

   protected:

      //! Element filter for locating correct elements.
      //! @return True if element in set, false if not.
      virtual bool Filter (
         const RVC::GEOMETRIC& object,
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      GEOMETRIC::ELEMTRANSLIST m_ElemTransList;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class GEOMETRIC::SEARCHRESULT {
   public:
   
      class CONST_ITERATOR;
      friend class CONST_ITERATOR;

      class CONST_ITERATOR {
         public:
         
            //! Default constructor
            CONST_ITERATOR (
               ) :
               m_IsRange(false),
               m_CurElemNum(0),
               m_CurIndex(0),
               m_sr(0)
               {}

            //! Internal constructor, used by container.
            CONST_ITERATOR (
               const SEARCHRESULT* sr,
               bool CreateEnd = false
               );

            //! Copy constructor
            CONST_ITERATOR (
               const CONST_ITERATOR& rhs
               ) : 
               m_IsRange(rhs.m_IsRange),
               m_CurElemNum(rhs.m_CurElemNum),
               m_CurIndex(rhs.m_CurIndex),
               m_sr(rhs.m_sr)
               {}

            //! Dereference operator, returns current element number.
            const INT32& operator* (
               ) const { return (m_CurElemNum); }

            //! Pre-increment operator.
            CONST_ITERATOR& operator++ (
               );

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

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

            bool operator!= (          //! Inequality operator
               const CONST_ITERATOR& rhs
               ) const { return (!(*this == rhs)); }
         
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            bool m_IsRange;
            INT32 m_CurElemNum;
            INT32 m_CurIndex;
            const SEARCHRESULT* m_sr;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };
      
      SEARCHRESULT (
         );
   
      SEARCHRESULT (
         const SEARCHRESULT& rhs
         );
   
      ~SEARCHRESULT (
         );
         
      SEARCHRESULT& operator= (
         const SEARCHRESULT& rhs
         );
         
      CONST_ITERATOR Begin (
         ) const {return (CONST_ITERATOR(this));}
         
      void Clear (
         );
         
      CONST_ITERATOR End (
         ) const {return (CONST_ITERATOR(this, true));}
         
      ERRVALUE FindElements (
         ELEMTYPE ElemType,
         const DRECT2D& SearchExtents,
         RVC::QSEARCHTREE& QTreeObj
         );
   
      ERRVALUE FindElements (
         ELEMTYPE ElemType,
         const DRECT2D& SearchExtents,
         RVC::SPATIALTREE& STreeObj
         );
         
      ERRVALUE GetElementSet (
         BITSET& SelectSet
         ) const;
         
      ERRVALUE GetElementSet (
         SIMPLE_ARRAY<INT32>& SelectList
         ) const;
         
      INT32 GetNumItems (
         ) const;
         
      bool IsEmpty (
         ) const;
         
      //! Set the search result for the all elements set
      void SetAll (
         INT32 NumElements
         );
         
      //! Set the search result for array passed in
      void SetArray (
         const SIMPLE_ARRAY<INT32>& ElemSet
         );
         
      //! Sort the elements in the list using the elements extents from smallest to largest
      void SortItemsByExtentArea (
         const RVC::GEOMETRIC& GeoObj,
         ELEMTYPE ElemType
         );
   
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      SIMPLE_ARRAY<INT32> m_list;
      SIMPLE_ARRAY<INT32_RANGE> m_range;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   
      
}     //! End of RVC namespace

#endif   //!< INC_RVC_GEOMETRC_H

---