rvc/opvectorgridgeneration.h

Go to the documentation of this file.

#ifndef  INC_RVC_OPVECTORGRIDGENERATION_H
#define  INC_RVC_OPVECTORGRIDGENERATION_H

#ifndef INC_RVC_VECTTOOL_H
   #include <rvc/vecttool.h>
#endif

#ifndef  INC_MI32_UNITCONV_H
   #include <mi32/unitconv.h>
#endif


#ifndef GENERATING_DOXYGEN_OUTPUT
class UNSIGNEDSET;
class QUADTREE;
struct GRIDENUMDEF2;
#endif


namespace RVC {
namespace OP {

class VECTOR_GRID_GENERATION {
   public:

      enum MODE {
         MODE_None = 0,
         MODE_Triangle,
         MODE_Square,
         MODE_Rectangle,
         MODE_Hexagon,
         MODE_Parallel,
         MODE_RandomRectangle,
         MODE_Count
         };

      enum ENUMERATION {
         ENUMERATION_SymbolicColumn = 0,
         ENUMERATION_SymbolicRow,
         ENUMERATION_SymbolicColumnRow,
         ENUMERATION_NumericRow,
         ENUMERATION_NumericColumn,
         ENUMERATION_NumericRowColumn,
         ENUMERATION_NumericSequential,
         ENUMERATION_NumericSerpentine,
         ENUMERATION_Count
         };

      class GRID_PARMS {
         public:

            GRID_PARMS ();
            GRID_PARMS (VECTOR_GRID_GENERATION::MODE mode);
            ~GRID_PARMS () { }

            void CopyOrientParmsFrom (
               const VECTOR_GRID_GENERATION::GRID_PARMS& OrientParms
               );

            bool DoBuildTables (
               ) { return (m_BuildTables); }

            VECTOR_GRID_GENERATION::MODE GetMode () const
               { return (m_mode); }

            double GetOrientAngle (
               ) { return m_oangle; }

            DPOINT2D& GetOrientEnd (
               ) { return m_oend; }

            DPOINT2D& GetOrientRadius (
               ) { return m_oradius; }

            DRECT2D& GetOrientRect (
               ) { return m_orect; }

            DPOINT2D& GetOrientStart ()
               { return m_ostart; }

            void SetBuildTables (
               bool build 
               ) { m_BuildTables = build; }

            void SetOrientAngle (
               double angle 
               ) { m_oangle = angle; }

            void SetOrientEnd (
               DPOINT2D& end 
               ) { m_oend = end; }

            void SetOrientStart (
               DPOINT2D& start 
               ) { m_ostart = start; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            VECTOR_GRID_GENERATION::MODE m_mode;
            DPOINT2D m_ostart;
            DPOINT2D m_oend;
            DPOINT2D m_oradius;
            double m_oangle;
            DRECT2D m_orect;
            bool m_BuildTables;
            #endif
         };

      class TRIANGLE_PARMS : public GRID_PARMS {
         public:
            TRIANGLE_PARMS ();
            
            double GetSideConv (
               ) { return (ConvertUnit(m_side, &m_ucSide)); }

            double m_side;
            UNITCONV m_ucSide;
         };

      class RECTANGLE_PARMS : public GRID_PARMS {
         public:
            RECTANGLE_PARMS ();
      
            double GetWidthConv (
               ) { return (ConvertUnit(m_width, &m_ucWidth)); }

            double GetHeightConv (
               ) { return (ConvertUnit(m_height, &m_ucHeight)); }

            double m_height;
            UNITCONV m_ucHeight;
            double m_width;
            UNITCONV m_ucWidth;
         };

      class HEXAGON_PARMS : public GRID_PARMS {
         public:
            HEXAGON_PARMS ();
            
            double GetSideConv (
               ) { return (ConvertUnit(m_side, &m_ucSide)); }

            double m_side;
            UNITCONV m_ucSide;
         };

      class RANDOMRECTANGLE_PARMS : public GRID_PARMS {
         public:
            RANDOMRECTANGLE_PARMS ();
            
            double GetMinWidthConv (
               ) { return (ConvertUnit(m_minWidth, &m_ucLength)); }

            double GetMinHeightConv (
               ) { return (ConvertUnit(m_minHeight, &m_ucLength)); }

            double GetMaxWidthConv (
               ) { return (ConvertUnit(m_maxWidth, &m_ucLength)); }

            double GetMaxHeightConv (
               ) { return (ConvertUnit(m_maxHeight, &m_ucLength)); }

            double m_minWidth;
            double m_maxWidth;
            double m_minHeight;
            double m_maxHeight;
            UNITCONV m_ucLength;
         };

      class PARALLEL_PARMS : public GRID_PARMS {
         public:
            PARALLEL_PARMS ();

            double GetWidthConv (
               ) { return (ConvertUnit(m_width, &m_ucWidth)); }
            
            bool IgnoreOrigin (
               ) { return (m_ignoreO); }

            void SetIgnoreOrigin (
               bool ignoreO
               ) { 
               m_ignoreO = ignoreO;
               return;
               };
            
            double m_width;
            UNITCONV m_ucWidth;
            bool m_ignoreO;   
         };

      VECTOR_GRID_GENERATION ();

      ~VECTOR_GRID_GENERATION ();

      ERRVALUE ComputeLRWidth (double *LWidth, double *RWidth, GRID_PARMS* GridParms);

      ERRVALUE MakeQTreeOfBoundary (RVC::VECTOR& VectObj, const UNSIGNEDSET *pSelectedPolygonSet = 0);

      ERRVALUE Process (
         RVC::VECTOR& VectObj, 
         RVC::OBJITEM& GridObj, 
         GRID_PARMS *GridParms, 
         const UNSIGNEDSET *pSelectedPolygonSet = 0
         ); 

      ERRVALUE SetGridScale ();

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      struct GRIDSHAPE {
         DPOINT2D origin;
         DPOINT2D vect1;
         INT32 num1;
         INT32 enum1;
         DPOINT2D vect2;
         INT32 num2;
         INT32 enum2;
         INT32 numSegm;
         INT32 ia[5];
         INT32 ja[5];
         int s[5];
         int asign;
         DPOINT2D va;
         INT32 im;
         INT32 jm;
         INT32 numPoints;
         DOUBLE_ARRAY<DPOINT2D> GPoints;
         DOUBLE_ARRAY<DPOINT2D> APoints;
         double minv1;
         double maxv1;
         double minv2;
         double maxv2;
         DOUBLE_ARRAY<double> randomv1;
         DOUBLE_ARRAY<double> randomv2;
         DRECT2D rect;
         double tol;
         QUADTREE* qth;
         INT32 numseg;
         INT32 maxseg;
         UINT8 *flagseg;

         ERRVALUE GetSegment (INT32 num, DPOINT2D *vect);
         };

      class EXTSTR {
         public:

            EXTSTR ();
            ~EXTSTR ();

            ERRVALUE ComputeConvexIn ();
            ERRVALUE GetRadiusIn (const DPOINT2D& Point, double theta, double beta, double *Radius);
            ERRVALUE InsertTo (const DPOINT2D& Point);

         private:
            int m_InsFlag;
            DPOINT2D m_GPoint;
            DOUBLE_ARRAY<DPOINT2D> m_Points;
         };

      struct TOPOLINE {
         INT32 num;
         INT32 left;
         INT32 right;
         UINT8 flag;
         };

      RVC::VECTOR m_BorderObj;
      RVC::VECTOR m_GridObj;
      QUADTREE *m_qth;
      UINT8 *m_flagseg;
      GRID_PARMS* m_GridParms;
      double m_xscale;
      double m_yscale;
      GRIDSHAPE m_shape;
      INT32 m_numlines;
      SIMPLE_ARRAY<TOPOLINE> m_topoline;
      INT32 m_numpolys;
      INT32 m_numseg;
      INT32 m_numselseg;
      EXTSTR *m_pExtStr;
      bool m_gefields[ENUMERATION_Count];

      ERRVALUE BuildGridCellDataTable ();
      ERRVALUE CopyQTreeOfBoundary ();
      ERRVALUE DivideSegment (DPOINT2D *Point, DRECT2D  *ext, DOUBLE_ARRAY<DPOINT2D>&Points, INT32 *count);
      void FreeGridShapePoints ();
      void FreeGridShapeQTree ();
      void FreeQtreeOfBoundary ();
      ERRVALUE GenerateExtStr (const UNSIGNEDSET *pSelectedPolygonSet);
      ERRVALUE GenerateIntersectionPoints (DPOINT2D *Point, DPOINT2D **Points);
      ERRVALUE GenerateRowColumnRecord (DPOINT2D Point, INT32 *row, INT32 *col, GRIDENUMDEF2 *genum);
      void GenerateRowRecord (INT32 r, GRIDENUMDEF2 *genum);
      UINT8 GetFlagSegIndexed (INT32 index) const
         { return m_flagseg[index]; }
      void GetRowColumnCoor (DPOINT2D Point, INT32 *row, double *col);
      QUADTREE* GetQuadTreeHandle () const
         { return m_qth; }
      double GetXScale () const
         { return m_xscale; }
      double GetYScale () const
         { return m_yscale; }
      ERRVALUE InsideArea (double x, double y);
      ERRVALUE MakeGrid ();
      ERRVALUE MakeGridPoints ();
      ERRVALUE MakeGridShape ();
      ERRVALUE MakeGridVector (RVC::OBJITEM& GridObjItem);
      void MakeScaledVector (DPOINT2D *vect);
      ERRVALUE Segmentation (DPOINT2D *Point, DRECT2D  *rect, INT32 *count);
      ERRVALUE SnapGridPointsToBoundary ();
      ERRVALUE WriteBoundary (INT32 *count);
      ERRVALUE WriteSegment (INT32 count, DPOINT2D *vect);

      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

} // End namespace OP
} // End namespace RVC


#endif   // INC_RVC_OPVECTORGRIDGENERATION_H

---