rvc/tintool.h

Go to the documentation of this file.

/********************************************************************
* \file rvc/tintool.h
* \brief TIN manipulation functions include file
*
* \if NODOC
* $Id: tintool.h_v 1.10 2011/12/23 14:18:35 mju Exp $
*
* $Log: tintool.h_v $
* Revision 1.10  2011/12/23 14:18:35  mju
* Remove redundant hdrs.
*
* Revision 1.7  2005/10/20 17:01:28  scowan
* Quadtree and geometric interface changes supported.
*
* Revision 1.1  2002/10/04 21:40:32  scowan
* Initial revision
* \endif
*********************************************************************/

#ifndef  INC_RVC_TINTOOL_H
#define  INC_RVC_TINTOOL_H

#ifndef  INC_RVC_TIN_H
   #include <rvc/tin.h>
#endif

#ifndef  INC_RVC_DBTNODE_H
   #include <rvc/dbtnode.h>
#endif

#ifndef  INC_RVC_DBTEDGE_H
   #include <rvc/dbtedge.h>
#endif

#ifndef  INC_RVC_DBTTRI_H
   #include <rvc/dbttri.h>
#endif

#ifndef  INC_RVC_DBTHULL_H
   #include <rvc/dbthull.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward Declarations
class POLYLINE;
class POLYLINELIST;
namespace RVC {
   class TINTOOLKITOBSERVER;
   class VECTOR;
   }
#endif // GENERATING_DOXYGEN_OUTPUT


namespace RVC {

#define TINCLIPMODE_Include   1
#define TINCLIPMODE_Exclude   2

class TINTOOLKIT : public SUBJECT<TINTOOLKITOBSERVER> {
   public:
   
      TINTOOLKIT (
         );

      ~TINTOOLKIT (
         );
         
      ERRVALUE AddLine (
         const POLYLINE& PolyLine,
         bool HasElevation = true
         );
         
      int AddNode (
         const DPOINT3D& P,
         bool TryOutside = true
         );
         
      ERRVALUE AddSegment (
         const DPOINT3D& start,
         const DPOINT3D& end,
         UINT8 type,
         bool HasElevation    
         );
         
      ERRVALUE AddVectorBreaklines (
         const RVC::OBJITEM& VectObjItem
         );
         
      ERRVALUE ApplyExclude (
         const POLYLINELIST& ExcludeList
         );
         
      ERRVALUE BuildNodeEdgeList (
         );
      
      ERRVALUE ClipByVector (
         const RVC::OBJITEM& VectObjItem,
         int ClipMode      
         );
         
      ERRVALUE Close (
         bool ForceClose = false
         );
         
      ERRVALUE ComputeExtents (
         );
         
      ERRVALUE ComputeStatistics (
         );
         
      ERRVALUE CreateMinSpanTree (
         const RVC::OBJITEM& VectObjItem
         );
         
      ERRVALUE CreateTIN (
         const POLYLINE& Nodes,
         double zscale,
         double zoffset,
         double xytolerance
         );
         
      ERRVALUE DeleteEdgeHole (
         INT32 EdgeNum
         );
         
      ERRVALUE DeleteEdges (
         const SIMPLE_ARRAY<INT32>& EdgeList
         );
         
      ERRVALUE DeleteNode (
         INT32 NumNode
         );
         
      ERRVALUE DeleteNodeHole (
         INT32 NodeNum
         );
         
      ERRVALUE DeleteNodes (
         const SIMPLE_ARRAY<INT32>& NodeList
         );
         
      ERRVALUE DeleteNodesHole (
         const SIMPLE_ARRAY<INT32>& NodeList
         );
         
      ERRVALUE DeleteTriangleHole (
         INT32 TriNum
         );
         
      ERRVALUE DeleteTriangles (
         const SIMPLE_ARRAY<INT32>& TriList
         );
         
      ERRVALUE GenerateTIN (
         const POLYLINE& Pool,   
         const POLYLINE* Clip,      
         const POLYLINELIST& Exclude, 
         INT32 Flag 
         );
         
      int GetConnectedNodeList (
         INT32 Num,
         SIMPLE_ARRAY<INT32>& list  
         );
         
      ERRVALUE GetConnectedNodes (
         INT32 NodeNum,
         SIMPLE_ARRAY<RVCTINNODE>& NodeArray,
         SIMPLE_ARRAY<INT32>& NodeList 
         );
   
      ERRVALUE GetEdgeAzimuth (
         INT32 NodeNum,
         const RVCTINEDGE& Edge,
         double& Angle  
         );
         
      ERRVALUE GetElementExtents (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         DRECT3D& Extents
         ) const;

      INT32 GetNodeEdges (
         INT32 Num,
         SIMPLE_ARRAY<INT32>& edgelist
         );
         
      INT32 GetNumElements (
         ELEMTYPE ElemType
         ) const;

      ERRVALUE GetSurroundTriangles (
         INT32 NodeNum, 
         SIMPLE_ARRAY<INT32>& TriList, 
         SIMPLE_ARRAY<INT32>& EdgeList, 
         SIMPLE_ARRAY<INT32>& NodeList
         );
      
      ERRVALUE GetTrianglesPoly (
         const POLYLINE& PolyLine,
         SIMPLE_ARRAY<INT32>& TList 
         );
         
      double GetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum
         ) const;
         
      ERRVALUE MedianFiltering (
         );
         
      ERRVALUE Open (
         const RVC::OBJITEM& TinObjItem
         );
         
      ERRVALUE Open (
         const RVC::TIN& TinObj
         );

      ERRVALUE RebuildHulls (
         );
         
      ERRVALUE RebuildTIN (
         const BITSET* MaskSet
         );
         
      ERRVALUE RemoveFlatNodes (
         double dz,     
         double minedge 
         );
         
      ERRVALUE RemoveLongEdges (
         double distance   
         );
         
      ERRVALUE Save (
         OBJITEM& DestObjItem
         );
         
      ERRVALUE SetZValue (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         double zvalue
         );
         
      ERRVALUE ValidateTopology (
         INT32 flag  
         );
         
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
   
      class OPENTIN : public TIN {
         public:
         
            OPENTIN (
               ) : TIN() {}
         
            OPENTIN (
               const OPENTIN& rhs
               ) : TIN(rhs) {}
         
            virtual ~OPENTIN (
               ) {}
               
            ERRVALUE ClearNodeEdgeList (
               ) { return (TIN::ClearNodeEdgeList()); }
               
            ERRVALUE SetNumEdges (
               INT32 NewNumEdges
               ) { return (TIN::SetNumEdges(NewNumEdges)); }

            ERRVALUE SetNumHulls (
               INT32 NewNumHulls
               ) { return (TIN::SetNumHulls(NewNumHulls)); }

            ERRVALUE SetNumNodes (
               INT32 NewNumNodes
               ) { return (TIN::SetNumNodes(NewNumNodes)); }

            ERRVALUE SetNumTriangles (
               INT32 NewNumTriangles
               ) { return (TIN::SetNumTriangles(NewNumTriangles)); }

            ERRVALUE SwapNodeEdges (
               INT32 NewNodeNum, 
               INT32 OldNodeNum
               ) { return (TIN::SwapNodeEdges(NewNodeNum, OldNodeNum)); }
            
         };
   
      OPENTIN m_TinObj;
      DBASE_TINEDGE m_DBEdgeObj;
      DBASE_TINHULL m_DBHullObj;
      DBASE_TINNODE m_DBNodeObj;
      DBASE_TINTRIANGLE m_DBTriangleObj;
      bool m_DisableCallbacks;
      SIMPLE_ARRAY<INT32> m_NodeEdgeList;
      
      double SnapDist;
      UINT32 SnapOpt;
      
      void CallOnAdd (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnDelete (ELEMTYPE ElemType, INT32 ElemNum, INT32 OtherElemNum);
      void CallOnMoveBegin (ELEMTYPE ElemType, INT32 ElemNum);
      void CallOnMoveEnd (ELEMTYPE ElemType, INT32 ElemNum);
         
      INT32 AddEdgeRaw (INT32 nodefrom, INT32 nodeto, INT32 trileft, INT32 triright, const RVCTINNODE& Node1, const RVCTINNODE& Node2);
      ERRVALUE AddNodeOutside (const DPOINT3D& P);
      INT32 AddNodeRaw (const RVCTINNODE& Node);
      ERRVALUE AddTriangleRaw (RVCTINTRIANGLE& Triangle, const RVCTINNODE& Node1, const RVCTINNODE& Node2, const RVCTINNODE& Node3);
      ERRVALUE AddTriangleRefEdge (INT32 trinum, INT32 refedge, INT32 Node1, INT32 Node2);
      ERRVALUE ArbitraryTriangulation (const SIMPLE_ARRAY<INT32> List);
      ERRVALUE ChangeEdge (INT32 NumEdge, INT32 NewNode1, INT32 NewNode2, INT32 NewLeft, INT32 NewRight, const DRECT2D& Extents);
      ERRVALUE ChangeMinMax (ELEMTYPE ElemType, INT32 ElemNum, const DRECT2D& Extents);
      ERRVALUE ChangeNodeReferences (INT32 NewNum, INT32 OldNum);
      ERRVALUE CreateEdgeTable (INT32 TriStart);
      ERRVALUE DeleteEdgeRaw (INT32 EdgeNum);
      ERRVALUE DeleteNodeRawQuick (INT32 NodeNum);
      ERRVALUE DeleteNodeTemp (INT32 NodeNum);        
      ERRVALUE DeleteTriangleRaw (INT32 TriangleNum);
      ERRVALUE DetermineEdge (const DPOINT3D& P, INT32& EdgeNum);
      ERRVALUE DetermineTriangle (const DPOINT3D& P, INT32& TriNum);
      ERRVALUE DivideTwoTriangles (INT32 num, const RVCTINTRIANGLE& oldT, RVCTINNODE extNodes[4], int flag[3]);
      INT32 FindNextHullEdge (INT32& curnode, INT32& curedge);
      INT32 GenerateNewEdge (INT32 nodefrom, INT32 nodeto, INT32 trileft, INT32 triright);
      ERRVALUE GenerateNewTriangle (RVCTINTRIANGLE& Triangle);
      
      double GenerateThreshold (
         double resolution
         ) const {
         DRECT3D Extents;
         m_TinObj.GetExtents(Extents);
         double thresh = MIN(Extents.GetHeight(), Extents.GetWidth());
         return (fabs(thresh * resolution));
         }
      
      ERRVALUE GetAngle (INT32 Start, INT32 End, double& Angle);
      ERRVALUE GetEdgeLength (INT32 Num, double& length);
      ERRVALUE GetHullInfo (const SIMPLE_ARRAY<RVCTINHULLEDGE> HullEdgeArray, RVCTINHULL& Hull);
      int GetNodeConnection (INT32 Node1, INT32 Node2, INT32& edge, INT32& lefttri, INT32& righttri);
      ERRVALUE GetNodeTriangles (INT32 NodeNum, SIMPLE_ARRAY<INT32>& TriangleList);
      int GetNumConnection (INT32 N1, INT32 N2, INT32 N3);
      bool HasNodeEdgeLink ();
      ERRVALUE InsertEdge (const DPOINT3D& start, const DPOINT3D& end, UINT8 type);
      ERRVALUE InsertNode (INT32 TriNum, const DPOINT3D& Pos);
      int IsANode (const DPOINT3D& P, INT32& NodeNum);
      ERRVALUE IsCrossReferenced (INT32 TriNum, INT32 CheckNum);
      int IsTriangleInPolygon (const POLYLINE& PolyLine, INT32 TriNum);
      ERRVALUE MarkEdgeFromSide (INT32 NumEdge, INT32 Tnum, INT32 NewNum);
      ERRVALUE MarkTriangleFromSide (INT32 NumTri, INT32 Tnum, INT32 NewNum);
      ERRVALUE PlugInTriangle (INT32 Node1, INT32 Node2, INT32 Node3);
      ERRVALUE RemoveTriangleRaw (INT32 TriNum, INT32 NodeNum);
      ERRVALUE RestoreTopology (INT32 NumStart, INT32 *Array);
         
      ERRVALUE SortNodesArroundNode (INT32 Center, SIMPLE_ARRAY<INT32>& NodeList);
      ERRVALUE SupressTriangleRaw (INT32 TriNum, INT32 NodeNum);
      int SwapEdgesInTriangle (INT32 t1, INT32 t2);
      ERRVALUE Triangulation (SIMPLE_ARRAY<RVCTINNODE>& Nodes);
      ERRVALUE UpdateDatabase (ELEMTYPE ElemType);
      ERRVALUE UpdateEdgeRefTriangle (INT32 EdgeNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateEdgeSideRef (INT32 EdgeNum, INT32 start, INT32 end, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateNodeRefEdge (INT32 NodeNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateQTree (ELEMTYPE ElemType, INT32 NewElemNum, INT32 DeletedElemNum);
      ERRVALUE UpdateTriangleEdgeFlag (INT32 TriNum, INT32 EdgeNum, UINT8 flag);
      ERRVALUE UpdateTriangleRefEdge (INT32 TriNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateTriangleRefNode (INT32 TriNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateTriangleRefTriangle (INT32 TriNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE UpdateTriangleSideRef (INT32 TriNum, INT32 EdgeNum, INT32 NewNum, INT32 OldNum);
      ERRVALUE WriteEdgeAsSegment (INT32 EdgeNum, RVC::VECTOR& VectObj);
      #endif // GENERATING_DOXYGEN_OUTPUT
   };
   

class TINTOOLKITOBSERVER : public OBSERVER_BASE {
   public:

      TINTOOLKITOBSERVER (
         TINTOOLKIT& ttk
         ) : OBSERVER_BASE(ttk) {}
         
      virtual ~TINTOOLKITOBSERVER (
         ) {}
      
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      
      virtual void OnAdd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
      
      virtual void OnDelete (
         ELEMTYPE ElemType,
         INT32 ElemNum,
         INT32 OtherElemNum         
         );
      
      virtual void OnMoveBegin (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );

      virtual void OnMoveEnd (
         ELEMTYPE ElemType,
         INT32 ElemNum
         );
         
      friend class TINTOOLKIT;
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

}     // End of RVC namespace

#endif         // INC_RVC_TINTOOL_H

---