rvc/tin.h

Go to the documentation of this file.

/**
 * \file rvc/tin.h 
 * \brief interface for the RVC::TIN class.
 *
 * \if NODOC
 * $Id: tin.h_v 1.49 2003/11/21 22:17:11 scowan Exp $
 *
 * $Log: tin.h_v $
 * Revision 1.49  2003/11/21 22:17:11  scowan
 * Support new Capabilities system.
 *
 * Revision 1.48  2003/10/07 17:30:14  scowan
 * Object virtual method changes.
 *
 * Revision 1.47  2003/09/30 16:52:06  dwilliss
 * Doxygen
 *
 * Revision 1.46  2003/09/25 21:20:04  dwilliss
 * Fixed doxygen comment
 *
 * Revision 1.45  2003/09/15 13:49:45  fileserver!dwilliss
 * Doxygen
 *
 * Revision 1.44  2003/06/19 17:46:06  scowan
 * Added virtual method and enum.
 *
 * Revision 1.43  2003/06/04 23:35:12  scowan
 * Added find element draw set.
 *
 * Revision 1.42  2003/05/12 23:33:20  scowan
 * Changes to virtual methods.
 *
 * Revision 1.41  2003/05/07 22:20:46  scowan
 * Changed virtual method format.
 *
 * Revision 1.40  2002/09/30 23:22:26  scowan
 * Made element search code const.
 *
 * Revision 1.39  2002/09/17 22:49:21  scowan
 * More virtual method adjustment.
 *
 * Revision 1.38  2002/09/17 16:15:37  scowan
 * Added more methods.
 *
 * Revision 1.37  2002/09/12 22:09:31  scowan
 * Updated search tree copy elem.
 *
 * Revision 1.36  2002/09/11 22:18:26  scowan
 * Added more methods.
 *
 * Revision 1.35  2002/09/10 22:55:17  scowan
 * Added more methods.
 *
 * Revision 1.34  2002/09/10 21:04:02  scowan
 * Added element iterator and a method.
 *
 * Revision 1.33  2002/09/03 22:18:38  scowan
 * More virtual method moves.
 *
 * Revision 1.32  2002/08/29 22:13:29  scowan
 * Virtual method adjustment.
 *
 * Revision 1.31  2002/06/19 22:24:14  scowan
 * More method changes.
 *
 * Revision 1.30  2002/06/18 22:15:27  scowan
 * Added extract interface.
 *
 * Revision 1.29  2002/04/30 17:33:56  scowan
 * Change base make parm class name.
 *
 * Revision 1.28  2002/04/30 14:40:40  scowan
 * Removed namespace from inheritance.
 *
 * Revision 1.27  2002/04/30 14:03:17  scowan
 * More const.
 *
 * Revision 1.26  2002/04/26 22:44:55  scowan
 * Added more virtual methods.
 *
 * Revision 1.25  2002/03/01 16:19:37  scowan
 * Added virtual methods.
 *
 * Revision 1.24  2002/03/01 15:27:14  scowan
 * Added element id methods.
 *
 * Revision 1.23  2002/02/27 23:25:00  scowan
 * Added get element extents methods.
 *
 * Revision 1.22  2002/01/09 23:41:11  scowan
 * Avoid mass docs.
 *
 * Revision 1.21  2002/01/09 23:40:23  scowan
 * Added more default setup for makeparm constructor.
 *
 * Revision 1.20  2002/01/09 23:38:46  scowan
 * Moved makeparms out of the class and added more make parameters.
 *
 * Revision 1.19  2002/01/03 22:57:38  scowan
 * Added extents management methods.
 *
 * Revision 1.18  2001/10/08 20:49:54  scowan
 * Added element region method.
 *
 * Revision 1.17  2001/09/28 15:29:24  scowan
 * Added extetnts to the make parms.
 *
 * Revision 1.16  2001/07/31 16:40:43  scowan
 * Added new interface methods.
 *
 * Revision 1.15  2001/06/14 16:08:07  scowan
 * Changed source type.
 *
 * Revision 1.14  2001/06/13 22:32:06  scowan
 * Added to RVC namespace.
 *
 * Revision 1.13  2001/06/13 15:40:33  scowan
 * Changed objtype enum.
 * Added make methods.
 *
 * Revision 1.12  2001/06/12 15:40:35  scowan
 * Added comments.
 *
 * Revision 1.11  2001/05/31 19:27:49  scowan
 * Made methods read, write and add.
 *
 * Revision 1.10  2001/05/25 14:53:29  scowan
 * Added missing pure method.
 *
 * Revision 1.9  2001/05/24 17:37:36  scowan
 * Added virtual methods for finding objects.
 *
 * Revision 1.8  2001/04/24 14:25:16  scowan
 * More const.
 *
 * Revision 1.7  2001/04/23 22:52:10  scowan
 * Added find closest methods.
 *
 * Revision 1.6  2001/04/23 17:46:10  scowan
 * Added update extents.
 *
 * Revision 1.5  2000/12/01 16:04:10  scowan
 * Fixed MAC errors.
 *
 * Revision 1.4  2000/11/24 22:53:35  scowan
 * Add set extents virtual method.
 *
 * Revision 1.3  2000/11/17 15:48:29  scowan
 * Removed unnecessary include file.
 *
 * Revision 1.2  2000/10/19 21:17:48  scowan
 * Checked in for vacation.
 *
 * Revision 1.1  2000/10/02 17:40:21  scowan
 * Initial revision
 *
 * \endif
**/

//!   \class RVC::TIN rvc/tin.h
//!   \brief Manages RVC::OBJTYPE_TIN RVC objects.  
//!   
//!   The interface currently wraps the MfTIN functions.
//!   
//!   RVC Object Types that this class supports: RVC::OBJTYPE_TIN.
//!
//!   Default RVC Object Type for this class: RVC::OBJTYPE_TIN.
//!
//!   Valid parents for this class:
//!      - RVC::OBJTYPE_File
//!      - RVC::OBJTYPE_Folder

#ifndef INC_RVC_TIN_H
#define INC_RVC_TIN_H

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

#ifndef INC_MI32_RVCTIN_H
   #include <mi32/rvctin.h>
#endif

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

namespace RVC {

#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
class QSEARCHTREE;
#endif // GENERATING_DOXYGEN_OUTPUT

class TIN : public GEOMETRIC {
   public:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      class MAKEPARMS;
      #endif // GENERATING_DOXYGEN_OUTPUT

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

         // CONSTRUCTORS

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

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

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

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

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

         //! Destructor
         virtual ~ELEMITERATOR (
            ) {}

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

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

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

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

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

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

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

      typedef ELEMITERATOR<RVCTINEDGE> EDGEITERATOR;
      typedef ELEMITERATOR<RVCTINHULL> HULLITERATOR;
      typedef ELEMITERATOR<RVCTINNODE> NODEITERATOR;
      typedef ELEMITERATOR<RVCTINTRIANGLE> TRIANGLEITERATOR;
      
      //! Default constructor
      TIN (
         );

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

      //! Destructor
      virtual ~TIN (
         );

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

      //! Add an edge to the TIN object
      //! @return Number of the added edge element or < 0 if error
      INT32 Add (
         const RVCTINEDGE& edge
         );

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

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

      //! Add a triangle to the TIN object
      //! @return Number of the added triangle element or < 0 if error
      INT32 Add (
         const RVCTINTRIANGLE& triangle
         );
         
      //! Compute the elevation at a given (x,y) point
      //! @return 0 if the point was outside a hull, >0 if elevation was calculated, <0 error
      int ComputeElevation (
         DPOINT3D& pt                  //!< Point to compute elevation at, result stored in pt.z
         );
         
      //! Compute plane coefficients for a given triangle
      ERRVALUE ComputePlaneCoefficients (
         INT32 TriangleNum,
         double& A,
         double& B,
         double& C,
         double& D
         );

      //! Obtain an element iterator to the beginning of the element list
      template <class _ELEM> ELEMITERATOR<_ELEM> ElementBegin (
         ELEMITERATOR<_ELEM> item
         ) const {
         return (ELEMITERATOR<_ELEM>(this));
         }

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

      //! Get MAKEPARM values from current TIN object instance       
      ERRVALUE GetMakeParms (
         RVC::TIN::MAKEPARMS& MakeParms
         ) const;
         
      //! Obtain next available edge ID for edge ID table
      //! @return Next available edge ID
      INT32 GetNextEdgeID (
         ) const;

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

      //! Obtain next available triangle ID for triangle ID table
      //! @return Next available triangle ID
      INT32 GetNextTriangleID (
         ) const;
      
      //! Obtain number of edges in the TIN object
      //! @return Number of edges
      INT32 GetNumEdges (
         ) const;

      //! Obtain number of edges in a hull
      //! @return Number of hull edges
      INT32 GetNumHullEdges (
         INT32 hullnum           //!< Hull to get number of edges of
         ) const;

      //! Obtain number of islands in a hull
      //! @return Number of hull islands
      INT32 GetNumHullIslands (
         INT32 hullnum           //!< Hull to get number of islands of
         ) const;

      //! Obtain number of hulls in the TIN object
      //! @return Number of hulls
      INT32 GetNumHulls (
         ) const;

      //! Obtain number of edges in a node
      //! @return Number of node edges
      INT32 GetNumNodeEdges (
         INT32 NodeNum           //!< Node to get number of edges of
         ) const;

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

      //! Obtain number of triangles in the TIN object
      //! @return Number of triangles
      INT32 GetNumTriangles (
         ) const;

      //! Obtain current xy tolerance for this object
      //! @return Minimum distance between two nodes
      double GetTolerance (
         ) const;

      //! Create new TIN object given parent object, name, description, creation parameters, and source
      ERRVALUE Make (
         const RVC::OBJECT& parent,
         const RVC::OBJECTNAME& name,
         const RVC::OBJECTDESC& desc,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );
      
      //! Create new TIN object given parent object, name, description, creation parameters, and source
      ERRVALUE Make (
         const RVC::OBJITEM& ObjItem,
         const MAKEPARMS& MakeParms,
         const char* Source = 0
         );
      
      //! Read a TIN edge element
      ERRVALUE Read (
         INT32 EdgeNum,          //!< Edge number to read
         RVCTINEDGE& Edge        //!< Edge element RETURNED
         ) const;

      //! Read a TIN hull element
      ERRVALUE Read (
         INT32 hullnum,          //!< Hull number ot read
         RVCTINHULL& hull        //!< Hull element RETURNED
         ) const;

      //! Read a TIN node element
      ERRVALUE Read (
         INT32 nodenum,          //!< Node number to read
         RVCTINNODE& node        //!< Node element RETURNED
         ) const;

      //! Read a TIN triangle element
      ERRVALUE Read (
         INT32 trinum,           //!< Triangle number to read
         RVCTINTRIANGLE& triangle   //!< Triangle element RETURNED
         ) const;

      //! Read list of edges that make up the hull
      ERRVALUE ReadHullEdges (
         INT32 hullnum,          //!< Hull number to read edge list of
         INT32 start,            //!< Start position to read hull edge list
         INT32 count,            //!< Maximum number of edges to read
         SIMPLE_ARRAY<RVCTINHULLEDGE>& edges    //!< List of hull edges read into
         ) const;

      //! Read list of islands that are in the hull
      ERRVALUE ReadHullIslands (
         INT32 hullnum,          //!< Hull number to read island list of
         INT32 start,            //!< Start position to read hull islands list
         INT32 count,            //!< Maximum number of islands to read
         SIMPLE_ARRAY<INT32>& islands     //!< List of hull islands read into
         ) const;

      //! Read list of edges that are attached to the node
      ERRVALUE ReadNodeEdges (
         INT32 nodenum,                //!< Node number to read edge list of
         SIMPLE_ARRAY<INT32>& EdgeList //!< List of node edges read into
         ) const;

      //! Read list of edges that are attached to the node
      ERRVALUE ReadNodeEdges (
         INT32 nodenum,          //!< Node number to read edge list of
         INT32 start,            //!< Start position to read node edge list
         INT32 count,            //!< Maximum number of edges to read
         SIMPLE_ARRAY<INT32>& Edges //!< List of node edges read into
         ) const;

      //! Set next available edge ID for edge ID table
      ERRVALUE SetNextEdgeID (
         INT32 NextEdgeID
         );

      //! Set next available node ID for node ID table
      ERRVALUE SetNextNodeID (
         INT32 NextNodeID
         );

      //! Set next available triangle ID for triangle ID table
      ERRVALUE SetNextTriangleID (
         INT32 NextTriangleID
         );
      
      //! Set current xy tolerance for this object
      ERRVALUE SetTolerance (
         double tolerance
         );

      //! Swap hull edge lists between two hulls
      ERRVALUE SwapHullEdges (
         INT32 hullnum1,
         INT32 hullnum2
         );

      //! Swap node edge lists between two nodes
      ERRVALUE SwapNodeEdges (
         INT32 node1, 
         INT32 node2
         );
      
      //! Write a TIN edge element
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 edgenum,             //!< Edge number to write 
         const RVCTINEDGE& edge        //!< Edge element to write
         );

      //! Write a TIN hull element
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 hullnum,             //!< Hull number to write 
         const RVCTINHULL& hull        //!< Hull element to write
         );

      //! Write a TIN node element
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 nodenum,             //!< Node number to write 
         const RVCTINNODE& node        //!< Node element to write
         );

      //! Write a TIN triangle element
      //! Does not update element nor object extents
      ERRVALUE Write (
         INT32 TriangleNum,            //!< Triangle number to write
         const RVCTINTRIANGLE& triangle   //!< Triangle element to write
         );

      //! Write hull edge list
      //! Does not update element nor object extents
      ERRVALUE WriteHullEdges (
         INT32 hullnum,             //!< Hull number to write edge list to
         const SIMPLE_ARRAY<RVCTINHULLEDGE>& edges    //!< Hull edge list to write
         );

      //! Write hull edge list
      //! Does not update element nor object extents
      ERRVALUE WriteHullEdges (
         INT32 hullnum,             //!< Hull number to write edge list to
         INT32 total,               //!< Total number of edges for this hull
         INT32 start,               //!< Start position to write hull edge list
         INT32 count,               //!< Number of edges to write
         const SIMPLE_ARRAY<RVCTINHULLEDGE>& edges    //!< Hull edge list to write
         );

      //! Write hull island list
      //! Does not update element nor object extents
      ERRVALUE WriteHullIslands (
         INT32 hullnum,             //!< Hull number to write island list to     
         INT32 total,               //!< Total number of islands for this hull   
         INT32 start,               //!< Start position to write hull island list
         INT32 count,               //!< Number of islands to write              
         const INT32 *islands       //!< Hull island list to write               
         );

      //! Write node edge list
      //! Does not update element nor object extents
      ERRVALUE WriteNodeEdges (
         INT32 nodenum,             //!< Node number to write edge list to
         const SIMPLE_ARRAY<INT32>& EdgeList
         );

      //! Write node edge list
      //! Does not update element nor object extents
      ERRVALUE WriteNodeEdges (
         INT32 nodenum,             //!< Node number to write edge list to
         INT32 NumEdges,            //!< Total number of edges for this node
         INT32 start,               //!< Start position to write node edge list
         INT32 count,               //!< Number of edges to write
         const SIMPLE_ARRAY<INT32>& EdgeList
         );

   protected:

      ERRVALUE ClearNodeEdgeList ();
      ERRVALUE SetNumEdges (INT32 NewNumEdges);
      ERRVALUE SetNumHulls (INT32 NewNumHulls);
      ERRVALUE SetNumNodes (INT32 NewNumNodes);
      ERRVALUE SetNumTriangles (INT32 NewNumTriangles);

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
   
      //! Implementation of RVC::OBJECT virtual methods
      virtual ERRVALUE v_CloseObject ();
      virtual OBJTYPE v_GetDftObjectType () const;
      virtual bool v_IsObjectOpen () const;
      virtual ERRVALUE v_OpenObject (OPENMODE OpenFlags, MDLGPARENT parent);

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

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

      //! No values are unchangeable in header

      int m_TinID;
      mutable QSEARCHTREE *m_NodeQTree;
      mutable QSEARCHTREE *m_EdgeQTree;
      mutable QSEARCHTREE *m_TriQTree;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };


//! Necessary tin object creation parameters    
class TIN::MAKEPARMS : public RVC::GEOMETRIC::MAKEPARMSBASE {
   public:
      //! Default constructor
      MAKEPARMS (
         ) :
         GEOMETRIC::MAKEPARMSBASE(GEOMETRIC::POINTTYPE_3DXYZ),
         m_ZOffset(0.0),
         m_NextEdgeID(1),
         m_NextNodeID(10),
         m_NextTriangleID(1),
         m_tolerance(0.0)        //! Need to add at the end of the day
         {}

      //! Template constructor
      MAKEPARMS (
         const RVC::TIN& Object
         );

      //! Obtain next TIN edge ID value
      //! @return Next TIN edge ID value
      INT32 GetNextEdgeID (
         ) const {return (m_NextEdgeID);}

      //! Obtain next TIN Node ID value
      //! @return Next TIN node ID value
      INT32 GetNextNodeID (
         ) const {return (m_NextNodeID);}

      //! Obtain next TIN Triangle ID value
      //! @return Next TIN triangle ID value
      INT32 GetNextTriangleID (
         ) const {return (m_NextTriangleID);}

      //! Obtain current xy tolerance for this object
      //! @return Minimum distance between two nodes
      double GetTolerance (
         ) const { return (m_tolerance); }

      //! Get TIN z offset value
      //! @return TIN Z offset value
      double GetZOffset (
         ) const {return (m_ZOffset);}

      //! Set TIN edge next element ID value       
      void SetNextEdgeID (
         INT32 NextEdgeID
         ) {m_NextEdgeID = NextEdgeID;}
         
      //! Set TIN Node next element ID value       
      void SetNextNodeID (
         INT32 NextNodeID
         ) {m_NextNodeID = NextNodeID;}
         
      //! Set TIN triangle next element ID value
      void SetNextTriangleID (
         INT32 NextTriangleID
         ) {m_NextTriangleID = NextTriangleID;}
         
      //! Set current xy tolerance for this object
      void SetTolerance (
         double tolerance
         ) { m_tolerance = tolerance; }
         
      //! Set TIN Z offset value
      void SetZOffset (
         double zoffset
         ) {m_ZOffset = zoffset;}
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      double m_ZOffset;
      INT32 m_NextEdgeID;
      INT32 m_NextNodeID;
      INT32 m_NextTriangleID;
      double m_tolerance;        //!< Need to add at the end of the day
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     //! End of RVC namespace

#endif   //!< INC_RVC_TIN_H

---