rvc/optriangulation.h

Go to the documentation of this file.

#ifndef  INC_RVC_OPTRIANGULATION_H
#define  INC_RVC_OPTRIANGULATION_H

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

#ifndef  INC_MI32_SPATREF_H
#include <mi32/spatref.h>
#endif

#ifndef  INC_RVC_OBJITEM_H
#include <rvc/objitem.h>
#endif

#include <float.h>


namespace RVC {
namespace OP {

class TRIANGULATION {
   public:

      enum SOURCE {
         SOURCE_Invalid = -1,
         SOURCE_First = 0,
         SOURCE_Raster = 0,
         SOURCE_Table = 1,
         SOURCE_Vector = 2,
         SOURCE_Shape = 3,
         SOURCE_Last = 3,
         SOURCE_Count = 4
         };

      enum METHOD {
         METHOD_Invalid = -1,
         METHOD_First = 0,
         METHOD_Delaunay = 0,     
         METHOD_AdaptiveDensification = 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
            SOURCE_PARAMETERS (
               );

            const SOURCE m_Source;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class RASTER_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            RASTER_PARAMETERS (
               );

            ~RASTER_PARAMETERS (
               );

         private:
         };

      class TABLE_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            enum NAME {
               NAME_XField = 0,
               NAME_YField = 1,
               NAME_ZField = 2,
               NAME_Count = 3
               };

            TABLE_PARAMETERS (
               );

            ~TABLE_PARAMETERS (
               );

            const SPATREF::COORDREFSYS& GetCoordRefSys (
               ) const { return (m_CoordRefSys); }

            const COMPONENT& GetComponent (
               ) const { return (m_Pin); }

            void GetName (
               const NAME id,
               RVC::OBJECTNAME& name
               ) const;

            const MISTRING& GetQuery (
               ) const { return (m_Query); }

            UINT8 GetXUnitCode (
               ) const { return (m_XUnitCode); }

            UINT8 GetYUnitCode (
               ) const { return (m_YUnitCode); }

            UINT8 GetZUnitCode (
               ) const { return (m_ZUnitCode); }

            void SetCoordRefSys (
               const SPATREF::COORDREFSYS& crs
               ) { m_CoordRefSys = crs; }

            void SetComponent (
               const COMPONENT& component
               ) { m_Pin = component; }

            void SetName (
               const NAME id,
               const RVC::OBJECTNAME& name
               );

            void SetQuery (
               const MISTRING& query
               ) { m_Query = query; }

            void SetXUnitCode (
               const UINT8 unitcode
               ) { m_XUnitCode = unitcode; }

            void SetYUnitCode (
               const UINT8 unitcode
               ) { m_YUnitCode = unitcode; }

            void SetZUnitCode (
               const UINT8 unitcode
               ) { m_ZUnitCode = unitcode; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            COMPONENT m_Pin;
            RVC::OBJECTNAME m_Names[NAME_Count];
            SPATREF::COORDREFSYS m_CoordRefSys;
            MISTRING m_Query;
            UINT8 m_XUnitCode;
            UINT8 m_YUnitCode;
            UINT8 m_ZUnitCode;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class VECTOR_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            enum TYPE {
               TYPE_Point = 0,
               TYPE_Line = 1
               };

            VECTOR_PARAMETERS (
               );

            ~VECTOR_PARAMETERS (
               );

            bool GetComponent (
               const TYPE type,
               COMPONENT& component
               ) const;

            const OP::COMPONENT& GetComponentLine (
               ) const { return (m_Line); }

            const OP::COMPONENT& GetComponentPoint (
               ) const { return (m_Point); }

            void SetComponent (
               const TYPE type,
               const COMPONENT& component
               );

            void SetComponentLine (
               const OP::COMPONENT& component
               ) { m_Line = component; }

            void SetComponentPoint (
               const OP::COMPONENT& component
               ) { m_Point = component; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            COMPONENT m_Point;
            COMPONENT m_Line;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class SHAPE_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            SHAPE_PARAMETERS (
               );

            ~SHAPE_PARAMETERS (
               );

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

            void SetComponent (
               const COMPONENT& component
               ) { m_Component = component; }

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


      class DESTINATION_PARAMETERS {
         public:

            DESTINATION_PARAMETERS (
               );

            ~DESTINATION_PARAMETERS (
               );

            bool GetApplyBreaklines (
               ) const;

            bool GetApplyClipping (
               ) const;

            const RVC::OBJITEM& GetBreaklinesObjItem (
               ) const;

            INT32 GetClipMethod (
               ) const;

            const RVC::OBJITEM& GetClipObjItem (
               ) const;

            bool GetComputeStatistics (
               ) const;

            double GetMaximumEdgeLength (
               ) const;

            bool GetOptimize (
               ) const;

            double GetMinimumEdgeLength (
               ) const;

            double GetZTolerance (
               ) const;

            void SetApplyBreaklines (
               const bool apply
               ) ;

            void SetApplyClipping (
               const bool apply
               );

            void SetBreaklinesObjItem (
               const RVC::OBJITEM& ObjItem
               ) ;

            void SetClipMethod (
               const INT32 method 
               );

            void SetClipObjItem (
               const RVC::OBJITEM& ObjItem
               );

            void SetComputeStatistics (
               const bool compute
               );

            void SetMaximumEdgeLength (
               const double length
               );

            void SetOptimize (
               const bool optimize
               );

            void SetMinimumEdgeLength (
               const double length
               );;

            void SetZTolerance (
               const double tolerance
               ); ;


         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT

            bool m_Optimize;
            double m_ZTolerance;
            double m_MinimumEdgeLength;
            double m_MaximumEdgeLength;

            bool m_ApplyBreaklines;
            RVC::OBJITEM m_BreaklinesObjItem;

            bool m_ApplyClipping;
            RVC::OBJITEM m_ClipObjItem;
            INT32 m_ClipMethod;

            bool m_ComputeStatistics;

            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class METHOD_PARAMETERS {
         public:

            METHOD_PARAMETERS (
               const METHOD method
               );

            virtual ~METHOD_PARAMETERS (
               );

            METHOD GetMethod (
               ) const;

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            const METHOD m_Method;

            METHOD_PARAMETERS (); // not implemented

            static METHOD Check (
               const METHOD method
               );

            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class DELAUNAY_PARAMETERS : public METHOD_PARAMETERS {
         public:

            DELAUNAY_PARAMETERS (); 

            ~DELAUNAY_PARAMETERS ();

            double GetTolerance (
               ) const { return (m_Tolerance); }

            double GetZScale (
               ) const { return (m_ZScale); }

            double GetZOffset (
               ) const { return (m_ZOffset); }

            double GetMaximumMemory (
               ) const { return (m_MaximumMemory); }

            double SetTolerance (
               const double tolerance
               );

            double SetZScale (
               const double ZScale
               );

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

            void SetMaximumMemory (
               const double MaximumMemory
               ) { m_MaximumMemory = MaximumMemory; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT

            double m_Tolerance;
            double m_ZScale;
            double m_ZOffset;
            double m_MaximumMemory;

            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class ADAPTIVEDENSIFICATION_PARAMETERS : public METHOD_PARAMETERS {
         public:

            ADAPTIVEDENSIFICATION_PARAMETERS (
               );

            ~ADAPTIVEDENSIFICATION_PARAMETERS (
               );

            double GetAccuracy (
               ) const { return (m_Accuracy); }

            INT32 GetNodeLimit (
               ) const { return (m_NodeLimit); }

            double SetAccuracy (
               const double accuracy
               );

            INT32 SetNodeLimit (
               const INT32 NodeLimit
               );

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT

            double m_Accuracy;
            INT32 m_NodeLimit;

            #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 ProcessDelaunay (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const DELAUNAY_PARAMETERS& MethodParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

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

   private:

      static ERRVALUE ProcessDestination (
         RVC::OBJITEM& DestObjItem, 
         const DESTINATION_PARAMETERS& DestParameters 
         );
          
   };

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


#endif  // INC_RVC_OPTRIANGULATION_H

---