rvc/opsurfacefitting.h

Go to the documentation of this file.

#ifndef  INC_RVC_OPSURFACEFITTING_H
#define  INC_RVC_OPSURFACEFITTING_H

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

#include <float.h>

#ifndef  INC_MI32_KRIGING_H
#include <mi32/kriging.h>
#endif

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

#ifndef  INC_MI32_POLYLINE_H
#include <mi32/polyline.h>
#endif

#ifndef  INC_RVC_RASTER_H
#include <rvc/raster.h>
#endif


namespace RVC {
namespace OP {

class SURFACEFITTING {
   public:

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

      enum METHOD {
         METHOD_Invalid = -1,
         METHOD_First = 0,
         METHOD_MinimumCurvature = 0,
         METHOD_UnivariateCurve = 1,
         METHOD_InverseDistance = 2,
         METHOD_Profiles = 3,
         METHOD_Polynomial = 4,
         METHOD_Kriging = 5,
         METHOD_TriangleInterpolation = 6,
         METHOD_Bidirectional = 7,
         METHOD_Last = 7,
         METHOD_Count = 8
         };

      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 VECTOR_PARAMETERS : public SOURCE_PARAMETERS {
         public:

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

            VECTOR_PARAMETERS (
               );

            ~VECTOR_PARAMETERS (
               );

            VECTOR_PARAMETERS& operator= (
               const 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 OP::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 TIN_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            enum TYPE {
               TYPE_Node = 0,
               TYPE_Edge = 1,
               TYPE_Triangle = 2
               };

            TIN_PARAMETERS (
               );

            ~TIN_PARAMETERS (
               );

            TIN_PARAMETERS& operator= (
               const TIN_PARAMETERS& 
               );

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

            const OP::COMPONENT& GetComponentEdge (
               ) const { return (m_Edge); }

            const OP::COMPONENT& GetComponentNode (
               ) const { return (m_Node); }

            const OP::COMPONENT& GetComponentTriangle (
               ) const { return (m_Triangle); }

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

            void SetComponentEdge (
               const OP::COMPONENT& component
               ) { m_Edge = component; }

            void SetComponentNode (
               const OP::COMPONENT& component
               ) { m_Node = component; }

            void SetComponentTriangle (
               const OP::COMPONENT& component
               ) { m_Triangle = component; }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            COMPONENT m_Node;
            COMPONENT m_Edge;
            COMPONENT m_Triangle;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      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 (
               );

            TABLE_PARAMETERS& operator= (
               const 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 SHAPE_PARAMETERS : public SOURCE_PARAMETERS {
         public:

            SHAPE_PARAMETERS (
               );

            ~SHAPE_PARAMETERS (
               );

            SHAPE_PARAMETERS& operator= (
               const 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 (
               );

            RVC::IMAGE::CELLTYPE GetCellType (
               ) const { return m_CellType; }

            UINT16 GetCompressionQualityRatio (
               ) const { return m_CompressionQualityRatio; }

            RVC::RASTER::COMPTYPE GetCompressionType (
               ) const { return m_CompressionType; }

            INT32 GetNumColumns (
               ) const { return m_NumColumns; }

            INT32 GetNumLines (
               ) const { return m_NumLines; }

            const TRANS2D_MAPGEN& GetTransformation (
               ) const { return m_Transformation; }

            void SetCellType (
               const RVC::IMAGE::CELLTYPE CellType
               ) { m_CellType = CellType; }

            void SetCompressionQualityRatio (
               const UINT16 CompressionQualityRatio
               ) { m_CompressionQualityRatio = CompressionQualityRatio; }

            void SetCompressionType (
               const RVC::RASTER::COMPTYPE CompressionType
               ); 
            void SetNumColumns (
               const INT32 NumColumns
               ) { m_NumColumns = NumColumns; }

            void SetNumLines (
               const INT32 NumLines
               ) { m_NumLines = NumLines; }

            void SetTransformation (
               const TRANS2D_MAPGEN& transformation
               );

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            INT32 m_NumLines;
            INT32 m_NumColumns;
            RVC::IMAGE::CELLTYPE m_CellType;
            TRANS2D_MAPGEN m_Transformation;
            RVC::RASTER::COMPTYPE m_CompressionType;
            UINT16 m_CompressionQualityRatio;

            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class METHOD_PARAMETERS {
         public:

            METHOD_PARAMETERS (
               const METHOD method
               );

            virtual ~METHOD_PARAMETERS (
               );

            UINT16 GetBlankDistance (
               ) const { return (m_BlankDistance); }

            METHOD GetMethod (
               ) const { return m_Method; }

            void SetBlankDistance (
               UINT16 BlankDistance                
               ) { m_BlankDistance = BlankDistance; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT

            const METHOD m_Method;
            UINT16 m_BlankDistance;

            METHOD_PARAMETERS (
               ); // not implemented

            static METHOD Check (
               const METHOD method
               );

            #endif // GENERATING_DOXYGEN_OUTPUT

         };

      class MINIMUMCURVATURE_PARAMETERS : public METHOD_PARAMETERS {
         public:

            enum CURVATURE {
               CURVATURE_Linear = 0,
               CURVATURE_Logarithmic = 1
               };

            enum DUPLICATE {
               DUPLICATE_First = 0,
               DUPLICATE_Minimum,
               DUPLICATE_Maximum,
               DUPLICATE_Last
               };

            enum INITIALIZATION {
               INITIALIZATION_InverseDistance = 0,
               INITIALIZATION_Profiles = 1
               };

            enum GRIDRATIO {
               GRIDRATIO_1 = 1,
               GRIDRATIO_2 = 2,
               GRIDRATIO_4 = 4,
               GRIDRATIO_8 = 8,
               GRIDRATIO_16 = 16
               };

            enum SEARCHAREA {
               SEARCHAREA_Circle = 0,
               SEARCHAREA_Square = 1,
               SEARCHAREA_Diamond = 2
               };

            MINIMUMCURVATURE_PARAMETERS (
               ); 

            double GetAllowedVariation (
               ) const { return m_AllowedVariation; }

            CURVATURE GetCurvature (
               ) const { return m_Curvature; }

            DUPLICATE GetDuplicateHandling (
               ) const { return (m_DuplicateHandling); }

            GRIDRATIO GetGridRatio ( 
               ) const { return m_GridRatio; }

            INITIALIZATION GetInitialization (
               ) const { return m_Initialization; }

            int GetDistanceUnit (
               ) const { return m_DistanceUnit; }

            double GetMatchingTolerance (
               ) const { return m_MatchingTolerance; }

            INT32 GetMaximumIterations (
               ) const { return m_MaximumIterations; }

            double GetMinimumMatches (
               ) const { return m_MinimumMatches; }

            SEARCHAREA GetSearchArea (
               ) const { return m_SearchArea; }

            double GetSearchDistance (
               ) const { return m_SearchDistance; }

            double GetTension (
               ) const { return m_Tension; }

            double GetWeightingPower (
               ) const { return m_WeightingPower; }

            double SetAllowedVariation (
               const double variation
               ) { m_AllowedVariation = MAX(0.0, variation); return m_AllowedVariation; }

            void SetCurvature (
               const CURVATURE curvature
               ) { m_Curvature = curvature; }

            void SetDuplicateHandling (
               DUPLICATE DuplicateHandling
               ) { m_DuplicateHandling = DuplicateHandling; }

            void SetGridRatio (
               const GRIDRATIO gridratio
               ) { m_GridRatio = gridratio; }

            void SetInitialization (
               const INITIALIZATION initialization
               ) { m_Initialization = initialization; }

            void SetDistanceUnit (
               const int unit 
               ) { m_DistanceUnit = unit; }

            double SetMatchingTolerance (
               const double tolerance
               ) { m_MatchingTolerance = MAX(tolerance, 0.0); return m_MatchingTolerance; }

            INT32 SetMaximumIterations (
               const INT32 iterations
               ) { m_MaximumIterations = bound(iterations, 1, 1000); return m_MaximumIterations; }

            double SetMinimumMatches (
               const double matches
               ) { m_MinimumMatches = bound(matches,10.0, 100.0); return m_MinimumMatches; }

            void SetSearchArea (
               const SEARCHAREA area 
               ) { m_SearchArea = area; }

            double SetSearchDistance (
               const double distance 
               ) { m_SearchDistance = bound(distance, DBL_MIN, DBL_MAX); return m_SearchDistance; }

            double SetTension (
               const double tension 
               ) { m_Tension = bound(tension, 0.0, 1.0); return m_Tension; }

            double SetWeightingPower (
               const double power 
               ) { m_WeightingPower = bound(power, 1.0, 20.0); return m_WeightingPower; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            CURVATURE m_Curvature;
            GRIDRATIO m_GridRatio;
            INITIALIZATION m_Initialization;
            DUPLICATE m_DuplicateHandling;
            SEARCHAREA m_SearchArea;
            INT32 m_MaximumIterations;
            int m_DistanceUnit;
            double m_AllowedVariation;
            double m_MatchingTolerance;
            double m_MinimumMatches;
            double m_SearchDistance;
            double m_Tension;
            double m_WeightingPower;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class UNIVARIATECURVE_PARAMETERS : public METHOD_PARAMETERS {
         public:

            enum INTERPOLATION {
               INTERPOLATION_Linear = 0,
               INTERPOLATION_Cubic = 1,
               INTERPOLATION_Hermite = 2
               };

            enum SLOPE {
               SLOPE_Linear = 0,
               SLOPE_Quadratic = 1
               };

            UNIVARIATECURVE_PARAMETERS (
               ); 

            SLOPE GetSlope (
               ) const { return m_Slope; }

            INTERPOLATION GetInterpolation (
               ) const { return m_Interpolation; }

            void SetSlope (
               const SLOPE slope
               ) { m_Slope = slope; }

            void SetInterpolation (
               const INTERPOLATION interpolation
               ) {m_Interpolation = interpolation; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            INTERPOLATION m_Interpolation;
            SLOPE m_Slope;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class INVERSEDISTANCE_PARAMETERS : public METHOD_PARAMETERS {
         public:

            enum SEARCHAREA {
               SEARCHAREA_Circle = 0,
               SEARCHAREA_Square = 1,
               SEARCHAREA_Diamond = 2
               };

            INVERSEDISTANCE_PARAMETERS (
               ); 

            int GetDistanceUnit (
               ) const { return m_DistanceUnit; }

            SEARCHAREA GetSearchArea (
               ) const { return m_SearchArea; }

            double GetSearchDistance (
               ) const { return m_SearchDistance; }

            double GetWeightingPower (
               ) const { return m_WeightingPower; }

            void SetDistanceUnit (
               const int unit 
               ) { m_DistanceUnit = unit; }

            void SetSearchArea (
               const SEARCHAREA area 
               ) { m_SearchArea = area; }

            double SetSearchDistance (
               const double distance 
               ) { m_SearchDistance = bound(distance, DBL_MIN, DBL_MAX); return m_SearchDistance; }

            double SetWeightingPower (
               const double power 
               ) { m_WeightingPower = bound(power, 1.0, 20.0); return m_WeightingPower; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            double m_SearchDistance;
            int m_DistanceUnit;
            SEARCHAREA m_SearchArea;
            double m_WeightingPower;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class PROFILES_PARAMETERS : public METHOD_PARAMETERS {
         public:

            PROFILES_PARAMETERS (
               ); 

            int GetDistanceUnit (
               ) const { return m_DistanceUnit; }

            double GetSearchDistance (
               ) const { return m_SearchDistance; }

            void SetDistanceUnit (
               const int unit 
               ) { m_DistanceUnit = unit; }

            double SetSearchDistance (
               const double distance 
               ) { m_SearchDistance = bound(distance, DBL_MIN, DBL_MAX); return m_SearchDistance; }


            private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            double m_SearchDistance;
            int m_DistanceUnit;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class POLYNOMIAL_PARAMETERS : public METHOD_PARAMETERS {
         public:

            POLYNOMIAL_PARAMETERS (
               ); 

            UINT8 GetOrder (
               ) const { return m_Order; }

            bool GetSaveCoefficients (
               ) const { return m_SaveCoefficients; }

            UINT8 SetOrder (
               const UINT8 order
               ) { m_Order = bound(order, 1, 20); return m_Order; }

            void SetSaveCoefficients (
               const bool save
               ) { m_SaveCoefficients = save; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            UINT8 m_Order;
            bool m_SaveCoefficients;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class KRIGING_PARAMETERS : public METHOD_PARAMETERS {
         public:


            KRIGING_PARAMETERS (
               ); 

            const KRIGING& GetKriging (
               ) const;

            KRIGING& GetKriging (
               );

            bool GetMakeDrift (
               ) const { return m_MakeStandardError; }

            bool GetMakeStandardError (
               ) const { return m_MakeDrift; }

            void SetMakeDrift (
               const bool make
               ) { m_MakeStandardError = make; }

            void SetMakeStandardError (
               const bool make
               ) { m_MakeDrift = make; }


         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            KRIGING m_Kriging;
            bool m_MakeStandardError;
            bool m_MakeDrift;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class TRIANGLEINTERPOLATION_PARAMETERS : public METHOD_PARAMETERS {
         public:

            enum INTERPOLATION {
               INTERPOLATION_Linear = 0,
               INTERPOLATION_Quintic = 1,
               INTERPOLATION_ModifiedQuintic = 2,
               INTERPOLATION_Nonic = 3
               };

            TRIANGLEINTERPOLATION_PARAMETERS (
               ); 

            INTERPOLATION GetInterpolation (
               ) const { return m_Interpolation; }

            void SetInterpolation (
               const INTERPOLATION interpolation
               ) { m_Interpolation = interpolation; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            INTERPOLATION m_Interpolation;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class BIDIRECTIONAL_PARAMETERS : public METHOD_PARAMETERS {
         public:

            enum DIRECTIONTYPE {
               DIRECTIONTYPE_Manual = 0,
               DIRECTIONTYPE_Auto = 1
               };

            BIDIRECTIONAL_PARAMETERS (
               ); 

            POLYLINE::SPLINE GetAcrossLineSplineType (
               ) const { return m_AcrossLineSplineType; }

            POLYLINE::SPLINE GetAlongLineSplineType (
               ) const { return m_AlongLineSplineType; }

            double GetAzimuth (
               ) const { return m_Azimuth; }

            DIRECTIONTYPE GetDirectionType (
               ) const { return m_DirectionType; }

            void SetAcrossLineSplineType (
               const POLYLINE::SPLINE spline
               ) { m_AcrossLineSplineType = spline; }

            void SetAlongLineSplineType (
               const POLYLINE::SPLINE spline
               ) { m_AlongLineSplineType = spline; }

            void SetAzimuth (
               const double azimuth
               ) { m_Azimuth = azimuth; }

            void SetDirectionType (
               const DIRECTIONTYPE type
               ) { m_DirectionType = type; }

         private:

            #ifndef GENERATING_DOXYGEN_OUTPUT
            POLYLINE::SPLINE m_AlongLineSplineType;
            POLYLINE::SPLINE m_AcrossLineSplineType;
            DIRECTIONTYPE m_DirectionType;
            double m_Azimuth;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class GEOMETRIC_ITERATOR {
         public:

            GEOMETRIC_ITERATOR (
               ) {
               }

            virtual ~GEOMETRIC_ITERATOR (
               ) {}

            GEOMETRIC_ITERATOR& operator++ (
               ) { return (v_Increment()); }
               
            INT64 GetElementID (
               ) const { return (v_GetElementID()); }

            double GetPosition (
               ) const { return (v_GetPosition()); }

            bool IsDone (
               ) const { return (v_IsDone()); }

            int Restart (
               ) { return (v_Restart()); }
               
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            virtual INT64 v_GetElementID (
               ) const { return -1; }
               
            virtual double v_GetPosition (
               ) const { return 1.0; }

            virtual GEOMETRIC_ITERATOR& v_Increment () = 0;

            virtual bool v_IsDone () const = 0;

            virtual ERRVALUE v_Restart (
               ) { return false; }

            GEOMETRIC_ITERATOR (const GEOMETRIC_ITERATOR& rhs);
            GEOMETRIC_ITERATOR& operator=(const GEOMETRIC_ITERATOR& rhs);
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class GEOMETRIC_ITERATOR_POINT : public GEOMETRIC_ITERATOR {
         public:

            explicit GEOMETRIC_ITERATOR_POINT (
               DIMENSION dim = DIMENSION_2D
               ) : m_Dimension(dim) {}

            virtual ~GEOMETRIC_ITERATOR_POINT (
               ) {}

            GEOMETRIC_ITERATOR_POINT& operator=(
               const GEOMETRIC_ITERATOR_POINT& rhs
               ) { if (this != &rhs) { m_Dimension = rhs.m_Dimension; } return (*this); }

            const DPOINT3D& operator* (
               ) const { return (m_Point); }

            const DPOINT3D* operator-> (
               ) const { return (&m_Point); }

         protected:
            DPOINT3D m_Point;

            DIMENSION GetDimension (
               ) const { return (m_Dimension); }
            
         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DIMENSION m_Dimension;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      class GEOMETRIC_ITERATOR_LINE : public GEOMETRIC_ITERATOR {
         public:

            explicit GEOMETRIC_ITERATOR_LINE (
               DIMENSION dim = DIMENSION_2D
               ) : m_Dimension(dim), m_Polyline(false, dim) {}

            virtual ~GEOMETRIC_ITERATOR_LINE (
               ) {}

            GEOMETRIC_ITERATOR_LINE& operator=(
               const GEOMETRIC_ITERATOR_LINE& rhs
               ) { if (this != &rhs) { m_Dimension = rhs.m_Dimension; } return (*this); }

            const POLYLINE& operator* (
               ) const { return (m_Polyline); }

            const POLYLINE* operator-> (
               ) const { return (&m_Polyline); }

         protected:
            POLYLINE m_Polyline;

            DIMENSION GetDimension (
               ) const { return (m_Dimension); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            DIMENSION m_Dimension;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };


      class GEOMETRIC_SOURCE {
         public:

            GEOMETRIC_SOURCE (
               ) {}

            virtual ~GEOMETRIC_SOURCE (
               ) {}

            enum COMPONENT {
               COMPONENT_Point = 0,
               COMPONENT_Line = 1,
               COMPONENT_SubRegion = 2
               };
       
            bool IsComponentAvailable (
               const COMPONENT component
               ) const { return v_IsComponentAvailable(component); }
       
            GEOMETRIC_ITERATOR_POINT* GetPoints (
               ) { return v_GetPoints(); }

            GEOMETRIC_ITERATOR_LINE* GetLines (
               ) { return v_GetLines(); }

         private:
            #ifndef GENERATING_DOXYGEN_OUTPUT
            virtual bool v_IsComponentAvailable (const COMPONENT component) const = 0;
            virtual GEOMETRIC_ITERATOR_POINT* v_GetPoints() = 0;
            virtual GEOMETRIC_ITERATOR_LINE* v_GetLines() = 0;
            #endif // GENERATING_DOXYGEN_OUTPUT
         };

      static ERRVALUE DoBlanking (
         const RVC::OBJITEM& ObjItemSrc,
         const RVC::OBJITEM& ObjItemTgt,
         const SOURCE_PARAMETERS& SrcParameters,
         const DESTINATION_PARAMETERS& DestParameters,
         UINT16 BlankDistance
         );

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

      static ERRVALUE ProcessMinimumCurvature (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const MINIMUMCURVATURE_PARAMETERS& MinimumCurvatureParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         ); 

      static ERRVALUE ProcessUnivariateCurve (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const UNIVARIATECURVE_PARAMETERS& UnivariateCurveParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         ); 

      static ERRVALUE ProcessInverseDistance (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const INVERSEDISTANCE_PARAMETERS& InverseDistanceParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         ); 

      static ERRVALUE ProcessProfiles (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const PROFILES_PARAMETERS& ProfilesParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         ); 

      static ERRVALUE ProcessPolynomial (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const POLYNOMIAL_PARAMETERS& PolynomialParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessKriging (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const KRIGING_PARAMETERS& KrigingParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         ); 

      static ERRVALUE ProcessTriangleInterpolation (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const TRIANGLEINTERPOLATION_PARAMETERS& TriangleInterpolationParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE ProcessBidirectional (
         const RVC::OBJITEM& SrcObjItem,
         RVC::OBJITEM& DestObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         const BIDIRECTIONAL_PARAMETERS& BidirectionalParameters,
         const DESTINATION_PARAMETERS& DestParameters 
         );

      static ERRVALUE GetPoints (
         const RVC::OBJITEM& SrcObjItem, 
         const SOURCE_PARAMETERS* SrcParameters, 
         POLYLINE& polyline
         );

      static RVC::OP::SURFACEFITTING::GEOMETRIC_SOURCE* GetGeometricSource (
         const RVC::OBJITEM& SrcObjItem, 
         const SOURCE_PARAMETERS* SrcParameters 
         );

      static ERRVALUE MakeDestination (
         RVC::OBJITEM& DestObjItem,
         const RVC::OP::SURFACEFITTING::DESTINATION_PARAMETERS& DestParameters, 
         RVC::RASTER& raster
         );

      static ERRVALUE GetTransformation (
         const RVC::OBJITEM& SrcObjItem, 
         const SOURCE_PARAMETERS* SrcParameters,
         TRANS2D_MAPGEN& transformation
         );

   private:

      #ifndef GENERATING_DOXYGEN_OUTPUT
      static ERRVALUE GetVectorPoints (const RVC::OBJITEM& SrcObjItem, const VECTOR_PARAMETERS& VectorParameters, POLYLINE& polyline);
      static ERRVALUE GetTablePoints (const RVC::OBJITEM& SrcObjItem, const TABLE_PARAMETERS& TableParameters, POLYLINE& polyline);
      static ERRVALUE GetTINPoints (const RVC::OBJITEM& SrcObjItem, const TIN_PARAMETERS& TINParameters, POLYLINE& polyline);
      static ERRVALUE GetShapePoints (const RVC::OBJITEM& SrcObjItem, const SHAPE_PARAMETERS& ShapeParameters, POLYLINE& polyline);
      #endif // GENERATING_DOXYGEN_OUTPUT

   };

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


#endif  // INC_RVC_OPSURFACEFITTING_H

---