mi32/delaunay.h

Go to the documentation of this file.

#ifndef  INC_MI32_DELAUNAY_H
#define  INC_MI32_DELAUNAY_H

#ifndef INC_MI32_PTTRIANG_H
#include <mi32/pttriang.h>
#endif

#ifndef INC_MI32_ARRAYCACHE_H
#include <mi32/arraycache.h>
#endif

#ifndef INC_MI32_BALANCEDTREE_H
#include <mi32/balancedtree.h>
#endif

#ifndef INC_SET
#include <set>
#define INC_SET
#endif


class DELAUNAY {
   public:

      DELAUNAY (const double MaximumMemory = 128.0);

      ~DELAUNAY ();

      INT32 AddPoint2D (
         const DPOINT2D& point
         );

      INT32 AddPoint3D (
         const DPOINT3D& point
         );

      INT32 AddPoints (
         const DOUBLE_ARRAY<DPOINT2D>& points
         );

      INT32 AddPoints (
         const DOUBLE_ARRAY<DPOINT3D>& points
         );

      INT32 AddPoints (
         const POLYLINE& polyline
         );

      void Free (
         );

      INT32 GetNumNodes (
         ) const;

      INT32 GetNumEdges (
         ) const;

      INT32 GetNumTriangles (
         ) const;

      bool GetPoint2D (
         const INT32 node, 
         DPOINT2D& point
         );

      bool GetPoint3D (
         const INT32 node, 
         DPOINT3D& point
         );

      INT32 GetIndex (
         const INT32 node
         );

      INT32 GetNode (
         const INT32 index
         );

      bool GetEdgeInfo (
         const INT32 edge, 
         EDGEINFO& edgeinfo
         );

       bool GetTriangleInfo (
         const INT32 triangle, 
         TRIANGLEINFO& triangleinfo
         );

      double GetTolerance (
         ) const { return m_Tolerance; };

         bool IsTriangulated (
         ) const { return m_IsTriangulated; };

      ERRVALUE Triangulate (
         const double tolerance
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct QUADRUPLE {
         QUADRUPLE (
            const INT32 n1,
            const INT32 n2,
            const INT32 n3,
            const INT32 n4
            ) :
            node1(n1),
            node2(n2),
            node3(n3),
            node4(n4)
            {
            };

         bool operator < (
            const QUADRUPLE& q
            ) const {
            if (node1 < q.node1) return true;
            if (node1 > q.node1) return false;
            if (node2 < q.node2) return true;
            if (node2 > q.node2) return false;
            if (node3 < q.node3) return true;
            if (node3 > q.node3) return false;
            if (node4 < q.node4) return true;
            return false; 
            };
         const INT32 node1;
         const INT32 node2;
         const INT32 node3;
         const INT32 node4;
         };

      class TEST : public BALANCEDTREE<DPOINT3D>::TEST {
         public:
         TEST ()  { }
         virtual int v_TestItems (const DPOINT3D& p1, const DPOINT3D& pt);
         };

      class DUMP : public BALANCEDTREE<DPOINT3D>::DUMP {
      public:
         DUMP (DELAUNAY& delaunay) : m_Delaunay(delaunay), m_Count(0) { }
         INT32 GetCount () { return m_Count; }
         virtual ERRVALUE v_DumpItem (const DPOINT3D& p, INT32 tagnum);
      private:
         DELAUNAY& m_Delaunay;
         INT32 m_Count;
         };

      friend class DUMP;

      const INT32 m_NumOfPointsInMemoryLimit;

      bool m_IsTriangulated;
      double m_Tolerance;

      DOUBLE_ARRAY<DPOINT3D> m_Points;

      MILIST<INT32> m_WorkHull;  

      std::set<INT32> m_DirtyEdges;
      std::set<QUADRUPLE> m_Set;    

      RVC::OBJECT m_File;

      RVC::ARRAY m_PointsArray;
      RVC::ARRAY m_WorkPointsArray;
      RVC::ARRAY m_WorkZArray;
      RVC::ARRAY m_WorkNodesArray;
      RVC::ARRAY m_WorkIndicesArray;
      RVC::ARRAY m_WorkEdgesArray;
      RVC::ARRAY m_WorkTrianglesArray;

      ARRAYCACHE<DPOINT2D> m_WorkPointsCache;
      ARRAYCACHE<double> m_WorkZCache;
      ARRAYCACHE<INT32> m_WorkNodesCache;
      ARRAYCACHE<INT32> m_WorkIndicesCache;
      ARRAYCACHE<EDGEINFO> m_WorkEdgesCache;
      ARRAYCACHE<TRIANGLEEDGES> m_WorkTrianglesCache;

      PTTRIANGULATOR m_Triangulator;
      bool m_Hard; 

      static int ComparePoints(void*, void*, void*);

      DELAUNAY (           
         const DELAUNAY& rhs
         );

      DELAUNAY& operator= (            
         const DELAUNAY& rhs
         );

      ERRVALUE Init ();

      double ConvexTest (const INT32 n1, const INT32 n2, const INT32 n3);

      INT32 GetUncommonNode (const INT32 edge, const EDGEINFO& edgeinfo, const INT32 tedge);
      INT32 GetSideNode (const INT32 edge, const bool side);

      INT32 GetFrontEdge (const INT32 edge, const EDGEINFO& edgeinfo, const INT32 tedge, const bool front);
      INT32 GetSideFrontEdge (const INT32 edge, const bool side, const bool front);

      ERRVALUE ClearStructures ();
      ERRVALUE SortWorkNodes ();
      ERRVALUE FindFirstTriangle ();
      ERRVALUE ConstructAllTriangles ();

      ERRVALUE CheckDirtyEdges ();
      bool IsSwapNeeded (const INT32 edge);
      ERRVALUE SwapEdge (const INT32 edge);
      bool CircleTest (const INT32 bottomnode, const INT32 leftnode, const INT32 topnode, const INT32 rightnode); 
      
      #endif // GENERATING_DOXYGEN_OUTPUT
   };

#endif  // MI32_DELAUNAY_H

---