mi32/tinrc16.h

Go to the documentation of this file.

#ifndef  INC_MI32_TINRC16_H
#define  INC_MI32_TINRC16_H

#ifndef  INC_MI32_DELEGATE_H
#include <mi32/delegate.h>
#endif

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

#ifndef  INC_MI32_DOUBLEAR_H
#include <mi32/doublear.h>
#endif

#ifndef  INC_MI32_POINT_H
#include <mi32/point.h>
#endif

//=====================================================================================================================

class TIN_RC16 {
   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT
      
      struct EDGE {
         INT32 m_NodeStart;
         INT32 m_NodeEnd;
         INT32 m_TriangleLeft;
         INT32 m_TriangleRight;
         UINT32 m_Length2;
         };

      struct TRIANGLE {
         INT32 m_Node[3];
         INT32 m_Edge[3];

         int GetNodePosOpposite (INT32 EdgeIdx) const
            { return ((m_Edge[1] == EdgeIdx) ? 0 : (m_Edge[2] == EdgeIdx) ? 1 : 2); }
         };

      #endif

   public:

      struct NODE {
         INT16 m_row;
         INT16 m_col;
         };

      struct PLANE {
         double m_Zrow;
         double m_Zcol;
         double m_Z0;
         };

      struct TRINODE {
         NODE m_Node[3];

         void CalcNormal (
            const double *values,   
            DPOINT3D& normal        
            ) const;

         void CalcPlane (
            const double *values,   
            PLANE& plane            
            ) const;
         };

      class FILLER {
         public:
            FILLER (const TIN_RC16& tin);

            virtual ~FILLER ();

            void Process ();

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const TIN_RC16& m_tin;

            void FillTriangle (const TRIANGLE& triangle);
            #endif

            // Overridables.

            virtual void v_FillBegin (
               const TRINODE& trinode
               );

            virtual void v_FillSpan (
               INT16 row,
               INT16 col, 
               UINT16 num
               ) = 0;
         };

      class FILLER_MEM_DOUBLE : public FILLER {
         public:

            FILLER_MEM_DOUBLE (
               const TIN_RC16& tin,
               double *data,
               UINT16 NumRows,
               UINT16 NumCols
               );

            ~FILLER_MEM_DOUBLE ();

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            double *m_data;
            INT32 m_NumRows;
            INT32 m_NumCols;
            PLANE m_Plane;

            INT32 CalcIdx (INT16 row, INT16 col) const
               { return (row * m_NumCols + col); }

            virtual void v_FillBegin (const TRINODE& trinode);
            virtual void v_FillSpan (INT16 row, INT16 col, UINT16 num);
            #endif
         };

      typedef fastdelegate::FastDelegate<double(INT16,INT16)> DELEGATE_GETVALUE;

      TIN_RC16 ();

      ~TIN_RC16 ();

      ERRVALUE AddRowCells (
         INT16 row,                             
         const INT16 *columns,                  
         UINT32 NumColumns                      
         );

      ERRVALUE CalcNodeNormals (
         DELEGATE_GETVALUE DelegateGetValue,    
         double rowscale,
         double colscale,
         DOUBLE_ARRAY<DPOINT3D>& NodeNormals    
         ) const;

      ERRVALUE Finalize ();

      const SIMPLE_ARRAY<NODE>& GetNodes () const
         { return (m_Nodes); }

      ERRVALUE Initialize ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      INT32 m_RowPrev;
      SIMPLE_ARRAY<NODE> m_Nodes;
      SIMPLE_ARRAY<EDGE> m_Edges;
      SIMPLE_ARRAY<INT32> m_EdgeIdxTop;
      SIMPLE_ARRAY<INT32> m_EdgeIdxBottom;
      SIMPLE_ARRAY<INT32> m_EdgeIdxWork;
      SIMPLE_ARRAY<INT32> m_EdgeIdxTest;
      SIMPLE_ARRAY<INT32> m_TriangleIdxTest;
      SIMPLE_ARRAY<TRIANGLE> m_Triangles;

      ERRVALUE DoRowNodes (INT16 row, INT32& NodeIdx);

      INT32 EdgeAdd (INT32 NodeIdx1, INT32 NodeIdx2);

      void EdgeTestAdd (INT32 EdgeIdx, INT32 TriangleIdx);

      int EdgeTestCell (const EDGE& Edge, INT16 row, INT16 col) const
         { return (NodesTestCell(Edge.m_NodeStart,Edge.m_NodeEnd,row,col)); }

      int EdgeTestCell (INT32 EdgeIdx, INT16 row, INT16 col) const
         { return (EdgeTestCell(m_Edges[EdgeIdx],row,col)); }

      void EdgeTestResplit (INT32 EdgeIdx, INT32 TriangleIdx);

      void EdgeTestSliver (INT32 EdgeIdx, SIMPLE_ARRAY<INT32>& EdgeIdxTest);

      INT32 NodeAdd (INT16 row, INT16 col);

      UINT32 NodeCalcDistance2 (INT32 NodeIdx1, INT32 NodeIdx2) const
         {
         INT32 drow = m_Nodes[NodeIdx2].m_row - m_Nodes[NodeIdx1].m_row;
         INT32 dcol = m_Nodes[NodeIdx2].m_col - m_Nodes[NodeIdx1].m_col;
         return (drow*drow + dcol*dcol);
         }

      int NodesTestCell (INT32 NodeIdxStart, INT32 NodeIdxEnd, INT16 row, INT16 col) const
         { return (NodesTestCell(m_Nodes[NodeIdxStart],m_Nodes[NodeIdxEnd],row,col)); }

      int NodesTestCell (const NODE& NodeStart, const NODE& NodeEnd, INT16 row, INT16 col) const
         {
         INT32 drows = NodeEnd.m_row - NodeStart.m_row;
         INT32 dcols = NodeEnd.m_col - NodeStart.m_col;
         INT32 trows = row - NodeStart.m_row;
         INT32 tcols = col - NodeStart.m_col;
         return (dcols * trows - drows * tcols);   // < 0 if left, > 0 if right
         }

      ERRVALUE TriangleAdd (INT32 NodeIdx0, INT32 NodeIdx1, INT32 NodeIdx2, INT32 EdgeIdx01, INT32 EdgeIdx12, INT32 EdgeIdx20);
      bool TriangleTestNodeInCircle (const TRIANGLE& Triangle, const NODE& Node) const;

   #if defined(WIN32) && defined(DEBUG)
      void TriangleAssertValid (INT32 TriangleIdx) const;
   #endif

      TIN_RC16 (const TIN_RC16&);
      TIN_RC16& operator= (const TIN_RC16&);

      #endif
   };

//=====================================================================================================================

#endif   // INC_MI32_TINRC16_H

---