mi32/rpovrgn.h

Go to the documentation of this file.

#ifndef  INC_MI32_RPOVRGN_H
#define  INC_MI32_RPOVRGN_H

#ifndef  INC_MI32_LINERAST_H
#include <mi32/linerast.h>
#endif

#ifndef  INC_MI32_FILLPOLY_H
#include <mi32/fillpoly.h>
#endif

#ifndef  INC_MI32_STATUNIVAR_H
#include <mi32/statunivar.h>
#endif

#ifndef  INC_RVC_NULLMASK_H
#include <rvc/nullmask.h>
#endif

#ifndef  INC_MI32_TRIANGULATOR_H
#include <mi32/triangulator.h>
#endif


class RASTER_REGION_PROP_CALC {
   public:

      enum BOUNDARYCELLS {
         BOUNDARYCELLS_IncludeAll     = 1,
         BOUNDARYCELLS_IncludeCenter  = 2,
         BOUNDARYCELLS_Proportionally = 3,
         BOUNDARYCELLS_ExcludeAll     = 4
         };

      void Clear ();

      bool Initialize (
         RVC::OBJITEM& objitem
         );

      bool IsInitialized () { return m_Initialized; };

      RASTER_REGION_PROP_CALC (
         ) : m_Initialized(false), m_FPSpan(this), m_LRSpan(this) {};

      ERRVALUE Compute (
         REGION2D& region,
         STAT_UNIVARIATE& statistics, 
         const BOUNDARYCELLS boundarycells
         );

      ERRVALUE Compute (
         REGION2D& region,
         RANGE<double>& range,
         const BOUNDARYCELLS boundarycells
         );

   private:
      #ifndef GENERATING_DOXYGEN_OUTPUT

      enum MODE {
         MODE_Statistics = 0,
         MODE_Range      = 1
         };

      class FPSPAN : public FILLPOLYGON::SPAN {
         public:

            FPSPAN (
               RASTER_REGION_PROP_CALC* operation
               ) :
               m_Operation(operation)
               { }

         private:
            RASTER_REGION_PROP_CALC* m_Operation;

            FPSPAN ();
            void VProcess (const double x1, const double x2, const double y);
         };

      class LRSPAN : public LINERASTERIZER2D::SPAN {
         public:

            LRSPAN (
               RASTER_REGION_PROP_CALC* operation
               ) :
               m_Operation(operation),
               m_Add(true)
               { }

            void Set (
               const bool add
               ) { m_Add = add; return; };

         private:

            void v_Process (
               const INT32 colmin, 
               const INT32 colmax, 
               const INT32 lin
               ) { m_Operation->ProcessSpan(colmin, colmax, lin, m_Add); };

            void v_ProcessSpan (
               const double x1,
               const double y1,
               const double x2,
               const double y2
               );

            LRSPAN ();

            RASTER_REGION_PROP_CALC* m_Operation;
            bool m_Add;
         };

      RVC::RASTER m_Raster;
      RVC::IMAGE::CONVMODE m_Convmode;
      RVC::NULLMASK m_NullMask;
      RVC::RASTER m_Mask;
      RVC::OBJECT m_File;
      TRIANGULATOR m_Triangulator;
      DOUBLE_ARRAY<DTRIANGLE2D> m_Triangles;

      bool m_Initialized;

      MODE m_Mode;
      STAT_UNIVARIATE* m_Statistics;
      RANGE<double>* m_Range;

      LRECT2D m_Extents;
      SIMPLE_ARRAY<UINT8> m_Data;
      SIMPLE_ARRAY<UINT8> m_NullBuffer;
      SIMPLE_ARRAY<UINT8> m_Buffer;
      SIMPLE_ARRAY<UINT8> m_Buffer0;
      SIMPLE_ARRAY<UINT8> m_Buffer1;
      FPSPAN m_FPSpan;
      LRSPAN m_LRSpan;
      POLYLINE m_Polyline;

      ERRVALUE ProcessX (const DTRIANGLE2D& triangle);
      ERRVALUE ProcessEQX (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessNEQX (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessLtoR (const DPOINT2D& left, const DPOINT2D& tr, const DPOINT2D& br);
      ERRVALUE ProcessRtoL (const DPOINT2D& right, const DPOINT2D& tl, const DPOINT2D& bl);

      ERRVALUE ProcessY (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessEQY (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessNEQY (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessTtoB (const DPOINT2D& top, const DPOINT2D& b1, const DPOINT2D& b2);
      ERRVALUE ProcessBtoT (const DPOINT2D& bottom, const DPOINT2D& t1, const DPOINT2D& t2);

      ERRVALUE Process (const DPOINT2D& p1, const DPOINT2D& p2, const DPOINT2D& p3);
      ERRVALUE ProcessSpan (const INT32 column1, const INT32 column2, const INT32 line, const bool add = true);

      ERRVALUE FillMaskWithCenters (const REGION2D& region);
      ERRVALUE ProcessBoundary(const REGION2D& region, const bool add); 
      ERRVALUE ProcessProportionally(const REGION2D& region);  
      ERRVALUE ComputeStatisticsFromMask();
      ERRVALUE ClearMask();

      ERRVALUE Accumulate (UINT32 NumValues, const void* vpValues, const UINT8* pValidity = 0);
      template<typename _CT> ERRVALUE Extend (UINT32 NumValues, const _CT* vpValues, const UINT8* pValidity = 0);
      ERRVALUE AccumulateWeighted (const void* vpValue, double weight);
      
      #endif   // GENERATING_DOXYGEN_OUTPUT
   };

#endif   // INC_MI32_TRIANGUL_H

---