saga_api_doc/html/geo__tools_8h_source.html

//                                                       //

//                         SAGA                          //

//                                                       //

//      System for Automated Geoscientific Analyses      //

//                                                       //

//           Application Programming Interface           //

//                                                       //

//                  Library: SAGA_API                    //

//                                                       //

//-------------------------------------------------------//

//                                                       //

//                      geo_tools.h                      //

//                                                       //

//          Copyright (C) 2005 by Olaf Conrad            //

//                                                       //

//-------------------------------------------------------//

//                                                       //

// This file is part of 'SAGA - System for Automated     //

// Geoscientific Analyses'.                              //

//                                                       //

// This library is free software; you can redistribute   //

// it and/or modify it under the terms of the GNU Lesser //

// General Public License as published by the Free       //

// Software Foundation, either version 2.1 of the        //

// License, or (at your option) any later version.       //

//                                                       //

// This library is distributed in the hope that it will  //

// be useful, but WITHOUT ANY WARRANTY; without even the //

// implied warranty of MERCHANTABILITY or FITNESS FOR A  //

// PARTICULAR PURPOSE. See the GNU Lesser General Public //

// License for more details.                             //

//                                                       //

// You should have received a copy of the GNU Lesser     //

// General Public License along with this program; if    //

// not, see <http://www.gnu.org/licenses/>.              //

//                                                       //

//-------------------------------------------------------//

//                                                       //

//    contact:    Olaf Conrad                            //

//                Institute of Geography                 //

//                University of Goettingen               //

//                Goldschmidtstr. 5                      //

//                37077 Goettingen                       //

//                Germany                                //

//                                                       //

//    e-mail:     oconrad@saga-gis.org                   //

//                                                       //


//---------------------------------------------------------

#ifndef HEADER_INCLUDED__SAGA_API__geo_tools_H

#define HEADER_INCLUDED__SAGA_API__geo_tools_H


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------

#include "api_core.h"

#include "metadata.h"


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------

#define SG_IS_BETWEEN(a, x, b)  (((a) <= (x) && (x) <= (b)) || ((b) <= (x) && (x) <= (a)))


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


typedef enum

{

        INTERSECTION_None = 0,

        INTERSECTION_Identical,

        INTERSECTION_Overlaps,

        INTERSECTION_Contained,

        INTERSECTION_Contains

}


TSG_Intersection;


//---------------------------------------------------------


enum class TSG_Point_Type

{

        SG_POINT_TYPE_2D = 0,

        SG_POINT_TYPE_3D,

        SG_POINT_TYPE_4D,

        SG_POINT_TYPE_2D_Int

};


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


typedef struct SSG_Point

{

        double                                          x, y;

}


TSG_Point;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Point : public TSG_Point

{

public:

        CSG_Point(void);

        CSG_Point(const CSG_Point &Point);

        CSG_Point(const TSG_Point &Point);

        CSG_Point(double x, double y);


        virtual ~CSG_Point(void)      {}


        virtual TSG_Point_Type            Get_Type                (void)  const   {       return( TSG_Point_Type::SG_POINT_TYPE_2D );     }


        virtual bool                            operator ==             (const CSG_Point &Point)       const   {       return(  is_Equal(Point) );     }

        virtual bool                            operator !=             (const CSG_Point &Point)       const   {       return( !is_Equal(Point) );     }


        virtual CSG_Point                      operator +          (const CSG_Point &Point)       const   {       return( CSG_Point(x + Point.x, y + Point.y)        );      }

        virtual CSG_Point                      operator -              (const CSG_Point &Point)       const   {       return( CSG_Point(x - Point.x, y - Point.y)        );      }


        virtual CSG_Point &                    operator  =             (const CSG_Point &Point)                       {       Assign  (Point);  return( *this );        }

        virtual CSG_Point &                    operator +=             (const CSG_Point &Point)                       {       Add     (Point);     return( *this );        }

        virtual CSG_Point &                    operator -=             (const CSG_Point &Point)                       {       Subtract(Point);        return( *this );        }

        virtual CSG_Point &                    operator *=             (const CSG_Point &Point)                       {       Multiply(Point);        return( *this );        }


        CSG_Point                                      operator *          (double Value)                          const   {       return( CSG_Point(x * Value, y * Value)      );      }

        CSG_Point                                      operator /              (double Value)                          const   {       return( CSG_Point(x / Value, y / Value)      );      }

        virtual CSG_Point &                    operator *=             (double Value)                                          {       Multiply(Value);        return( *this );        }

        virtual CSG_Point &                    operator /=             (double Value)                                          {       Divide  (Value);  return( *this );        }


        virtual void                            Assign                  (double x, double y);

        virtual void                            Assign                  (const CSG_Point &Point);


        virtual void                            Add                             (const CSG_Point &Point);

        virtual void                            Subtract                (const CSG_Point &Point);

        virtual void                            Multiply                (const CSG_Point &Point);


        virtual void                            Multiply                (double Value);

        virtual void                            Divide                  (double Value);


        virtual double                          Get_Length              (void)  const;

        virtual double                          Get_Distance        (const CSG_Point &Point)       const   {       CSG_Point d(*this - Point); return( d.Get_Length() );        }


        virtual bool                            is_Equal                (const CSG_Point &Point, double epsilon = 0.)  const   {       return( is_Equal(Point.x, Point.y, epsilon) ); }


        virtual bool                            is_Equal                (double _x,   double _y, double epsilon = 0.)   const

        {

                return( fabs(x - _x) <= epsilon && fabs(y - _y) <= epsilon );

        }


};


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Points

{

public:

        CSG_Points(void);

        CSG_Points(const CSG_Points &Points);

        CSG_Points(sLong nPoints, TSG_Array_Growth Growth = TSG_Array_Growth::SG_ARRAY_GROWTH_1);


        bool                                            Clear                      (void)              { return( m_Points.Destroy() ); }


        CSG_Points &                          operator  =             (const CSG_Points &Points) { Assign(Points); return( *this ); }

        bool                                            Assign                  (const CSG_Points &Points);


        bool                                            Add                             (double x, double y);

        bool                                            Add                          (const TSG_Point &Point) { return( Add(Point.x, Point.y) ); }

        bool                                            Del                          (sLong Index)       { return( m_Points.Del_Entry(Index) ); }


        bool                                            Set_Count              (sLong nPoints)     { return( m_Points.Set_Array(nPoints) ); }

        sLong                                              Get_Count              (void)        const { return( m_Points.Get_Size() ); }


        TSG_Point *                                    Get_Points            (void)        const { return( (TSG_Point *)m_Points.Get_Array() ); }


        TSG_Point &                                    operator []             (sLong Index)       { return( Get_Points()[Index] ); }

        const TSG_Point &                      operator []             (sLong Index) const { return( Get_Points()[Index] ); }


private:


        CSG_Array                                      m_Points;


};


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Lines

{

public:

        CSG_Lines(void);

        virtual ~CSG_Lines(void);


                                                                CSG_Lines              (const CSG_Lines &Lines);

        bool                                            Create                    (const CSG_Lines &Lines);


                                                                CSG_Lines              (sLong nLines);

        bool                                            Create                    (sLong nLines);


        bool                                            Destroy                  (void);

        bool                                            Clear                      (void);


        CSG_Lines &                                    operator  =             (const CSG_Lines &Lines) { Assign(Lines); return( *this ); }

        bool                                            Assign                  (const CSG_Lines &Lines);


        CSG_Points &                          Add                             (void);

        bool                                            Add                             (const CSG_Points &Line);

        bool                                            Add                             (const CSG_Lines &Lines);

        bool                                            Del                             (sLong Index);


        bool                                            Set_Count               (sLong nLines);

        sLong                                              Get_Count              (void)        const { return( m_Lines.Get_Size() ); }


        CSG_Points &                          Get_Line                (sLong Index)       { return( *((CSG_Points *)m_Lines[Index]) ); }

        const CSG_Points &                    Get_Line                (sLong Index) const { return( *((CSG_Points *)m_Lines[Index]) ); }


        CSG_Points &                          operator []             (sLong Index)       { return( Get_Line(Index) ); }

        const CSG_Points &                    operator []             (sLong Index) const { return( Get_Line(Index) ); }


        double                                          Get_Length              (void)        const;

        double                                          Get_Length              (sLong Index) const;


private:


        CSG_Array_Pointer                      m_Lines;


};


//                                                       //


//---------------------------------------------------------


typedef struct SSG_Point_3D

{

        double                                          x, y, z;

}


TSG_Point_3D;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Point_3D : public TSG_Point_3D

{

public:

        CSG_Point_3D(void);

        CSG_Point_3D(const CSG_Point_3D &Point);

        CSG_Point_3D(const TSG_Point_3D &Point);

        CSG_Point_3D(double x, double y, double z);


        virtual ~CSG_Point_3D(void)        {}


        virtual TSG_Point_Type            Get_Type                (void)  const   {       return( TSG_Point_Type::SG_POINT_TYPE_3D );     }


        virtual bool                            operator ==             (const CSG_Point_3D &Point) const   {       return(  is_Equal(Point) );     }

        virtual bool                            operator !=             (const CSG_Point_3D &Point) const   {       return( !is_Equal(Point) );     }


        virtual CSG_Point_3D                operator +          (const CSG_Point_3D &Point) const   {       return( CSG_Point_3D(x + Point.x, y + Point.y, z + Point.z)   );      }

        virtual CSG_Point_3D                operator -              (const CSG_Point_3D &Point) const   {       return( CSG_Point_3D(x - Point.x, y - Point.y, z - Point.z)   );      }


        virtual CSG_Point_3D &              operator  =             (const CSG_Point_3D &Point)                 {       Assign  (Point);  return( *this );        }

        virtual CSG_Point_3D &              operator +=             (const CSG_Point_3D &Point)                 {       Add     (Point);     return( *this );        }

        virtual CSG_Point_3D &              operator -=             (const CSG_Point_3D &Point)                 {       Subtract(Point);        return( *this );        }

        virtual CSG_Point_3D &              operator *=             (const CSG_Point_3D &Point)                 {       Multiply(Point);        return( *this );        }


        CSG_Point_3D                                operator *          (double Value)                          const   {       return( CSG_Point_3D(x * Value, y * Value, z * Value)    );      }

        CSG_Point_3D                                operator /              (double Value)                          const   {       return( CSG_Point_3D(x / Value, y / Value, z / Value)    );      }

        virtual CSG_Point_3D &              operator *=             (double Value)                                          {       Multiply(Value);        return( *this );        }

        virtual CSG_Point_3D &              operator /=             (double Value)                                          {       Divide  (Value);  return( *this );        }


        virtual void                            Assign                  (double x, double y, double z);

        virtual void                            Assign                  (const CSG_Point_3D &Point);


        virtual void                            Add                             (const CSG_Point_3D &Point);

        virtual void                            Subtract                (const CSG_Point_3D &Point);

        virtual void                            Multiply                (const CSG_Point_3D &Point);


        virtual void                            Multiply                (double Value);

        virtual void                            Divide                  (double Value);


        virtual double                          Get_Length              (void)  const;

        virtual double                          Get_Distance        (const CSG_Point_3D &Point) const   {       CSG_Point_3D d(*this - Point); return( d.Get_Length() ); }


        virtual bool                            is_Equal                (const CSG_Point_3D &Point      , double epsilon = 0.)      const   {       return( is_Equal(Point.x, Point.y, Point.y, epsilon) );      }


        virtual bool                            is_Equal                (double _x, double _y, double _z, double epsilon = 0.)  const

        {

                return( fabs(x - _x) <= epsilon && fabs(y - _y) <= epsilon && fabs(z - _z) <= epsilon );

        }


};


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Points_3D

{

public:

        CSG_Points_3D(void);

        CSG_Points_3D(const CSG_Points_3D &Points);

        CSG_Points_3D(sLong nPoints, TSG_Array_Growth Growth = TSG_Array_Growth::SG_ARRAY_GROWTH_1);


        bool                                            Clear                      (void)              { return( m_Points.Destroy() ); }


        CSG_Points_3D &                            operator  =             (const CSG_Points_3D &Points) { Assign(Points); return( *this ); }

        bool                                            Assign                  (const CSG_Points_3D &Points);


        bool                                            Add                             (double x, double y, double z);

        bool                                            Add                          (const TSG_Point_3D &Point) { return( Add(Point.x, Point.y, Point.z) ); }

        bool                                            Del                          (sLong Index)       { return( m_Points.Del_Entry(Index) ); }


        bool                                            Set_Count              (sLong nPoints)     { return( m_Points.Set_Array(nPoints) ); }

        sLong                                              Get_Count              (void)        const { return( m_Points.Get_Size() ); }


        TSG_Point_3D *                              Get_Points            (void)        const { return( (TSG_Point_3D *)m_Points.Get_Array() ); }


        TSG_Point_3D &                              operator []             (sLong Index)       { return( Get_Points()[Index] ); }

        const TSG_Point_3D &                operator []             (sLong Index) const { return( Get_Points()[Index] ); }


private:


        CSG_Array                                      m_Points;


};


//                                                       //


//---------------------------------------------------------


typedef struct SSG_Point_4D

{

        double                                          x, y, z, m;

}


TSG_Point_4D;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Point_4D : public TSG_Point_4D

{

public:

        CSG_Point_4D(void);

        CSG_Point_4D(const CSG_Point_4D &Point);

        CSG_Point_4D(const TSG_Point_4D &Point);

        CSG_Point_4D(double x, double y, double z, double m);


        virtual ~CSG_Point_4D(void)        {}


        virtual TSG_Point_Type            Get_Type                (void)  const   {       return( TSG_Point_Type::SG_POINT_TYPE_4D );     }


        virtual bool                            operator ==             (const CSG_Point_4D &Point) const   {       return(  is_Equal(Point) );     }

        virtual bool                            operator !=             (const CSG_Point_4D &Point) const   {       return( !is_Equal(Point) );     }


        virtual CSG_Point_4D                operator +          (const CSG_Point_4D &Point) const   {       return( CSG_Point_4D(x + Point.x, y + Point.y, z + Point.z, m + Point.m) ); }

        virtual CSG_Point_4D                operator -              (const CSG_Point_4D &Point) const   {       return( CSG_Point_4D(x - Point.x, y - Point.y, z - Point.z, m - Point.m) ); }


        CSG_Point_4D                                operator *          (double Value)                          const   {       return( CSG_Point_4D(x * Value, y * Value, z * Value, m * Value)        );      }

        CSG_Point_4D                                operator /              (double Value)                          const   {       return( CSG_Point_4D(x / Value, y / Value, z / Value, m * Value)        );      }

        virtual CSG_Point_4D &              operator *=             (double Value)                                          {       Multiply(Value);        return( *this );        }

        virtual CSG_Point_4D &              operator /=             (double Value)                                          {       Divide  (Value);  return( *this );        }


        virtual CSG_Point_4D &              operator  =             (const CSG_Point_4D &Point)                 {       Assign  (Point);  return( *this );        }

        virtual CSG_Point_4D &              operator +=             (const CSG_Point_4D &Point)                 {       Add     (Point);     return( *this );        }

        virtual CSG_Point_4D &              operator -=             (const CSG_Point_4D &Point)                 {       Subtract(Point);        return( *this );        }

        virtual CSG_Point_4D &              operator *=             (const CSG_Point_4D &Point)                 {       Multiply(Point);        return( *this );        }


        virtual void                            Assign                  (double x, double y, double z, double m);

        virtual void                            Assign                  (const CSG_Point_4D &Point);


        virtual void                            Add                             (const CSG_Point_4D &Point);

        virtual void                            Subtract                (const CSG_Point_4D &Point);

        virtual void                            Multiply                (const CSG_Point_4D &Point);


        virtual void                            Multiply                (double Value);

        virtual void                            Divide                  (double Value);


        virtual double                          Get_Length              (void)  const;

        virtual double                          Get_Distance        (const CSG_Point_4D &Point) const   {       CSG_Point_4D d(*this - Point); return( d.Get_Length() ); }


        virtual bool                            is_Equal                (const CSG_Point_4D &Point                 , double epsilon = 0.)   const   {       return( is_Equal(Point.x, Point.y, Point.y, Point.m, epsilon) );    }


        virtual bool                            is_Equal                (double _x, double _y, double _z, double _m, double epsilon = 0.)       const

        {

                return( fabs(x - _x) <= epsilon && fabs(y - _y) <= epsilon && fabs(z - _z) <= epsilon && fabs(m - _m) <= epsilon );

        }


};


//                                                       //


//---------------------------------------------------------


typedef struct SSG_Point_Int

{

        int                                                     x, y;

}


TSG_Point_Int;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Points_Int

{

public:

        CSG_Points_Int(void);

        CSG_Points_Int(const CSG_Points_Int &Points);

        CSG_Points_Int(sLong nPoints, TSG_Array_Growth Growth = TSG_Array_Growth::SG_ARRAY_GROWTH_1);


        bool                                            Clear                      (void)              { return( m_Points.Destroy() ); }


        CSG_Points_Int &                  operator  =             (const CSG_Points_Int &Points) { Assign(Points); return( *this ); }

        bool                                            Assign                  (const CSG_Points_Int &Points);


        bool                                            Add                             (int x, int y);

        bool                                            Add                          (const TSG_Point_Int &Point) { return( Add(Point.x, Point.y) ); }

        bool                                            Del                          (sLong Index)       { return( m_Points.Del_Entry(Index) ); }


        bool                                            Set_Count              (sLong nPoints)     { return( m_Points.Set_Array(nPoints) ); }

        sLong                                              Get_Count              (void)        const { return( m_Points.Get_Size() ); }


        TSG_Point_Int *                            Get_Points            (void)        const { return( (TSG_Point_Int *)m_Points.Get_Array() ); }


        TSG_Point_Int &                            operator []             (sLong Index)       { return( Get_Points()[Index] ); }

        const TSG_Point_Int &              operator []             (sLong Index) const { return( Get_Points()[Index] ); }


private:


        CSG_Array                                      m_Points;


};


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


typedef struct SSG_Rect

{

        double                                          xMin, yMin, xMax, yMax;

}


TSG_Rect;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Rect : public TSG_Rect

{

public:

        CSG_Rect(void);

        CSG_Rect(const CSG_Rect &Rect);

        CSG_Rect(const TSG_Rect &Rect);

        CSG_Rect(const CSG_Point &A, const CSG_Point &B);

        CSG_Rect(double xMin, double yMin, double xMax, double yMax);


        ~CSG_Rect(void);


        bool                                            Create                    (double xMin, double yMin, double xMax, double yMax);

        bool                                            Create                    (const CSG_Point &A, const CSG_Point &B);

        bool                                            Create                    (const CSG_Rect &Rect);


        bool                                            operator ==             (const CSG_Rect &Rect) const { return(  is_Equal(Rect) ); }

        bool                                            operator !=             (const CSG_Rect &Rect) const { return( !is_Equal(Rect) ); }


        CSG_Rect &                                      operator  =             (const CSG_Rect &Rect)   { Assign(Rect); return( *this ); }


        CSG_Rect &                                      operator +=             (const CSG_Point &Point) { Move(  Point.x,  Point.y); return( *this ); }

        CSG_Rect &                                      operator -=             (const CSG_Point &Point) { Move( -Point.x, -Point.y); return( *this ); }


        CSG_Rect &                                      Assign                  (double xMin, double yMin, double xMax, double yMax);

        CSG_Rect &                                      Assign                  (const CSG_Point &A, const CSG_Point &B);

        CSG_Rect &                                      Assign                  (const CSG_Rect &Rect);


        CSG_Rect &                                      Set_BottomLeft  (double x, double y);

        CSG_Rect &                                      Set_BottomLeft  (const CSG_Point &Point);

        CSG_Rect &                                      Set_TopRight    (double x, double y);

        CSG_Rect &                                      Set_TopRight    (const CSG_Point &Point);


        double                                          Get_XMin                (void) const    {       return( xMin );     }

        double                                          Get_XMax                (void) const    {       return( xMax );     }

        double                                          Get_YMin                (void) const    {       return( yMin );     }

        double                                          Get_YMax                (void) const    {       return( yMax );     }


        double                                          Get_XRange            (void) const    {       return( xMax - xMin );  }

        double                                          Get_YRange            (void) const    {       return( yMax - yMin );  }


        double                                          Get_Area                (void) const    {       return( Get_XRange() * Get_YRange() );      }

        double                                          Get_Diameter        (void) const    {       return( sqrt(Get_XRange()*Get_XRange() + Get_YRange()*Get_YRange()) );  }


        CSG_Point                                      Get_TopLeft          (void) const    {       return( CSG_Point(xMin, yMax) );       }

        CSG_Point                                      Get_BottomRight  (void) const    {       return( CSG_Point(xMax, yMin) );       }


        CSG_Point                                      Get_Center            (void) const    {       return( CSG_Point(Get_XCenter(), Get_YCenter()) );       }

        double                                          Get_XCenter          (void) const    {       return( (xMin + xMax) / 2. );   }

        double                                          Get_YCenter          (void) const    {       return( (yMin + yMax) / 2. );   }


        CSG_Rect &                                      Move                    (double dx, double dy);

        CSG_Rect &                                      Move                    (const CSG_Point &Point);


        CSG_Rect &                                      Inflate                 (double d, bool bPercent = true);

        CSG_Rect &                                      Deflate                 (double d, bool bPercent = true);

        CSG_Rect &                                      Inflate                 (double dx, double dy, bool bPercent = true);

        CSG_Rect &                                      Deflate                 (double dx, double dy, bool bPercent = true);


        CSG_Rect &                                      Union                   (double x, double y);

        CSG_Rect &                                      Union                   (const CSG_Point &Point);

        CSG_Rect &                                      Union                   (const CSG_Rect &Rect);

        bool                                            Intersect               (const CSG_Rect &Rect);


        bool                                            is_Equal                (double xMin, double yMin, double xMax, double yMax, double epsilon = 0.) const;

        bool                                            is_Equal                (const CSG_Rect &Rect                              , double epsilon = 0.) const;


        bool                                            Contains                (double x, double y)            const;

        bool                                            Contains                (const CSG_Point &Point)       const;


        TSG_Intersection                        Intersects              (const CSG_Rect &Rect)          const;


};


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Rects

{

public:

        CSG_Rects(void);

        CSG_Rects(const CSG_Rects &Rects);

        virtual ~CSG_Rects(void);


        void                                            Clear                      (void);


        CSG_Rects &                                    operator  =             (const CSG_Rects &Rects);

        bool                                            Assign                    (const CSG_Rects &Rects);


        bool                                            Add                          (void);

        bool                                            Add                          (double xMin, double yMin, double xMax, double yMax);

        bool                                            Add                          (const CSG_Rect &Rect);


        int                                                     Get_Count              (void)  const   {       return( m_nRects );     }


        CSG_Rect &                                      operator []             (int Index)             {       return( *m_Rects[Index] );      }

        CSG_Rect &                                      Get_Rect                (int Index)             {       return( *m_Rects[Index] );      }


private:


        int                                                     m_nRects;


        CSG_Rect                                        **m_Rects;


};


//                                                       //


//---------------------------------------------------------


typedef struct SSG_Rect_Int

{

        int                                                     xMin, yMin, xMax, yMax;

}


TSG_Rect_Int;


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Rect_Int : public TSG_Rect_Int

{

public:

        CSG_Rect_Int(void);

        CSG_Rect_Int(const CSG_Rect_Int &Rect);

        CSG_Rect_Int(const TSG_Rect_Int &Rect);

        CSG_Rect_Int(const TSG_Point_Int &A, const TSG_Point_Int &B);

        CSG_Rect_Int(int xMin, int yMin, int xMax, int yMax);


        ~CSG_Rect_Int(void);


        bool                                            Create                    (int xMin, int yMin, int xMax, int yMax);

        bool                                            Create                    (const TSG_Point_Int &A, const TSG_Point_Int &B);

        bool                                            Create                    (const CSG_Rect_Int &Rect);


        bool                                            operator ==             (const CSG_Rect_Int &Rect) const { return(  is_Equal(Rect) ); }

        bool                                            operator !=             (const CSG_Rect_Int &Rect) const { return( !is_Equal(Rect) ); }


        CSG_Rect_Int &                              operator  =             (const CSG_Rect_Int &Rect)   { Assign(Rect); return( *this ); }


        CSG_Rect_Int &                              operator +=             (const TSG_Point_Int &Point) { Move( Point.x,  Point.y); return( *this ); }

        CSG_Rect_Int &                              operator -=             (const TSG_Point_Int &Point) { Move(-Point.x, -Point.y); return( *this ); }


        CSG_Rect_Int &                              Assign                  (int xMin, int yMin, int xMax, int yMax);

        CSG_Rect_Int &                              Assign                  (const TSG_Point_Int &A, const TSG_Point_Int &B);

        CSG_Rect_Int &                              Assign                  (const CSG_Rect_Int &Rect);


        CSG_Rect_Int &                              Set_BottomLeft  (int x, int y);

        CSG_Rect_Int &                              Set_BottomLeft  (const TSG_Point_Int &Point);

        CSG_Rect_Int &                              Set_TopRight    (int x, int y);

        CSG_Rect_Int &                              Set_TopRight    (const TSG_Point_Int &Point);


        int                                                     Get_XMin                (void) const    {       return( xMin );     }

        int                                                     Get_XMax                (void) const    {       return( xMax );     }

        int                                                     Get_YMin                (void) const    {       return( yMin );     }

        int                                                     Get_YMax                (void) const    {       return( yMax );     }


        int                                                     Get_XRange            (void) const    {       return( xMax - xMin );  }

        int                                                     Get_YRange            (void) const    {       return( yMax - yMin );  }


        double                                          Get_Area                (void) const    {       return( ((double)Get_XRange() * (double)Get_YRange()) );    }

        double                                          Get_Diameter        (void) const    {       double x = (double)xMax - xMin, y = (double)yMax - yMin; return( sqrt(x*x + y*y) );     }


        TSG_Point_Int                              Get_TopLeft          (void) const    {       TSG_Point_Int p; p.x = xMin; p.y = yMax; return( p );    }

        TSG_Point_Int                              Get_BottomRight  (void) const    {       TSG_Point_Int p; p.x = xMax; p.y = yMin; return( p );    }


        CSG_Rect_Int &                              Move                    (int dx, int dy);

        CSG_Rect_Int &                              Move                    (const TSG_Point_Int &Point);


        CSG_Rect_Int &                              Inflate                 (int d);

        CSG_Rect_Int &                              Deflate                 (int d);

        CSG_Rect_Int &                              Inflate                 (int dx, int dy);

        CSG_Rect_Int &                              Deflate                 (int dx, int dy);


        CSG_Rect_Int &                              Union                   (int x, int y);

        CSG_Rect_Int &                              Union                   (const TSG_Point_Int &Point);

        CSG_Rect_Int &                              Union                   (const CSG_Rect_Int &Rect);

        bool                                            Intersect               (const CSG_Rect_Int &Rect);


        bool                                            is_Equal                (int xMin, int yMin, int xMax, int yMax) const;

        bool                                            is_Equal                (const CSG_Rect_Int &Rect              ) const;


        bool                                            Contains                (double x, double y)         const;

        bool                                            Contains                (const TSG_Point_Int &Point) const;


        TSG_Intersection                        Intersects              (const CSG_Rect_Int &Rect)   const;


};


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Rects_Int

{

public:

        CSG_Rects_Int(void);

        virtual ~CSG_Rects_Int(void);


        void                                            Clear                      (void);


        CSG_Rects_Int &                            operator  =             (const CSG_Rects_Int &Rects);

        bool                                            Assign                    (const CSG_Rects_Int &Rects);


        bool                                            Add                          (void);

        bool                                            Add                          (int xMin, int yMin, int xMax, int yMax);

        bool                                            Add                          (const CSG_Rect_Int &Rect);


        int                                                     Get_Count              (void)  const   {       return( m_nRects );     }


        CSG_Rect_Int &                              operator []             (int Index)             {       return( *m_Rects[Index] );      }

        CSG_Rect_Int &                              Get_Rect                (int Index)             {       return( *m_Rects[Index] );      }


private:


        int                                                     m_nRects;


        CSG_Rect_Int                                **m_Rects;


};


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


typedef enum

{

        SG_DISTWGHT_None        = 0,

        SG_DISTWGHT_IDW,

        SG_DISTWGHT_EXP,

        SG_DISTWGHT_GAUSS

}


TSG_Distance_Weighting;


//                                                       //


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Distance_Weighting

{

public:

        CSG_Distance_Weighting(void);

        virtual ~CSG_Distance_Weighting(void);


        static bool                             Enable_Parameters      (class CSG_Parameters &Parameters);

        bool                                    Create_Parameters      (class CSG_Parameters &Parameters, const CSG_String &Parent = "", bool bIDW_Offset = false);

        static bool                             Add_Parameters            (class CSG_Parameters &Parameters, const CSG_String &Parent = "", bool bIDW_Offset = false);

        bool                                    Set_Parameters            (class CSG_Parameters &Parameters);


        TSG_Distance_Weighting    Get_Weighting              (void)  const   {       return( m_Weighting   );        }

        bool                                    Set_Weighting           (TSG_Distance_Weighting Weighting);


        double                                  Get_IDW_Power              (void)  const   {       return( m_IDW_Power   );        }

        bool                                    Set_IDW_Power           (double Value);


        bool                                    Get_IDW_Offset            (void)  const   {       return( m_IDW_bOffset );        }

        bool                                    Set_IDW_Offset          (bool bOn = true);


        double                                  Get_BandWidth              (void)  const   {       return( m_Bandwidth   );        }

        bool                                    Set_BandWidth           (double Value);


        //-----------------------------------------------------


        double                                  Get_Weight                    (double Distance)       const

        {

                if( Distance < 0. )

                {

                        return( 0. );

                }


                switch( m_Weighting )

                {

                case SG_DISTWGHT_IDW  :

                        return( m_IDW_bOffset

                                ? pow(1. + Distance, -m_IDW_Power) : Distance > 0.

                                ? pow(     Distance, -m_IDW_Power) : 0.

                        );


                case SG_DISTWGHT_EXP  :

                        return( exp(-Distance / m_Bandwidth) );


                case SG_DISTWGHT_GAUSS:

                        Distance        /= m_Bandwidth;

                        return( exp(-0.5 * Distance*Distance) );


                default: // case SG_DISTWGHT_None:

                        return( 1. );

                }

        }


private:


        bool                                    m_IDW_bOffset;


        double                                  m_IDW_Power, m_Bandwidth;


        TSG_Distance_Weighting    m_Weighting;


};


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------


enum class ESG_CRS_Format

{

        WKT1, WKT2, PROJ, JSON, ESRI, CODE, Undefined, WKT = WKT1

};


//---------------------------------------------------------


enum class ESG_CRS_Type

{

        Geographic, Geodetic, Geocentric, Projection, Undefined

};


//---------------------------------------------------------


enum class ESG_Projection_Unit

{

        Kilometer,

        Meter,

        Decimeter,

        Centimeter,

        Millimeter,

        Int_Nautical_Mile,

        Int_Inch,

        Int_Foot,

        Int_Yard,

        Int_Statute_Mile,

        Int_Fathom,

        Int_Chain,

        Int_Link,

        US_Inch,

        US_Foot,

        US_Yard,

        US_Chain,

        US_Statute_Mile,

        Indian_Yard,

        Indian_Foot,

        Indian_Chain,

        Undefined, First = Kilometer

};


//                                                       //


//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Projection

{

        friend class CSG_Projections;


public:

        CSG_Projection(void);

        virtual ~CSG_Projection(void);


        void                                                    Destroy                                  (void);


                                                                        CSG_Projection                    (const CSG_Projection &Projection);

        bool                                                    Create                                    (const CSG_Projection &Projection);

        CSG_Projection &                          operator =                              (const CSG_Projection &Projection) { Create(Projection); return( *this ); }


                                                                        CSG_Projection                    (const char       *Definition);

        bool                                                    Create                                  (const char       *Definition);

        CSG_Projection &                          operator =                              (const char       *Definition)     { Create(Definition); return( *this ); }


                                                                        CSG_Projection                    (const wchar_t    *Definition);

        bool                                                    Create                                  (const wchar_t    *Definition);

        CSG_Projection &                          operator =                              (const wchar_t    *Definition)     { Create(Definition); return( *this ); }


                                                                        CSG_Projection                    (const CSG_String &Definition);

        bool                                                    Create                                  (const CSG_String &Definition);

        CSG_Projection &                          operator =                              (const CSG_String &Definition)     { Create(Definition); return( *this ); }


                                                                        CSG_Projection                    (int Code, const SG_Char *Authority = NULL);

        bool                                                    Create                                  (int Code, const SG_Char *Authority = NULL);

        CSG_Projection &                          operator =                              (int Code)                         { Create(Code      ); return( *this ); }


                                                                        CSG_Projection                    (const CSG_String &WKT2, const CSG_String &PROJ);

        bool                                                    Create                                  (const CSG_String &WKT2, const CSG_String &PROJ);


        bool                                                    Assign                                    (const CSG_Projection &Projection)          { return( Create(Projection      ) ); }

        bool                                                    Assign                                    (const CSG_String &Definition)              { return( Create(Definition      ) ); }

        bool                                                    Assign                                    (int Code, const SG_Char *Authority = NULL) { return( Create(Code, Authority ) ); }


        bool                                                    is_Okay                                  (void)  const   {       return( m_Type != ESG_CRS_Type::Undefined );     }

        bool                                                    is_Equal                                (const CSG_Projection &Projection) const;

        bool                                                    operator ==                             (const CSG_Projection &Projection) const { return( is_Equal(Projection) == true  ); }

        bool                                                    operator !=                             (const CSG_Projection &Projection) const { return( is_Equal(Projection) == false ); }


        static const CSG_Projection &     Get_GCS_WGS84                   (void);

        bool                                                    Set_GCS_WGS84                   (void);


        static CSG_Projection                     Get_UTM_WGS84                   (int Zone, bool bSouth = false);

        bool                                                    Set_UTM_WGS84                   (int Zone, bool bSouth = false);


        bool                                                    Load                                    (const CSG_String &File);

        bool                                                    Save                                    (const CSG_String &File, ESG_CRS_Format Format = ESG_CRS_Format::WKT) const;


        bool                                                    Load                                    (CSG_File &Stream);

        bool                                                    Save                                    (CSG_File &Stream      , ESG_CRS_Format Format = ESG_CRS_Format::WKT) const;


        bool                                                    Load                                    (const CSG_MetaData &Projection);

        bool                                                    Save                                    (      CSG_MetaData &Projection) const;


        CSG_String                                            Get_Description                 (bool bDetails = false) const;


        const CSG_String &                            Get_Name                                (void)  const   {       return( m_Name      );  }


        const CSG_String &                            Get_WKT                                  (void)  const   {       return( m_WKT2      );  }

              CSG_String                              Get_WKT1                                (void)  const;

        const CSG_String &                            Get_WKT2                                (void)  const   {       return( m_WKT2      );  }

        const CSG_String &                            Get_PROJ                                (void)  const   {       return( m_PROJ      );  }

              CSG_String                              Get_JSON                                (void)  const;

              CSG_String                              Get_ESRI                                (void)  const;

              CSG_String                              Get_XML                                 (void)  const;

        const CSG_String &                            Get_Authority                      (void)  const   {       return( m_Authority );  }

        int                                                             Get_Code                                (void)  const   {       return( m_Code      );  }


        const CSG_String &                            Get_Proj4                              (void)  const   {       return( m_PROJ      );  }

        int                                                             Get_Authority_ID                (void)  const   {       return( m_Code      );  }

        int                                                             Get_EPSG                                (void)  const   {       return( m_Authority.CmpNoCase("EPSG") ? -1 : m_Code );  }


        bool                                                    is_Geographic                      (void)  const   {       return( m_Type == ESG_CRS_Type::Geographic );   }

        bool                                                    is_Geodetic                          (void)  const   {       return( m_Type == ESG_CRS_Type::Geodetic   );     }

        bool                                                    is_Geocentric                      (void)  const   {       return( m_Type == ESG_CRS_Type::Geocentric );   }

        bool                                                    is_Projection                      (void)  const   {       return( m_Type == ESG_CRS_Type::Projection );   }


        ESG_CRS_Type                                        Get_Type                                (void)  const   {       return( m_Type );       }

        CSG_String                                            Get_Type_Identifier             (void)  const;

        CSG_String                                            Get_Type_Name                   (void)  const;


        ESG_Projection_Unit                          Get_Unit                                (void)  const   {       return( m_Unit );       }

        CSG_String                                            Get_Unit_Identifier             (void)  const;

        CSG_String                                            Get_Unit_Name                   (void)  const;

        double                                                  Get_Unit_To_Meter               (void)  const;


private:


        int                                                             m_Code;


        ESG_CRS_Type                                        m_Type;


        ESG_Projection_Unit                          m_Unit;


        CSG_String                                            m_Name, m_Authority, m_PROJ, m_WKT2;


};


//                                                       //


//---------------------------------------------------------

//---------------------------------------------------------


class SAGA_API_DLL_EXPORT CSG_Projections

{

        friend class CSG_Projection;


public:

        CSG_Projections(void);

        virtual ~CSG_Projections(void);


                                                                        CSG_Projections                  (bool LoadCodeList);

        bool                                                    Create                                    (bool LoadCodeList = true);


        void                                                    Destroy                                  (void);


        static bool                                             Parse                                      (const CSG_String &Definition, CSG_String *PROJ = NULL, CSG_String *WKT2 = NULL, CSG_String *WKT1 = NULL, CSG_String *JSON = NULL, CSG_String *ESRI = NULL);

        static CSG_String                             Parse                                      (const CSG_String &Definition, ESG_CRS_Format Format);


        bool                                                    Load                                        (const CSG_String &File, bool bAppend = false);

        bool                                                    Save                                        (const CSG_String &File);


        bool                                                    Add                                          (const CSG_Projection &Projection);

        bool                                                    Add                                          (const SG_Char *WKT, const SG_Char *Proj4, const SG_Char *Authority, int Authority_ID);


        sLong                                                      Get_Count                              (void)  const;


        CSG_Projection                                    operator []                             (sLong Index)      const   {       return( Get_Projection(Index) );  }

        CSG_Projection                                    Get_Projection                  (sLong Index)      const;

        const SG_Char *                                  Get_Projection                  (                            int Code, const SG_Char    *Authority = NULL) const;

        bool                                                    Get_Projection                  (CSG_Projection &Projection, int Code, const SG_Char    *Authority = NULL) const;


        bool                                                    Get_Preference                  (CSG_Projection &Projection, int Code, const CSG_String &Authority       ) const;

        bool                                                    Get_Preference                  (CSG_Projection &Projection          , const CSG_String &Authority_Code  ) const;


        CSG_String                                            Get_Names_List                  (ESG_CRS_Type Type = ESG_CRS_Type::Undefined, bool bAddSelect = true)      const;


        static ESG_CRS_Type                         Get_CRS_Type                    (const CSG_String &Identifier);

        static CSG_String                             Get_CRS_Type_Identifier (ESG_CRS_Type Type);

        static CSG_String                             Get_CRS_Type_Name               (ESG_CRS_Type Type);


        static ESG_Projection_Unit           Get_Unit                                (const CSG_String &Identifier);

        static const CSG_String                       Get_Unit_Identifier             (ESG_Projection_Unit Unit);

        static const CSG_String                       Get_Unit_Name                   (ESG_Projection_Unit Unit, bool bSimple = true);

        static double                                   Get_Unit_To_Meter               (ESG_Projection_Unit Unit);


        static CSG_String                             Convert_WKT2_to_XML             (const CSG_String &WKT);


        void                                                    Set_UseInternalDB              (bool bUse = true) { m_bUseInternalDB = bUse; }

        bool                                                    Get_UseInternalDB              (void) const { return( m_bUseInternalDB ); }


private:


        bool                                                    m_bUseInternalDB = true;


        class CSG_Table                                        *m_pProjections, *m_pPreferences;


        void                                                    _On_Construction                        (void);


private:


        CSG_Translator                                    m_WKT1_to_Proj4, m_Proj4_to_WKT1, m_EPSG_to_Idx;


        bool                                                    _Load                                           (class CSG_Table *pTable, const CSG_String &File, bool bAppend = false) const;


        static CSG_Projection                     _Get_Projection                         (class CSG_Table_Record *pProjection);


        bool                                                    _Add_Preferences                        (void);


        static CSG_MetaData                         _WKT2_to_MetaData                       (const CSG_String &WKT, bool bTrim);

        static bool                                             _WKT2_to_MetaData                       (CSG_MetaData &MetaData, const CSG_String &WKT);


        static CSG_MetaData                         _WKT1_to_MetaData                       (const CSG_String &WKT);

        static bool                                             _WKT1_to_MetaData                       (CSG_MetaData &MetaData, const CSG_String &WKT);


        bool                                                    _WKT1_to_Proj4                          (CSG_String &Proj4, const CSG_String &WKT  )     const;

        bool                                                    _WKT1_from_Proj4                        (CSG_String &WKT  , const CSG_String &Proj4)     const;

        bool                                                    _WKT1_to_Proj4_Set_Datum        (CSG_String &Proj4, const CSG_MetaData &WKT)   const;


        static bool                                             _Proj4_Find_Parameter           (                   const CSG_String &Proj4, const CSG_String &Key);

        static bool                                             _Proj4_Read_Parameter           (CSG_String &Value, const CSG_String &Proj4, const CSG_String &Key);

        static bool                                             _Proj4_Get_Ellipsoid            (CSG_String &Value, const CSG_String &Proj4);

        static bool                                             _Proj4_Get_Datum                        (CSG_String &Value, const CSG_String &Proj4);

        static bool                                             _Proj4_Get_Prime_Meridian       (CSG_String &Value, const CSG_String &Proj4);

        static bool                                             _Proj4_Get_Unit                         (CSG_String &Value, const CSG_String &Proj4);


        bool                                                    _Set_Dictionary                         (void);

        bool                                                    _Set_Dictionary                         (CSG_Table &Dictionary, int Direction);


};


//---------------------------------------------------------

SAGA_API_DLL_EXPORT CSG_Projections & SG_Get_Projections            (void);


//---------------------------------------------------------

SAGA_API_DLL_EXPORT bool                             SG_Get_Projected                (class CSG_Shapes *pSource, class CSG_Shapes *pTarget, const CSG_Projection &Target);


SAGA_API_DLL_EXPORT bool                             SG_Get_Projected                (const CSG_Projection &Source, const CSG_Projection &Target, TSG_Point &Point    );

SAGA_API_DLL_EXPORT bool                             SG_Get_Projected                (const CSG_Projection &Source, const CSG_Projection &Target, TSG_Rect  &Rectangle);


//---------------------------------------------------------

SAGA_API_DLL_EXPORT bool                             SG_Grid_Get_Geographic_Coordinates    (CSG_Grid *pGrid, CSG_Grid *pLon, CSG_Grid *pLat);


//                                                       //

//                                              Functions                                                //

//                                                       //


//---------------------------------------------------------

SAGA_API_DLL_EXPORT bool             SG_Is_Equal                                          (double a, double b, double epsilon = 0.);

SAGA_API_DLL_EXPORT bool             SG_Is_Equal                                          (const TSG_Point &A, const TSG_Point &B, double epsilon = 0.);


SAGA_API_DLL_EXPORT bool             SG_Is_Between                                      (double x, double a, double b, double epsilon = 0.);

SAGA_API_DLL_EXPORT bool             SG_Is_Between                                      (const TSG_Point &Point, const TSG_Point &Corner_A, const TSG_Point &Corner_B, double epsilon = 0.);


//---------------------------------------------------------

SAGA_API_DLL_EXPORT double           SG_Get_Length                                      (double dx, double dy);


SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (double ax, double ay, double bx, double by, bool bPolar);

SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (const TSG_Point &A, const TSG_Point &B    , bool bPolar);


SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (double ax, double ay, double bx, double by);

SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (const TSG_Point &A, const TSG_Point &B);


SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (double ax, double ay, double az, double bx, double by, double bz);

SAGA_API_DLL_EXPORT double           SG_Get_Distance                                  (const TSG_Point_3D &A, const TSG_Point_3D &B);


SAGA_API_DLL_EXPORT double           SG_Get_Distance_Polar                      (double aLon, double aLat, double bLon, double bLat, double a = 6378137., double e = 298.257223563, bool bDegree = true);

SAGA_API_DLL_EXPORT double           SG_Get_Distance_Polar                      (const TSG_Point &A      , const TSG_Point &B      , double a = 6378137., double e = 298.257223563, bool bDegree = true);


SAGA_API_DLL_EXPORT double           SG_Get_Angle_Of_Direction              (double dx, double dy);

SAGA_API_DLL_EXPORT double           SG_Get_Angle_Of_Direction              (double ax, double ay, double bx, double by);

SAGA_API_DLL_EXPORT double           SG_Get_Angle_Of_Direction              (const TSG_Point &A);

SAGA_API_DLL_EXPORT double           SG_Get_Angle_Of_Direction              (const TSG_Point &A, const TSG_Point &B);

SAGA_API_DLL_EXPORT double           SG_Get_Angle_Difference                  (double a, double b);

SAGA_API_DLL_EXPORT bool             SG_is_Angle_Between                          (double Angle, double Angle_Min, double Angle_Max, bool bCheckRange = true);


SAGA_API_DLL_EXPORT bool             SG_Get_Crossing                                  (TSG_Point &Crossing, const TSG_Point &a1, const TSG_Point &a2, const TSG_Point &b1, const TSG_Point &b2, bool bExactMatch = true);

SAGA_API_DLL_EXPORT bool             SG_Get_Crossing_InRegion                (TSG_Point &Crossing, const TSG_Point &a , const TSG_Point & b, const TSG_Rect &Region);


SAGA_API_DLL_EXPORT bool             SG_Is_Point_On_Line                          (const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, bool bExactMatch = false, double Epsilon = 0.);

SAGA_API_DLL_EXPORT double           SG_Get_Distance_To_Line                  (const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, bool bExactMatch = true);

SAGA_API_DLL_EXPORT double           SG_Get_Nearest_Point_On_Line        (const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, TSG_Point &Line_Point, bool bExactMatch = true);


SAGA_API_DLL_EXPORT bool             SG_Get_Triangle_CircumCircle        (TSG_Point Triangle[3], TSG_Point &Point, double &Radius);


SAGA_API_DLL_EXPORT double           SG_Get_Polygon_Area                          (TSG_Point *Points, int nPoints);

SAGA_API_DLL_EXPORT double           SG_Get_Polygon_Area                          (const CSG_Points &Points);


//                                                       //

//                                                       //

//                                                       //


//---------------------------------------------------------

#endif // #ifndef HEADER_INCLUDED__SAGA_API__geo_tools_H

api_core.h

TSG_Array_Growth
TSG_Array_Growth
Definition api_core.h:291

TSG_Array_Growth::SG_ARRAY_GROWTH_1
@ SG_ARRAY_GROWTH_1
Definition api_core.h:293

sLong
signed long long sLong
Definition api_core.h:158

SAGA_API_DLL_EXPORT
#define SAGA_API_DLL_EXPORT
Definition api_core.h:94

SG_Char
#define SG_Char
Definition api_core.h:536

operator+
SAGA_API_DLL_EXPORT CSG_String operator+(const char *A, const CSG_String &B)
Definition api_string.cpp:473

CSG_Array_Pointer
Definition api_core.h:368

CSG_Array
Definition api_core.h:308

CSG_Distance_Weighting::CSG_Distance_Weighting
CSG_Distance_Weighting(void)
Definition geo_classes.cpp:1363

CSG_Distance_Weighting::Add_Parameters
static bool Add_Parameters(class CSG_Parameters &Parameters, const CSG_String &Parent="", bool bIDW_Offset=false)
Definition geo_classes.cpp:1396

CSG_Distance_Weighting::Get_IDW_Power
double Get_IDW_Power(void) const
Definition geo_tools.h:726

CSG_Distance_Weighting::Create_Parameters
bool Create_Parameters(class CSG_Parameters &Parameters, const CSG_String &Parent="", bool bIDW_Offset=false)
Definition geo_classes.cpp:1378

CSG_Distance_Weighting::Enable_Parameters
static bool Enable_Parameters(class CSG_Parameters &Parameters)
Definition geo_classes.cpp:1434

CSG_Distance_Weighting::Get_IDW_Offset
bool Get_IDW_Offset(void) const
Definition geo_tools.h:729

CSG_Distance_Weighting::Get_Weight
double Get_Weight(double Distance) const
Definition geo_tools.h:736

CSG_Distance_Weighting::Set_Parameters
bool Set_Parameters(class CSG_Parameters &Parameters)
Definition geo_classes.cpp:1449

CSG_Distance_Weighting::Get_BandWidth
double Get_BandWidth(void) const
Definition geo_tools.h:732

CSG_Distance_Weighting::Get_Weighting
TSG_Distance_Weighting Get_Weighting(void) const
Definition geo_tools.h:723

CSG_File
Definition api_core.h:1129

CSG_Grid
Definition grid.h:501

CSG_Lines
Definition geo_tools.h:217

CSG_Lines::Get_Line
CSG_Points & Get_Line(sLong Index)
Definition geo_tools.h:242

CSG_Lines::CSG_Lines
CSG_Lines(void)
Definition geo_classes.cpp:373

CSG_Lines::Get_Count
sLong Get_Count(void) const
Definition geo_tools.h:240

CSG_Lines::Get_Line
const CSG_Points & Get_Line(sLong Index) const
Definition geo_tools.h:243

CSG_Lines::Create
bool Create(const CSG_Lines &Lines)
Definition geo_classes.cpp:385

CSG_Lines::Destroy
bool Destroy(void)
Definition geo_classes.cpp:409

CSG_Lines::Clear
bool Clear(void)
Definition geo_classes.cpp:415

CSG_Lines::Assign
bool Assign(const CSG_Lines &Lines)
Definition geo_classes.cpp:421

CSG_MetaData
Definition metadata.h:88

CSG_Parameters
Definition parameters.h:1701

CSG_Point_3D
Definition geo_tools.h:272

CSG_Point_3D::Subtract
virtual void Subtract(const CSG_Point_3D &Point)
Definition geo_classes.cpp:184

CSG_Point_3D::Get_Distance
virtual double Get_Distance(const CSG_Point_3D &Point) const
Definition geo_tools.h:310

CSG_Point_3D::~CSG_Point_3D
virtual ~CSG_Point_3D(void)
Definition geo_tools.h:279

CSG_Point_3D::Assign
virtual void Assign(double x, double y, double z)
Definition geo_classes.cpp:162

CSG_Point_3D::Multiply
virtual void Multiply(const CSG_Point_3D &Point)
Definition geo_classes.cpp:191

CSG_Point_3D::is_Equal
virtual bool is_Equal(const CSG_Point_3D &Point, double epsilon=0.) const
Definition geo_tools.h:312

CSG_Point_3D::CSG_Point_3D
CSG_Point_3D(void)
Definition geo_classes.cpp:141

CSG_Point_3D::Get_Type
virtual TSG_Point_Type Get_Type(void) const
Definition geo_tools.h:281

CSG_Point_3D::is_Equal
virtual bool is_Equal(double _x, double _y, double _z, double epsilon=0.) const
Definition geo_tools.h:313

CSG_Point_3D::Divide
virtual void Divide(double Value)
Definition geo_classes.cpp:205

CSG_Point_3D::Get_Length
virtual double Get_Length(void) const
Definition geo_classes.cpp:213

CSG_Point_3D::Add
virtual void Add(const CSG_Point_3D &Point)
Definition geo_classes.cpp:177

CSG_Point_4D
Definition geo_tools.h:366

CSG_Point_4D::CSG_Point_4D
CSG_Point_4D(void)
Definition geo_classes.cpp:224

CSG_Point_4D::Subtract
virtual void Subtract(const CSG_Point_4D &Point)
Definition geo_classes.cpp:270

CSG_Point_4D::Assign
virtual void Assign(double x, double y, double z, double m)
Definition geo_classes.cpp:245

CSG_Point_4D::Multiply
virtual void Multiply(const CSG_Point_4D &Point)
Definition geo_classes.cpp:278

CSG_Point_4D::is_Equal
virtual bool is_Equal(double _x, double _y, double _z, double _m, double epsilon=0.) const
Definition geo_tools.h:407

CSG_Point_4D::Get_Distance
virtual double Get_Distance(const CSG_Point_4D &Point) const
Definition geo_tools.h:404

CSG_Point_4D::Add
virtual void Add(const CSG_Point_4D &Point)
Definition geo_classes.cpp:262

CSG_Point_4D::Get_Type
virtual TSG_Point_Type Get_Type(void) const
Definition geo_tools.h:375

CSG_Point_4D::is_Equal
virtual bool is_Equal(const CSG_Point_4D &Point, double epsilon=0.) const
Definition geo_tools.h:406

CSG_Point_4D::Divide
virtual void Divide(double Value)
Definition geo_classes.cpp:294

CSG_Point_4D::Get_Length
virtual double Get_Length(void) const
Definition geo_classes.cpp:303

CSG_Point_4D::~CSG_Point_4D
virtual ~CSG_Point_4D(void)
Definition geo_tools.h:373

CSG_Point
Definition geo_tools.h:135

CSG_Point::Add
virtual void Add(const CSG_Point &Point)
Definition geo_classes.cpp:99

CSG_Point::is_Equal
virtual bool is_Equal(double _x, double _y, double epsilon=0.) const
Definition geo_tools.h:176

CSG_Point::Get_Type
virtual TSG_Point_Type Get_Type(void) const
Definition geo_tools.h:144

CSG_Point::CSG_Point
CSG_Point(void)
Definition geo_classes.cpp:65

CSG_Point::Divide
virtual void Divide(double Value)
Definition geo_classes.cpp:123

CSG_Point::Assign
virtual void Assign(double x, double y)
Definition geo_classes.cpp:86

CSG_Point::~CSG_Point
virtual ~CSG_Point(void)
Definition geo_tools.h:142

CSG_Point::Subtract
virtual void Subtract(const CSG_Point &Point)
Definition geo_classes.cpp:105

CSG_Point::Multiply
virtual void Multiply(const CSG_Point &Point)
Definition geo_classes.cpp:111

CSG_Point::is_Equal
virtual bool is_Equal(const CSG_Point &Point, double epsilon=0.) const
Definition geo_tools.h:175

CSG_Point::Get_Distance
virtual double Get_Distance(const CSG_Point &Point) const
Definition geo_tools.h:173

CSG_Point::Get_Length
virtual double Get_Length(void) const
Definition geo_classes.cpp:130

CSG_Points_3D
Definition geo_tools.h:322

CSG_Points_3D::Set_Count
bool Set_Count(sLong nPoints)
Definition geo_tools.h:337

CSG_Points_3D::Clear
bool Clear(void)
Definition geo_tools.h:328

CSG_Points_3D::CSG_Points_3D
CSG_Points_3D(void)
Definition geo_classes.cpp:548

CSG_Points_3D::Assign
bool Assign(const CSG_Points_3D &Points)
Definition geo_classes.cpp:566

CSG_Points_3D::Del
bool Del(sLong Index)
Definition geo_tools.h:335

CSG_Points_3D::Get_Points
TSG_Point_3D * Get_Points(void) const
Definition geo_tools.h:340

CSG_Points_3D::Add
bool Add(const TSG_Point_3D &Point)
Definition geo_tools.h:334

CSG_Points_3D::Get_Count
sLong Get_Count(void) const
Definition geo_tools.h:338

CSG_Points_Int
Definition geo_tools.h:428

CSG_Points_Int::Del
bool Del(sLong Index)
Definition geo_tools.h:441

CSG_Points_Int::Get_Count
sLong Get_Count(void) const
Definition geo_tools.h:444

CSG_Points_Int::Add
bool Add(const TSG_Point_Int &Point)
Definition geo_tools.h:440

CSG_Points_Int::Assign
bool Assign(const CSG_Points_Int &Points)
Definition geo_classes.cpp:624

CSG_Points_Int::Clear
bool Clear(void)
Definition geo_tools.h:434

CSG_Points_Int::CSG_Points_Int
CSG_Points_Int(void)
Definition geo_classes.cpp:606

CSG_Points_Int::Set_Count
bool Set_Count(sLong nPoints)
Definition geo_tools.h:443

CSG_Points_Int::Get_Points
TSG_Point_Int * Get_Points(void) const
Definition geo_tools.h:446

CSG_Points
Definition geo_tools.h:185

CSG_Points::Set_Count
bool Set_Count(sLong nPoints)
Definition geo_tools.h:200

CSG_Points::CSG_Points
CSG_Points(void)
Definition geo_classes.cpp:316

CSG_Points::Clear
bool Clear(void)
Definition geo_tools.h:191

CSG_Points::Get_Points
TSG_Point * Get_Points(void) const
Definition geo_tools.h:203

CSG_Points::Del
bool Del(sLong Index)
Definition geo_tools.h:198

CSG_Points::Assign
bool Assign(const CSG_Points &Points)
Definition geo_classes.cpp:334

CSG_Points::Add
bool Add(const TSG_Point &Point)
Definition geo_tools.h:197

CSG_Points::Get_Count
sLong Get_Count(void) const
Definition geo_tools.h:201

CSG_Projection
Definition geo_tools.h:827

CSG_Projection::is_Geographic
bool is_Geographic(void) const
Definition geo_tools.h:901

CSG_Projection::Get_Authority
const CSG_String & Get_Authority(void) const
Definition geo_tools.h:894

CSG_Projection::CSG_Projections
friend class CSG_Projections
Definition geo_tools.h:828

CSG_Projection::CSG_Projection
CSG_Projection(void)
Definition projections.cpp:82

CSG_Projection::Get_Name
const CSG_String & Get_Name(void) const
Definition geo_tools.h:885

CSG_Projection::is_Projection
bool is_Projection(void) const
Definition geo_tools.h:904

CSG_Projection::Get_Proj4
const CSG_String & Get_Proj4(void) const
Definition geo_tools.h:897

CSG_Projection::Get_PROJ
const CSG_String & Get_PROJ(void) const
Definition geo_tools.h:890

CSG_Projection::Destroy
void Destroy(void)
Definition projections.cpp:235

CSG_Projection::Get_Code
int Get_Code(void) const
Definition geo_tools.h:895

CSG_Projection::Get_Type
ESG_CRS_Type Get_Type(void) const
Definition geo_tools.h:906

CSG_Projection::Get_WKT2
const CSG_String & Get_WKT2(void) const
Definition geo_tools.h:889

CSG_Projection::is_Equal
bool is_Equal(const CSG_Projection &Projection) const
Definition projections.cpp:501

CSG_Projection::Assign
bool Assign(const CSG_String &Definition)
Definition geo_tools.h:860

CSG_Projection::Assign
bool Assign(const CSG_Projection &Projection)
Definition geo_tools.h:859

CSG_Projection::Get_Authority_ID
int Get_Authority_ID(void) const
Definition geo_tools.h:898

CSG_Projection::Get_Unit
ESG_Projection_Unit Get_Unit(void) const
Definition geo_tools.h:910

CSG_Projection::Get_EPSG
int Get_EPSG(void) const
Definition geo_tools.h:899

CSG_Projection::Assign
bool Assign(int Code, const SG_Char *Authority=NULL)
Definition geo_tools.h:861

CSG_Projection::Create
bool Create(const CSG_Projection &Projection)
Definition projections.cpp:96

CSG_Projection::is_Geocentric
bool is_Geocentric(void) const
Definition geo_tools.h:903

CSG_Projection::is_Okay
bool is_Okay(void) const
Definition geo_tools.h:863

CSG_Projection::Get_WKT
const CSG_String & Get_WKT(void) const
Definition geo_tools.h:887

CSG_Projection::is_Geodetic
bool is_Geodetic(void) const
Definition geo_tools.h:902

CSG_Projections
Definition geo_tools.h:939

CSG_Projections::Create
bool Create(bool LoadCodeList=true)
Definition projections.cpp:787

CSG_Projections::Save
bool Save(const CSG_String &File)
Definition projections.cpp:1124

CSG_Projections::Get_Projection
CSG_Projection Get_Projection(sLong Index) const
Definition projections.cpp:920

CSG_Projections::Parse
static bool Parse(const CSG_String &Definition, CSG_String *PROJ=NULL, CSG_String *WKT2=NULL, CSG_String *WKT1=NULL, CSG_String *JSON=NULL, CSG_String *ESRI=NULL)
Definition projections.cpp:1187

CSG_Projections::Destroy
void Destroy(void)
Definition projections.cpp:848

CSG_Projections::Get_Count
sLong Get_Count(void) const
Definition projections.cpp:860

CSG_Projections::Add
bool Add(const CSG_Projection &Projection)
Definition projections.cpp:866

CSG_Projections::Get_UseInternalDB
bool Get_UseInternalDB(void) const
Definition geo_tools.h:984

CSG_Projections::Load
bool Load(const CSG_String &File, bool bAppend=false)
Definition projections.cpp:1118

CSG_Projections::Set_UseInternalDB
void Set_UseInternalDB(bool bUse=true)
Definition geo_tools.h:983

CSG_Projections::CSG_Projections
CSG_Projections(void)
Definition projections.cpp:774

CSG_Projections::CSG_Projection
friend class CSG_Projection
Definition geo_tools.h:940

CSG_Rect_Int
Definition geo_tools.h:591

CSG_Rect_Int::CSG_Rect_Int
CSG_Rect_Int(void)
Definition geo_classes.cpp:1029

CSG_Rect_Int::is_Equal
bool is_Equal(int xMin, int yMin, int xMax, int yMax) const
Definition geo_classes.cpp:1226

CSG_Rect_Int::Get_BottomRight
TSG_Point_Int Get_BottomRight(void) const
Definition geo_tools.h:634

CSG_Rect_Int::Get_YMin
int Get_YMin(void) const
Definition geo_tools.h:624

CSG_Rect_Int::Move
CSG_Rect_Int & Move(int dx, int dy)
Definition geo_classes.cpp:1130

CSG_Rect_Int::Get_YRange
int Get_YRange(void) const
Definition geo_tools.h:628

CSG_Rect_Int::Get_YMax
int Get_YMax(void) const
Definition geo_tools.h:625

CSG_Rect_Int::Get_Diameter
double Get_Diameter(void) const
Definition geo_tools.h:631

CSG_Rect_Int::Get_TopLeft
TSG_Point_Int Get_TopLeft(void) const
Definition geo_tools.h:633

CSG_Rect_Int::Get_XMax
int Get_XMax(void) const
Definition geo_tools.h:623

CSG_Rect_Int::Get_Area
double Get_Area(void) const
Definition geo_tools.h:630

CSG_Rect_Int::Assign
CSG_Rect_Int & Assign(int xMin, int yMin, int xMax, int yMax)
Definition geo_classes.cpp:1093

CSG_Rect_Int::Get_XMin
int Get_XMin(void) const
Definition geo_tools.h:622

CSG_Rect_Int::Get_XRange
int Get_XRange(void) const
Definition geo_tools.h:627

CSG_Rect_Int::Create
bool Create(int xMin, int yMin, int xMax, int yMax)
Definition geo_classes.cpp:1064

CSG_Rect
Definition geo_tools.h:474

CSG_Rect::Create
bool Create(double xMin, double yMin, double xMax, double yMax)
Definition geo_classes.cpp:698

CSG_Rect::Get_Area
double Get_Area(void) const
Definition geo_tools.h:513

CSG_Rect::is_Equal
bool is_Equal(double xMin, double yMin, double xMax, double yMax, double epsilon=0.) const
Definition geo_classes.cpp:858

CSG_Rect::Get_YRange
double Get_YRange(void) const
Definition geo_tools.h:511

CSG_Rect::CSG_Rect
CSG_Rect(void)
Definition geo_classes.cpp:663

CSG_Rect::Move
CSG_Rect & Move(double dx, double dy)
Definition geo_classes.cpp:778

CSG_Rect::Get_YCenter
double Get_YCenter(void) const
Definition geo_tools.h:521

CSG_Rect::Get_XMax
double Get_XMax(void) const
Definition geo_tools.h:506

CSG_Rect::Get_XRange
double Get_XRange(void) const
Definition geo_tools.h:510

CSG_Rect::Get_XMin
double Get_XMin(void) const
Definition geo_tools.h:505

CSG_Rect::Get_TopLeft
CSG_Point Get_TopLeft(void) const
Definition geo_tools.h:516

CSG_Rect::Get_YMin
double Get_YMin(void) const
Definition geo_tools.h:507

CSG_Rect::Get_XCenter
double Get_XCenter(void) const
Definition geo_tools.h:520

CSG_Rect::Get_YMax
double Get_YMax(void) const
Definition geo_tools.h:508

CSG_Rect::Get_BottomRight
CSG_Point Get_BottomRight(void) const
Definition geo_tools.h:517

CSG_Rect::Get_Diameter
double Get_Diameter(void) const
Definition geo_tools.h:514

CSG_Rect::Get_Center
CSG_Point Get_Center(void) const
Definition geo_tools.h:519

CSG_Rect::Assign
CSG_Rect & Assign(double xMin, double yMin, double xMax, double yMax)
Definition geo_classes.cpp:727

CSG_Rects_Int::Get_Rect
CSG_Rect_Int & Get_Rect(int Index)
Definition geo_tools.h:678

CSG_Rects_Int::Clear
void Clear(void)
Definition geo_classes.cpp:1296

CSG_Rects_Int::Add
bool Add(void)
Definition geo_classes.cpp:1334

CSG_Rects_Int::Assign
bool Assign(const CSG_Rects_Int &Rects)
Definition geo_classes.cpp:1313

CSG_Rects_Int::CSG_Rects_Int
CSG_Rects_Int(void)
Definition geo_classes.cpp:1283

CSG_Rects_Int::Get_Count
int Get_Count(void) const
Definition geo_tools.h:675

CSG_Rects::Add
bool Add(void)
Definition geo_classes.cpp:1000

CSG_Rects::CSG_Rects
CSG_Rects(void)
Definition geo_classes.cpp:942

CSG_Rects::Clear
void Clear(void)
Definition geo_classes.cpp:962

CSG_Rects::Get_Rect
CSG_Rect & Get_Rect(int Index)
Definition geo_tools.h:566

CSG_Rects::Assign
bool Assign(const CSG_Rects &Rects)
Definition geo_classes.cpp:979

CSG_Rects::Get_Count
int Get_Count(void) const
Definition geo_tools.h:563

CSG_Shapes
Definition shapes.h:772

CSG_String
Definition api_core.h:563

CSG_Table_Record
Definition table.h:130

CSG_Table
Definition table.h:285

CSG_Translator
Definition api_core.h:1512

B
#define B

A
#define A

SG_Get_Distance
SAGA_API_DLL_EXPORT double SG_Get_Distance(double ax, double ay, double bx, double by, bool bPolar)
Definition geo_functions.cpp:103

SG_Get_Triangle_CircumCircle
SAGA_API_DLL_EXPORT bool SG_Get_Triangle_CircumCircle(TSG_Point Triangle[3], TSG_Point &Point, double &Radius)
Definition geo_functions.cpp:465

SG_is_Angle_Between
SAGA_API_DLL_EXPORT bool SG_is_Angle_Between(double Angle, double Angle_Min, double Angle_Max, bool bCheckRange=true)
Definition geo_functions.cpp:257

SG_Get_Length
SAGA_API_DLL_EXPORT double SG_Get_Length(double dx, double dy)
Definition geo_functions.cpp:97

ESG_CRS_Type
ESG_CRS_Type
Definition geo_tools.h:789

ESG_CRS_Type::Projection
@ Projection
Definition geo_tools.h:790

ESG_CRS_Type::Geographic
@ Geographic
Definition geo_tools.h:790

ESG_CRS_Type::Geodetic
@ Geodetic
Definition geo_tools.h:790

ESG_CRS_Type::Undefined
@ Undefined
Definition geo_tools.h:790

ESG_CRS_Type::Geocentric
@ Geocentric
Definition geo_tools.h:790

TSG_Point
struct SSG_Point TSG_Point

SG_Get_Distance_Polar
SAGA_API_DLL_EXPORT double SG_Get_Distance_Polar(double aLon, double aLat, double bLon, double bLat, double a=6378137., double e=298.257223563, bool bDegree=true)
Definition geo_functions.cpp:157

TSG_Distance_Weighting
TSG_Distance_Weighting
Definition geo_tools.h:698

SG_DISTWGHT_GAUSS
@ SG_DISTWGHT_GAUSS
Definition geo_tools.h:702

SG_DISTWGHT_None
@ SG_DISTWGHT_None
Definition geo_tools.h:699

SG_DISTWGHT_EXP
@ SG_DISTWGHT_EXP
Definition geo_tools.h:701

SG_DISTWGHT_IDW
@ SG_DISTWGHT_IDW
Definition geo_tools.h:700

SG_Get_Angle_Of_Direction
SAGA_API_DLL_EXPORT double SG_Get_Angle_Of_Direction(double dx, double dy)
Definition geo_functions.cpp:216

SG_Get_Crossing
SAGA_API_DLL_EXPORT bool SG_Get_Crossing(TSG_Point &Crossing, const TSG_Point &a1, const TSG_Point &a2, const TSG_Point &b1, const TSG_Point &b2, bool bExactMatch=true)
Definition geo_functions.cpp:280

SG_Get_Crossing_InRegion
SAGA_API_DLL_EXPORT bool SG_Get_Crossing_InRegion(TSG_Point &Crossing, const TSG_Point &a, const TSG_Point &b, const TSG_Rect &Region)
Definition geo_functions.cpp:342

TSG_Point_3D
struct SSG_Point_3D TSG_Point_3D

SG_Is_Equal
SAGA_API_DLL_EXPORT bool SG_Is_Equal(double a, double b, double epsilon=0.)
Definition geo_functions.cpp:64

SG_Get_Polygon_Area
SAGA_API_DLL_EXPORT double SG_Get_Polygon_Area(TSG_Point *Points, int nPoints)
Definition geo_functions.cpp:514

SG_Grid_Get_Geographic_Coordinates
SAGA_API_DLL_EXPORT bool SG_Grid_Get_Geographic_Coordinates(CSG_Grid *pGrid, CSG_Grid *pLon, CSG_Grid *pLat)
Definition projections.cpp:2859

TSG_Point_4D
struct SSG_Point_4D TSG_Point_4D

SG_Get_Projections
SAGA_API_DLL_EXPORT CSG_Projections & SG_Get_Projections(void)
Definition projections.cpp:69

ESG_Projection_Unit
ESG_Projection_Unit
Definition geo_tools.h:795

ESG_Projection_Unit::Indian_Yard
@ Indian_Yard
Definition geo_tools.h:814

ESG_Projection_Unit::US_Inch
@ US_Inch
Definition geo_tools.h:809

ESG_Projection_Unit::Indian_Chain
@ Indian_Chain
Definition geo_tools.h:816

ESG_Projection_Unit::Meter
@ Meter
Definition geo_tools.h:797

ESG_Projection_Unit::Int_Yard
@ Int_Yard
Definition geo_tools.h:804

ESG_Projection_Unit::Int_Statute_Mile
@ Int_Statute_Mile
Definition geo_tools.h:805

ESG_Projection_Unit::US_Yard
@ US_Yard
Definition geo_tools.h:811

ESG_Projection_Unit::Int_Nautical_Mile
@ Int_Nautical_Mile
Definition geo_tools.h:801

ESG_Projection_Unit::Int_Chain
@ Int_Chain
Definition geo_tools.h:807

ESG_Projection_Unit::Int_Foot
@ Int_Foot
Definition geo_tools.h:803

ESG_Projection_Unit::US_Foot
@ US_Foot
Definition geo_tools.h:810

ESG_Projection_Unit::Int_Inch
@ Int_Inch
Definition geo_tools.h:802

ESG_Projection_Unit::First
@ First
Definition geo_tools.h:817

ESG_Projection_Unit::Int_Link
@ Int_Link
Definition geo_tools.h:808

ESG_Projection_Unit::Indian_Foot
@ Indian_Foot
Definition geo_tools.h:815

ESG_Projection_Unit::US_Statute_Mile
@ US_Statute_Mile
Definition geo_tools.h:813

ESG_Projection_Unit::Millimeter
@ Millimeter
Definition geo_tools.h:800

ESG_Projection_Unit::Centimeter
@ Centimeter
Definition geo_tools.h:799

ESG_Projection_Unit::Decimeter
@ Decimeter
Definition geo_tools.h:798

ESG_Projection_Unit::US_Chain
@ US_Chain
Definition geo_tools.h:812

ESG_Projection_Unit::Int_Fathom
@ Int_Fathom
Definition geo_tools.h:806

ESG_Projection_Unit::Kilometer
@ Kilometer
Definition geo_tools.h:796

SG_Is_Between
SAGA_API_DLL_EXPORT bool SG_Is_Between(double x, double a, double b, double epsilon=0.)
Definition geo_functions.cpp:77

TSG_Rect_Int
struct SSG_Rect_Int TSG_Rect_Int

SG_Get_Distance_To_Line
SAGA_API_DLL_EXPORT double SG_Get_Distance_To_Line(const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, bool bExactMatch=true)
Definition geo_functions.cpp:413

TSG_Point_Int
struct SSG_Point_Int TSG_Point_Int

SG_Get_Projected
SAGA_API_DLL_EXPORT bool SG_Get_Projected(class CSG_Shapes *pSource, class CSG_Shapes *pTarget, const CSG_Projection &Target)
Definition projections.cpp:2740

SG_Is_Point_On_Line
SAGA_API_DLL_EXPORT bool SG_Is_Point_On_Line(const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, bool bExactMatch=false, double Epsilon=0.)
Definition geo_functions.cpp:394

TSG_Point_Type
TSG_Point_Type
Definition geo_tools.h:112

TSG_Point_Type::SG_POINT_TYPE_4D
@ SG_POINT_TYPE_4D
Definition geo_tools.h:115

TSG_Point_Type::SG_POINT_TYPE_3D
@ SG_POINT_TYPE_3D
Definition geo_tools.h:114

TSG_Point_Type::SG_POINT_TYPE_2D_Int
@ SG_POINT_TYPE_2D_Int
Definition geo_tools.h:116

TSG_Point_Type::SG_POINT_TYPE_2D
@ SG_POINT_TYPE_2D
Definition geo_tools.h:113

ESG_CRS_Format
ESG_CRS_Format
Definition geo_tools.h:783

ESG_CRS_Format::CODE
@ CODE
Definition geo_tools.h:784

ESG_CRS_Format::JSON
@ JSON
Definition geo_tools.h:784

ESG_CRS_Format::ESRI
@ ESRI
Definition geo_tools.h:784

ESG_CRS_Format::WKT
@ WKT
Definition geo_tools.h:784

ESG_CRS_Format::WKT2
@ WKT2
Definition geo_tools.h:784

ESG_CRS_Format::WKT1
@ WKT1
Definition geo_tools.h:784

ESG_CRS_Format::PROJ
@ PROJ
Definition geo_tools.h:784

ESG_CRS_Format::Undefined
@ Undefined
Definition geo_tools.h:784

TSG_Intersection
TSG_Intersection
Definition geo_tools.h:101

INTERSECTION_Overlaps
@ INTERSECTION_Overlaps
Definition geo_tools.h:104

INTERSECTION_None
@ INTERSECTION_None
Definition geo_tools.h:102

INTERSECTION_Contains
@ INTERSECTION_Contains
Definition geo_tools.h:106

INTERSECTION_Identical
@ INTERSECTION_Identical
Definition geo_tools.h:103

INTERSECTION_Contained
@ INTERSECTION_Contained
Definition geo_tools.h:105

TSG_Rect
struct SSG_Rect TSG_Rect

SG_Get_Nearest_Point_On_Line
SAGA_API_DLL_EXPORT double SG_Get_Nearest_Point_On_Line(const TSG_Point &Point, const TSG_Point &Line_A, const TSG_Point &Line_B, TSG_Point &Line_Point, bool bExactMatch=true)
Definition geo_functions.cpp:421

SG_Get_Angle_Difference
SAGA_API_DLL_EXPORT double SG_Get_Angle_Difference(double a, double b)
Definition geo_functions.cpp:247

operator*
CSG_Vector operator*(double Scalar, const CSG_Vector &Vector)
Definition mat_matrix.cpp:579

metadata.h

SSG_Point_3D
Definition geo_tools.h:265

SSG_Point_3D::x
double x
Definition geo_tools.h:266

SSG_Point_3D::y
double y
Definition geo_tools.h:266

SSG_Point_3D::z
double z
Definition geo_tools.h:266

SSG_Point_4D
Definition geo_tools.h:359

SSG_Point_4D::z
double z
Definition geo_tools.h:360

SSG_Point_4D::x
double x
Definition geo_tools.h:360

SSG_Point_4D::m
double m
Definition geo_tools.h:360

SSG_Point_4D::y
double y
Definition geo_tools.h:360

SSG_Point_Int
Definition geo_tools.h:421

SSG_Point_Int::x
int x
Definition geo_tools.h:422

SSG_Point_Int::y
int y
Definition geo_tools.h:422

SSG_Point
Definition geo_tools.h:128

SSG_Point::x
double x
Definition geo_tools.h:129

SSG_Point::y
double y
Definition geo_tools.h:129

SSG_Rect_Int
Definition geo_tools.h:584

SSG_Rect_Int::xMin
int xMin
Definition geo_tools.h:585

SSG_Rect_Int::yMin
int yMin
Definition geo_tools.h:585

SSG_Rect_Int::yMax
int yMax
Definition geo_tools.h:585

SSG_Rect_Int::xMax
int xMax
Definition geo_tools.h:585

SSG_Rect
Definition geo_tools.h:467

SSG_Rect::xMin
double xMin
Definition geo_tools.h:468

SSG_Rect::xMax
double xMax
Definition geo_tools.h:468

SSG_Rect::yMin
double yMin
Definition geo_tools.h:468

SSG_Rect::yMax
double yMax
Definition geo_tools.h:468