rvc/opcontouring.h

Go to the documentation of this file.

#ifndef  INC_RVC_CONTOURING_H
#define  INC_RVC_CONTOURING_H

#ifndef  INC_RVC_OPCOMPONENT_H
   #include <rvc/opcomponent.h>
#endif

#ifndef INC_RVC_VECTOR_H
   #include <rvc/vector.h>
#endif

#ifndef INC_MI32_QTREE_H
   #include <mi32/qtree.h>
#endif

#include <float.h>


#ifndef GENERATING_DOXYGEN_OUTPUT
// Forward declarations
namespace SPATREF {
   class COORDREFSYS;
   }
#endif


namespace RVC {
namespace OP {

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

class CONTOURING {
   public:

      enum SOURCE {
         SOURCE_Invalid = -1,
         SOURCE_First = 0,
         SOURCE_Raster = 0,
         SOURCE_TIN = 1,
         SOURCE_Last = 1,
         SOURCE_Count = 2
         };

      enum METHOD {
         METHOD_Invalid = -1,
         METHOD_First = 0,
         METHOD_Linear = 0,     
         METHOD_IterativeThresholding = 1,  
         METHOD_Last = 1,
         METHOD_Count = 2
         };

      class SOURCE_PARAMETERS {
         public:

            SOURCE_PARAMETERS (
               const SOURCE source
               );

            virtual ~SOURCE_PARAMETERS (
               );

            SOURCE GetSource (
               ) const { return m_Source; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            const SOURCE m_Source;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class RASTER_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            enum RESAMPLINGMETHOD {
               RESAMPLINGMETHOD_None = 0,
               RESAMPLINGMETHOD_BilinearInterpolation = 1,
               RESAMPLINGMETHOD_CubicConvolution = 2
               };

            enum SMOOTHINGMETHOD {
               SMOOTHINGMETHOD_None = 0,
               SMOOTHINGMETHOD_WeightedAverage = 1,
               SMOOTHINGMETHOD_Gaussian = 2,
               SMOOTHINGMETHOD_Quadratic = 3,
               SMOOTHINGMETHOD_Cubic = 4,
               SMOOTHINGMETHOD_Quartic = 5
               };

            enum WINDOWSIZE {
               WINDOWSIZE_3x3 = 3,
               WINDOWSIZE_5x5 = 5,
               WINDOWSIZE_7x7 = 7,
               WINDOWSIZE_9x9 = 9,
               WINDOWSIZE_11x11 = 11,
               WINDOWSIZE_13x13 = 13,
               WINDOWSIZE_15x15 = 15
               };

            RASTER_PARAMETERS (
               );

            ~RASTER_PARAMETERS (
               );

            RESAMPLINGMETHOD GetResamplingMethod (
               ) const { return m_ResamplingMethod; };

            UINT8 GetResolutionFactor (
               ) const { return m_ResolutionFactor; } 

            SMOOTHINGMETHOD GetSmoothingMethod (
               ) const { return m_SmoothingMethod; };

            WINDOWSIZE GetWindowSize (
               ) const { return m_WindowSize; };

            void SetResamplingMethod (
               const RESAMPLINGMETHOD method
               ) { m_ResamplingMethod = method; };

            UINT8 SetResolutionFactor (
               const UINT8 ResolutionFactor
               ) { 
               const UINT8 factor1 = ResolutionFactor >> 1;
               const UINT8 factor2 = bound(factor1, 1, 8);
               m_ResolutionFactor =  factor2 << 1;  
               return m_ResolutionFactor; 
               } 

            void SetSmoothingMethod (
               const SMOOTHINGMETHOD method
               ) { m_SmoothingMethod = method; };

            void SetWindowSize (
               const WINDOWSIZE size
               ) { m_WindowSize = size; };

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            RESAMPLINGMETHOD m_ResamplingMethod;
            UINT8 m_ResolutionFactor;
            SMOOTHINGMETHOD m_SmoothingMethod;
            WINDOWSIZE m_WindowSize;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class TIN_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            TIN_PARAMETERS (
               );

            ~TIN_PARAMETERS (
               );

            const OP::COMPONENT& GetComponent (
               ) const { return m_Component; };

            void SetComponent (
               const OP::COMPONENT& element
               ) { m_Component = element; };

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            OP::COMPONENT m_Component;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class DESTINATION_PARAMETERS {
         public:

            DESTINATION_PARAMETERS (
               );

            ~DESTINATION_PARAMETERS (
               );

            bool GetCreateElevationRangeTable (
               ) const { return m_CreateElevationRangeTable; }

            void SetCreateElevationRangeTable (
               const bool create
               ) { m_CreateElevationRangeTable = create; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            bool m_CreateElevationRangeTable;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class METHOD_PARAMETERS {
         public:

            METHOD_PARAMETERS (
               const METHOD method
               );

            virtual ~METHOD_PARAMETERS (
               );

            METHOD GetMethod (
               ) const { return m_Method; }

            double GetStartingLevel (
               ) const { return m_StartingLevel; }

            double GetEndingLevel (
               ) const { return m_EndingLevel; }

            double GetInterval (
               ) const { return m_Interval; }

            double GetZScale (
               ) const { return m_ZScale; }

            double GetZOffset (
               ) const { return m_ZOffset; }

            void SetStartingLevel (
               const double StartingLevel
               ) { m_StartingLevel = StartingLevel; }

            void SetEndingLevel (
               const double EndingLevel
               ) {m_EndingLevel = EndingLevel; }

            void SetInterval (
               const double Interval
               ) { m_Interval = Interval; }

            void SetZScale (
               const double ZScale
               ) { m_ZScale = ZScale; }

            void SetZOffset (
               const double ZOffset
               ) { m_ZOffset = ZOffset; } 

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT

            const METHOD m_Method;

            double m_StartingLevel;
            double m_EndingLevel;
            double m_Interval;
            double m_ZScale;
            double m_ZOffset;

            METHOD_PARAMETERS (
               ); // not implemented

            static METHOD Check (
               const METHOD method
               );

            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class LINEAR_PARAMETERS : public METHOD_PARAMETERS {
         public:

            LINEAR_PARAMETERS (
               ) :
               METHOD_PARAMETERS(METHOD_Linear)
               { } 

            ~LINEAR_PARAMETERS (
               ) { }

         };

      class ITERATIVETHRESHOLDING_PARAMETERS : public METHOD_PARAMETERS {
         public:

            ITERATIVETHRESHOLDING_PARAMETERS (
               )  :
               METHOD_PARAMETERS(METHOD_IterativeThresholding)
               {}

            ~ITERATIVETHRESHOLDING_PARAMETERS (
               ) {}

         };

      class SEGMENTS {
         public:

            // Constructor.
            SEGMENTS ();

            ~SEGMENTS ();

            ERRVALUE Add (
               const DPOINT3D& p1,
               const DPOINT3D& p2
               );

            void Clear (
               );

            ERRVALUE Init (
               const RVC::OBJITEM& objitem,
               const DRECT3D& extents
               );

            ERRVALUE Trace (
               const bool force = false 
               );

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            struct SEGMENT {
               DPOINT3D m_Left;
               DPOINT3D m_Right;
               bool m_IsTheSameZ;
               bool m_IsUsed;    

               SEGMENT (
                  ) :
                  m_IsTheSameZ(true),
                  m_IsUsed(false)
                  { }
               };

            RVC::VECTOR m_Vector;
            QUADTREE m_QTree;
            POLYLINE m_Polyline;
            POLYLINE m_Baseline;
            POLYLINE m_Joinline;
            POLYLINE m_Templine;
            SIMPLE_ARRAY<SEGMENT> m_Segments;
            SIMPLE_ARRAY<INT32> m_ListA;
            SIMPLE_ARRAY<INT32> m_ListB;

            double m_Tolerance;

            static int Compare (SEGMENT* p1, SEGMENT* p2, void* );
            static double Distance (const DPOINT2D& p1, const DPOINT2D& p2);

            ERRVALUE ReplaceNode (const DPOINT2D& op, const DPOINT2D& np, const INT32 itemnum);
            int Snap (POLYLINE& polyline);
            ERRVALUE Store (POLYLINE& polyline);
            ERRVALUE StoreSimple (POLYLINE& polyline, const INT32 linenum);

            #endif // GENERATING_DOXYGEN_OUTPUT

         };


      static ERRVALUE Process (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const METHOD_PARAMETERS* MethodParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessLinearFromTIN (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const TIN_PARAMETERS& TINParameters,
         const LINEAR_PARAMETERS& LinearParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessFromRaster (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const RASTER_PARAMETERS& RasterParameters,
         const METHOD_PARAMETERS* MethodParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessLinearFromRaster (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const RASTER_PARAMETERS& RasterParameters,
         const LINEAR_PARAMETERS& LinearParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessIterativeThresholdingFromRaster (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const RASTER_PARAMETERS& RasterParameters,
         const ITERATIVETHRESHOLDING_PARAMETERS& IterThresParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ComputeFromTriangle (
         const DPOINT3D& A,                        
         const DPOINT3D& B,                        
         const DPOINT3D& C,                        
         double start,                             
         double end,                               
         double interval,                          
         FastDelegate<ERRVALUE(const DPOINT3D&, const DPOINT3D&)> DelegateContourSegment  
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      static ERRVALUE ProcessDestination (
         const RVC::OBJITEM& DestObjItem, 
         const DESTINATION_PARAMETERS& DestParameters 
         );
      #endif // GENERATING_DOXYGEN_OUTPUT
          
   };

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

}  // end namespace OP
}  // end namespace RVC


#endif  // INC_RVC_OPPROFILING_H

---