map_layer.h

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                      map_layer.h                      //
//                                                       //
//                 Copyright (C) 2026 by                 //
//                      Olaf Conrad                      //
//                                                       //
//-------------------------------------------------------//
//                                                       //
// This file is part of 'SAGA - System for Automated     //
// Geoscientific Analyses'. SAGA is free software; you   //
// can redistribute it and/or modify it under the terms  //
// of the GNU General Public License as published by the //
// Free Software Foundation, either version 2 of the     //
// License, or (at your option) any later version.       //
//                                                       //
// SAGA 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 General Public        //
// License for more details.                             //
//                                                       //
// You should have received a copy of the GNU General    //
// Public License along with this program; if not, see   //
// <http://www.gnu.org/licenses/>.                       //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//    e-mail:     oconrad@saga-gis.org                   //
//                                                       //
//    contact:    Olaf Conrad                            //
//                Institute of Geography                 //
//                University of Hamburg                  //
//                Germany                                //
//                                                       //
 
//---------------------------------------------------------
#ifndef _HEADER_INCLUDED__SAGA_GDI__Map_Layer_H
#define _HEADER_INCLUDED__SAGA_GDI__Map_Layer_H
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#include "map_dc.h"
#include "../parameters.h"
#include "../grids.h"
#include "../pointcloud.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#define LAYER_DRAW_FLAG_THUMBNAIL 0x01
#define LAYER_DRAW_FLAG_SELECTION 0x02
#define LAYER_DRAW_FLAG_HIGHLIGHT 0x04
#define LAYER_DRAW_FLAG_NOEDITS   0x08
#define LAYER_DRAW_FLAG_NOLABELS  0x10
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Layer
{
public:
 
        CSG_Map_Layer(void) {}
        virtual ~CSG_Map_Layer(void);
 
        const TSG_Data_Object_Type &        Get_ObjectType                    (void) const { return( m_Type ); }
 
        bool                                                    Set_Object                              (CSG_Data_Object *pObject);
        CSG_Data_Object *                                Get_Object                            (void) const { return( m_pObject ); }
        CSG_Rect                                                Get_Extent                              (void) const;
 
        static CSG_Parameters &                   Get_Defaults                    (void);
 
        virtual bool                                    Add_Parameters                  (CSG_Parameters &Parameters);
        CSG_Parameters &                          Get_Parameters                    (void) { return( m_Parameters ); }
        bool                                                    Set_Parameters                  (const CSG_Parameters &Parameters);
 
        virtual bool                                    Parameter_Changed               (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                                    Parameters_Changed              (void);
        virtual bool                                    DataObject_Changed              (void);
 
        bool                                                    Sync_Back                               (CSG_Parameters &Target) const;
        bool                                                    Sync_Forward                    (const CSG_Parameters &Source);
 
        bool                                                    Draw                                    (CSG_Map_DC &dc_Map, int Flags = 0, CSG_Data_Object *pObject = NULL);
 
        CSG_Table &                                            Get_LUT                                 (void);
        CSG_Colors &                                  Get_Colors                              (void);
        const CSG_Colors &                            Get_Colors                              (void)                     const;
        bool                                                    Get_Colors                              (      CSG_Colors &Colors) const;
        bool                                                    Set_Colors                              (const CSG_Colors &Colors);
 
        wxString                                                Get_Legend_Title                (void) const;
        wxString                                                Get_Legend_Subtitle             (void) const;
 
        bool                                                    Get_Field_Value                 (sLong Index, int Field, int Normalize, double Scale, wxString &Value) const;
        bool                                                    Get_Field_Value                 (sLong Index, int Field, int Normalize, double Scale, double   &Value) const;
 
        double                                                  Get_Stretch_Minimum             (void) const;
        double                                                  Get_Stretch_Maximum             (void) const;
        double                                                  Get_Stretch_Range               (void) const;
        bool                                                    Set_Stretch_Range               (double Minimum, double Maximum);
        bool                                                    Set_Stretch_FullRange   (void);
        virtual bool                                    Set_Stretch_Extent            (const CSG_Rect &Extent) { return( false ); }
 
        bool                                                    Classify                                (const CSG_MetaData &Options);
 
        class CSG_Map_Symbology *              Get_Symbology                      (void) { return( m_pSymbology ); }
        class CSG_Map_Legend *                    Get_Legend                            (void) { return( m_pLegend    ); }
 
        virtual bool                                    asImage                                  (CSG_Grid *pImage)      { return( false ); }
 
        const class wxBitmap *                  Get_Thumbnail                   (int dx, int dy);
        bool                                                    Set_Thumbnail                   (void);
 
 
protected:
 
        TSG_Data_Object_Type                        m_Type = SG_DATAOBJECT_TYPE_Undefined;
 
        CSG_Parameters                                    m_Parameters;
 
        CSG_Data_Object                                  *m_pObject    = NULL;
 
        class CSG_Map_Symbology                        *m_pSymbology = NULL;
 
        class CSG_Map_Legend                      *m_pLegend    = NULL;
 
        class wxBitmap                                  *m_pThumbnail = NULL;
 
        CSG_Table                                              m_Normalization;
 
 
        CSG_Map_Layer(TSG_Data_Object_Type Type);
 
        virtual void                                    On_Draw                                  (CSG_Map_DC &dc_Map, int Flags)       {}
 
        bool                                                    Set_Stretch                             (CSG_Parameters &Parameters, CSG_Data_Object *pObject = NULL, const CSG_String &Suffix = "");
 
        bool                                                    Set_Normalization               (int Field_Value, int Field_Normalize, double Scale_Normalize, sLong maxSamples = 0);
 
        bool                                                    Set_Fields_Choice               (CSG_Parameter &Choice, bool bNumeric, bool bAddNone, bool bSelectNone = false);
        static int                                              Get_Fields_Choice               (CSG_Parameter &Choice);
 
 
private:
 
        CSG_Table *                                            _Get_Field_Table                (int &Field, const CSG_Parameters &Parameters);
 
 
        //---------------------------------------------------------
public: 
 
        class CTransparency
        {
        public:
 
                bool                                            Create                                    (CSG_Grid *pGrid, double Minimum, double Maximum)
                {
                        m_pGrid = pGrid && Minimum != Maximum ? pGrid : NULL;
 
                        if( m_pGrid )
                        {
                                m_Minimum = Minimum; m_Scale = 255. / (Maximum - Minimum);
                        }
 
                        return( m_pGrid != NULL );
                }
 
                bool                                            is_Okay                                  (void) const { return( m_pGrid != NULL ); }
 
                BYTE                                            Get_Alpha                              (const CSG_Point &Point) const
                {
                        return( Get_Alpha(Point.x, Point.y) );
                }
 
                BYTE                                            Get_Alpha                              (double x, double y) const
                {
                        if( m_pGrid )
                        {
                                double Alpha;
 
                                if( m_pGrid->Get_Value(x, y, Alpha) )
                                {
                                        Alpha = (Alpha - m_Minimum) * m_Scale;
 
                                        return( Alpha <= 0. ? 0 : Alpha >= 255. ? 255 : (BYTE)Alpha );
                                }
 
                                return( 0 );
                        }
 
                        return( 255 );
                }
 
                BYTE                                            Get_Alpha                              (const CSG_Grid_System &System, int x, int y) const
                {
                        return( Get_Alpha(System.Get_xGrid_to_World(x), System.Get_yGrid_to_World(y)) );
                }
 
                bool                                            Set_Alpha                              (int &Color, const CSG_Point &Point) const
                {
                        return( Set_Alpha(Color, Point.x, Point.y) );
                }
 
                bool                                            Set_Alpha                              (int &Color, double x, double y) const
                {
                        if( m_pGrid )
                        {
                                ((BYTE *)&Color)[3] = Get_Alpha(x, y);
 
                                return( true );
                        }
 
                        return( false );
                }
 
                bool                                            Set_Alpha                              (int &Color, const CSG_Grid_System &System, int x, int y) const
                {
                        if( m_pGrid )
                        {
                                ((BYTE *)&Color)[3] = Get_Alpha(System.Get_xGrid_to_World(x), System.Get_yGrid_to_World(y));
 
                                return( true );
                        }
 
                        return( false );
                }
 
 
        private:
 
                double                                          m_Minimum = 0., m_Scale = 1.;
 
                CSG_Grid                                        *m_pGrid = NULL;
 
        };
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Grid : public CSG_Map_Layer
{
public:
        CSG_Map_Grid(CSG_Grid *pGrid = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        virtual bool                            Update                                    (CSG_Data_Object *pChanged);
 
        virtual bool                            Set_Stretch_Extent            (const CSG_Rect &Extent);
 
        virtual bool                            asImage                                  (CSG_Grid *pImage);
 
        virtual bool                            Get_Image                              (wxImage  &Image , bool bFitSize = true, int Width = 0, int Height = 0);
        virtual bool                            Get_Bitmap                            (wxBitmap &Bitmap, bool bFitSize = true, int Width = 0, int Height = 0);
        virtual bool                            Get_Bitmap_Legend              (wxBitmap &Bitmap, double Zoom);
 
        CSG_Grid *                                      Get_Composite_Band            (int Band);
 
 
protected:
 
        virtual void                            On_Draw                                  (CSG_Map_DC &dc_Map, int Flags);
 
 
private:
 
        int                                                     m_Stretch_Extent = -1, m_xSel = 0, m_ySel = 0;
 
        CTransparency                              m_Alpha;
 
        //-----------------------------------------------------
        class CComposite
        {
        public:
                CSG_Grid *pReference = NULL, *pGrid = NULL; CSG_Scaler Scaler;
 
                CComposite &                    operator =                              (const CComposite &Composite)
                {
                        pReference = Composite.pReference; pGrid = Composite.pGrid; Scaler = Composite.Scaler;
 
                        return( *this );
                }
 
                bool                                    Set_Color                               (BYTE &Color, int x, int y)
                {
                        if( pGrid )
                        {
                                if( pReference && pReference != pGrid && pReference->Get_System() != pGrid->Get_System() )
                                {
                                        return( Set_Color(Color, pReference->Get_System().Get_Grid_to_World(x, y), CSG_Grid_Resampling::NearestNeighbour) );
                                }
 
                                if( pGrid->is_InGrid(x, y) )
                                {
                                        double Value = Scaler.to_Relative(pGrid->asDouble(x, y));
 
                                        Color = Value <= 0. ? 0 : Value >= 1. ? 255 : (BYTE)(255. * Value);
 
                                        return( true );
                                }
                        }
 
                        if( pGrid != pReference )
                        {
                                Color = 255;
 
                                return( true );
                        }
 
                        return( false );
                }
 
                bool                                    Set_Color                               (BYTE &Color, const CSG_Point &Point, CSG_Grid_Resampling Resampling)
                {
                        if( pGrid )
                        {
                                double Value;
 
                                if( pGrid->Get_Value(Point, Value, Resampling) )
                                {
                                        Value = Scaler.to_Relative(Value);
 
                                        Color = Value <= 0. ? 0 : Value >= 1. ? 255 : (BYTE)(255. * Value);
 
                                        return( true );
                                }
                        }
 
                        if( pGrid != pReference )
                        {
                                Color = 255;
 
                                return( true );
                        }
 
                        return( false );
                }
 
        }                                                       m_Composite[3];
 
 
        //-----------------------------------------------------
        void                                            _Composite_Update               (void);
        void                                            _Composite_Get                  (CComposite Composite[3]);
 
        bool                                            _Get_Stretch_Extent             (const CSG_Rect &Extent, CSG_Grid *pGrid, double &Minimum, double &Maximum) const;
 
        void                                            _Draw_Cells                             (CSG_Map_DC &dc_Map, CComposite Composite[3]);
        void                                            _Draw_Points                    (CSG_Map_DC &dc_Map, CComposite Composite[3], CSG_Grid_Resampling Resampling);
        void                                            _Draw_Points                    (CSG_Map_DC &dc_Map, CComposite Composite[3], CSG_Grid_Resampling Resampling, int yDC, int axDC, int bxDC);
 
        int                                                     _Adjust_Color                   (const CSG_Point &p, int Color, CSG_Grid_Resampling Resampling);
        int                                                     _Adjust_Color                   (int    x, int    y, int Color);
 
        void                                            _Draw_Values                    (CSG_Map_DC &dc_Map);
 
 
private:
 
        //-----------------------------------------------------
        class CShading
        {
        public:
 
                bool                                    Create                                  (int Mode, CSG_Grid *pGrid, double Height, double Azimuth, double Exaggeration, double Minimum, double Maximum)
                {
                        m_Mode = pGrid && pGrid->Get_Range() > 0. && Height >= 0. && Minimum != Maximum ? Mode : 0;
 
                        if( m_Mode )
                        {
                                m_pGrid        = pGrid;
                                m_Sin_Height   = sin(M_DEG_TO_RAD * Height);
                                m_Cos_Height   = cos(M_DEG_TO_RAD * Height);
                                m_Azimuth      =     M_DEG_TO_RAD * Azimuth;
                                m_Exaggeration = Exaggeration;
                                m_Minimum      = Minimum;
                                m_Range        = Maximum - Minimum;
                        }
 
                        return( is_Okay() );
                }
 
                bool                                    is_Okay                                 (void) const { return( m_Mode != 0 ); }
 
                bool                                    Set_Shading                             (int &Color, int x, int y) const
                {
                        double s, a; return( m_Mode && m_pGrid && m_pGrid->Get_Gradient(x, y, s, a             ) && _Set_Shading(s, a, Color) );
                }
 
                bool                                    Set_Shading                             (int &Color, const CSG_Point &Point, CSG_Grid_Resampling Resampling) const
                {
                        double s, a; return( m_Mode && m_pGrid && m_pGrid->Get_Gradient(Point, s, a, Resampling) && _Set_Shading(s, a, Color) );
                }
 
 
        private:
 
                int                                             m_Mode = 0;
 
                double                                  m_Sin_Height = 0., m_Cos_Height = 0, m_Azimuth = 0., m_Exaggeration = 1., m_Minimum = 0., m_Range = 1.;
 
                CSG_Grid                                *m_pGrid = NULL;
 
 
                bool                                    _Set_Shading                    (double s, double a, int &Color) const
                {
                        s = M_PI_090 - atan(m_Exaggeration * tan(s));
 
                        if( m_Mode == 1 )
                        {
                                _Set_Shading(acos(sin(s) * m_Sin_Height + cos(s) * m_Cos_Height * cos(a - m_Azimuth)), (BYTE *)&Color);
                        }
                        else
                        {
                                double sum = 0., dir = m_Azimuth - M_PI_180 / 2., sin_Slope = sin(s) * m_Sin_Height, cos_Slope = cos(s) * m_Cos_Height;
 
                                for(int i=0; i<6; i++, dir+=M_PI_180/5.)
                                {
                                        sum += acos(sin_Slope + cos_Slope * cos(a - dir));
                                }
 
                                _Set_Shading(sum / 6., (BYTE *)&Color);
                        }
 
                        return( true );
                }
 
                void                                    _Set_Shading                    (double Shade, BYTE *Color) const
                {
                        Shade = m_Range * ((1. - Shade / M_PI_090) - m_Minimum); double c;
 
                        c = Shade * Color[0]; Color[0] = c <= 0. ? 0 : c >= 255. ? 255 : (BYTE)c;
                        c = Shade * Color[1]; Color[1] = c <= 0. ? 0 : c >= 255. ? 255 : (BYTE)c;
                        c = Shade * Color[2]; Color[2] = c <= 0. ? 0 : c >= 255. ? 255 : (BYTE)c;
                }
 
        };
 
        CShading                                        m_Shading;
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Grids : public CSG_Map_Layer
{
public:
        CSG_Map_Grids(CSG_Grids *pGrids = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        CSG_Grid *                                      Get_Grid                                (void);
        CSG_Grid *                                      Get_Grid                                (int Band);
        CSG_String                                    Get_Grid_Name                      (int Band, int Style = SG_GRIDS_NAME_GRID);
 
        bool                                            Set_Grid_Choices                (CSG_Parameters &Parameters, int NameField = -1);
 
        virtual bool                            Set_Stretch_Extent            (const CSG_Rect &Extent);
 
        virtual bool                            asImage                                  (CSG_Grid *pImage);
 
        virtual bool                            Get_Image                              (wxImage  &Image , bool bFitSize = true, int Width = 0, int Height = 0);
        virtual bool                            Get_Bitmap                            (wxBitmap &Bitmap, bool bFitSize = true, int Width = 0, int Height = 0);
        virtual bool                            Get_Bitmap_Legend              (wxBitmap &Bitmap, double Zoom);
 
 
protected:
 
        virtual void                            On_Draw                                  (CSG_Map_DC &dc_Map, int Flags);
 
 
private:
 
        int                                                     m_Stretch_Extent = -1;
 
        CTransparency                              m_Alpha;
 
        CSG_Scaler                                    m_Stretch[3];
 
 
        CSG_String                                    _Get_List_Attributes    (void);
        CSG_String                                    _Get_List_Bands                 (int Attribute = -1);
 
        CSG_Grid *                                      _Get_Grid                               (int Band, const CSG_Parameters &Parameters);
 
        bool                                            _Get_Stretch_Extent             (const CSG_Rect &Extent, CSG_Data_Object *pObject, double &Minimum, double &Maximum) const;
 
        void                                            _Draw_Cells                             (CSG_Map_DC &dc_Map);
        void                                            _Draw_Points                    (CSG_Map_DC &dc_Map);
 
        bool                                            _Draw_Get_Color                 (int &Color, int x, int y          );
        bool                                            _Draw_Get_Color                 (int &Color, const CSG_Point &Point);
 
 
private:
 
        class CBands
        {
        public:
 
                bool                                    bOverlay, bBandStatistics;
 
                CSG_Grid_Resampling          Resampling;
 
                CSG_Grid                                *pBands[3];
 
                void                                    Set_Bands                               (CSG_Grid *pB0, CSG_Grid *pB1, CSG_Grid *pB2) { pBands[0] = pB0; pBands[1] = pB1; pBands[2] = pB2; }
 
                CSG_Grid *                              operator []                             (int i) { return( pBands[i] ); }
        };
 
        CBands                                          m_Bands;
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_PointCloud : public CSG_Map_Layer
{
public:
        CSG_Map_PointCloud(CSG_PointCloud *pPointCloud = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        int                                                     Get_Field_Value                  (void) { return( m_Stretch.Value  ); }
        int                                                     Get_Field_Normal                (void) { return( m_Stretch.Normal ); }
        double                                          Get_Scale_Normal                (void) { return( m_Stretch.Scale  ); }
 
        bool                                            asImage                                 (CSG_Grid *pImage);
 
 
protected:
 
        virtual void                            On_Draw                                 (CSG_Map_DC &dc_Map, int Flags);
 
 
private:
 
        int                                                     m_PointSize = 1, m_Aggregation = 0, m_Edit_Index = -1;
 
        wxColour                                        m_Color_Pen;
 
        CSG_Grid                                        m_Z, m_N, m_Symbol;
 
        class CStretch                          { public: int Value = -1, Normal = -1; double Scale = 1.; } m_Stretch;
 
 
        void                                            _Draw_Pixel                             (CSG_Map_DC &dc_Map, int x, int y, double z, int Color);
        void                                            _Draw_Symbol                    (CSG_Map_DC &dc_Map, const CSG_Point_3D &Point, int Color);
 
        void                                            _Draw_Points                    (CSG_Map_DC &dc_Map, bool bSkipSelection);
 
        void                                            _Draw_Thumbnail                 (CSG_Map_DC &dc_Map);
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Shapes : public CSG_Map_Layer
{
public:
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        int                                                     Get_Field_Value                  (void) const { return( m_Stretch.Value  ); }
        int                                                     Get_Field_Normal                (void) const { return( m_Stretch.Normal ); }
        double                                          Get_Scale_Normal                (void) const { return( m_Stretch.Scale  ); }
        int                                                     Get_Field_Label                  (void) const { return( m_Label.Field    ); }
 
        wxPen                                           Get_Def_Pen                          (void) const { return( m_Pen   ); }
        wxBrush                                         Get_Def_Brush                      (void) const { return( m_Brush ); }
 
        virtual void                            Draw_Thumbnails                 (CSG_Map_DC &dc_Map, int Limit);
 
        virtual void                            Draw_Shape                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags = 0        ) {};
        virtual void                            Draw_Label                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, const wxString &Label) {};
 
 
protected:
 
        bool                                            m_bNoData = true;
 
        int                                                     m_bVertices = 0, m_DrawOrder = 0;
 
        wxPen                                           m_Pen;
 
        wxBrush                                         m_Brush;
 
        class CStretch                          { public: int Value = -1, Normal = -1; double Scale = 1.; } m_Stretch;
 
        class CLabel                              { public: int Field = -1, Precision = -1, Effect = 0, Effect_Size = 1; wxColour Effect_Color; } m_Label;
 
 
        CSG_Map_Shapes(void);
 
        virtual void                            On_Draw                                  (CSG_Map_DC &dc_Map, int Flags);
 
        CSG_Shape *                                    Get_Shape                              (sLong i);
 
        bool                                            Get_Class_Color                  (CSG_Shape *pShape, int &Color);
 
        CSG_Parameter *                            BrushList_Add                      (CSG_Parameters &Parameters, const CSG_String &ParentID, const CSG_String &Identifier, const CSG_String &Name, const CSG_String &Description) const;
        wxBrushStyle                            BrushList_Get_Style          (const CSG_String &Identifier);
 
        CSG_Parameter *                            PenList_Add                          (CSG_Parameters &Parameters, const CSG_String &ParentID, const CSG_String &Identifier, const CSG_String &Name, const CSG_String &Description) const;
        int                                                     PenList_Get_Style              (const CSG_String &Identifier);
 
        virtual void                            Draw_Initialize                  (CSG_Map_DC &dc_Map, int Flags) {}
 
 
private:
 
        void                                            _Draw_Shape                             (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags     = 0);
        void                                            _Draw_Label                             (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int PointSize = 0);
 
 
        //-----------------------------------------------------
        // Charts...
 
        class CChart
        {
        public:
 
                bool                                    is_Valid                                (void)  {       return( m_Fields.Get_Count() > 0 );     }
 
                bool                                    Set_Options                             (const CSG_Shapes *pShapes,       CSG_Parameters &Parameters);
                bool                                    Get_Options                             (const CSG_Shapes *pShapes, const CSG_Parameters &Parameters);
 
                void                                    Draw                                    (CSG_Map_DC &dc_Map, CSG_Shape *pShape);
 
 
        private:
 
                int                                             m_Type = 0;
 
                CSG_Points_Int                  m_Fields;
 
                class CSize                             { public: int Size = 1, Field = -1, Type = 0; double Scale = 1., Range = 0.; } m_Size;
 
                void                                    _Draw_Pie                               (CSG_Map_DC &dc_Map, CSG_Table_Record *pRecord, bool bOutline, int x, int y, int size);
                void                                    _Draw_Bar                               (CSG_Map_DC &dc_Map, CSG_Table_Record *pRecord, bool bOutline, int x, int y, int sx, int sy);
 
        }                                                       m_Chart;
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Shapes_Point : public CSG_Map_Shapes
{
public:
        CSG_Map_Shapes_Point(CSG_Shapes *pShapes = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        virtual void                            Draw_Shape                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags = 0        );
        virtual void                            Draw_Label                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, const wxString &Label);
 
        bool                                            Get_Outline                          (void)  {       return( m_bOutline ); }
        bool                                            Get_Style_Size                  (int &minSize, int &maxSize, double &Minimum, double &Scale, wxString *pName);
 
        void                                            Draw_Symbol                             (wxDC &dc, int x, int y, int size);
 
 
protected:
 
        bool                                            m_bOutline;
 
        wxImage                                         m_Symbol_Image;
 
        class CSize                { public: int Unit, Field, Adjust; double Minimum, Offset, Scale;    } m_Size;
 
        class CLabel_Point         { public: int Align, Angle_Field; double Angle; CSG_Point Offset;    } m_Label_Point;
 
        class CSymbol              { public: int Type; wxImage Image;                                   } m_Symbol;
 
        class CImage               { public: int Field, Align, Fit; double Offset, Scale;               } m_Image;
 
        class CArrow               { public: int Field, Style, Width, Orientation, Unit; double Offset; } m_Arrow;
 
        class CBeachball           { public: int Strike, Dip, Rake;                                     } m_Beachball;
 
 
        virtual void                            Draw_Initialize                  (CSG_Map_DC &dc_Map                              , int Flags);
        virtual bool                            Draw_Initialize                  (CSG_Map_DC &dc_Map, int &Size, CSG_Shape *pShape, int Flags);
 
        void                                            Draw_Symbol                          (CSG_Map_DC &dc, int x, int y, int size);
 
 
private:
 
        void                                            _Image_Draw                             (CSG_Map_DC &dc, int x, int y, int size, const wxString &file);
 
        void                                            _Arrow_Draw                             (CSG_Map_DC &dc_Map, int x, int y, int size, double direction);
 
        void                                            _Beachball_Draw                 (CSG_Map_DC &dc, int x, int y, int size, double strike, double dip, double rake);
        void                                            _Beachball_Get_Plane    (CSG_Shape *pPlane, CSG_Shape *pCircle, const CSG_Vector &Normal);
        void                                            _Beachball_Get_Scaled   (CSG_Shape *pShape, double x, double y, double size);
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Shapes_Points : public CSG_Map_Shapes_Point
{
public:
        CSG_Map_Shapes_Points(CSG_Shapes *pShapes = NULL);
 
        virtual void                            Draw_Shape                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags = 0        );
        virtual void                            Draw_Label                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, const wxString &Label);
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Shapes_Line : public CSG_Map_Shapes
{
public:
        CSG_Map_Shapes_Line(CSG_Shapes *pShapes = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        virtual void                            Draw_Shape                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags = 0        );
        virtual void                            Draw_Label                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, const wxString &Label);
 
        bool                                            Get_Style_Size                    (int &min_Size, int &max_Size, double &min_Value, double &dValue, wxString *pName);
 
 
protected:
 
        bool                                            m_bPoints;
 
        int                                                     m_iSize, m_Size_Type, m_Line_Style, m_Effect;
 
        int                                                     m_Label_Style, m_Label_Freq, m_Label_Align, m_Label_Orient;
 
        double                                          m_Size, m_dSize, m_Size_Min;
 
        wxColour                                        m_Effect_Color;
 
 
        virtual void                            Draw_Initialize                  (CSG_Map_DC &dc_Map, int Flags);
 
 
private:
 
        void                                            _Draw_Shape                             (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int xOffset = 0, int yOffset = 0);
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Shapes_Polygon : public CSG_Map_Shapes
{
public:
        CSG_Map_Shapes_Polygon(CSG_Shapes *pShapes = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        virtual void                            Draw_Shape                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, int Flags = 0        );
        virtual void                            Draw_Label                            (CSG_Map_DC &dc_Map, CSG_Shape *pShape, const wxString &Label);
 
        virtual void                            Draw_Thumbnails                  (CSG_Map_DC &dc_Map, int Limit);
 
        bool                                            Get_Outline                          (void)  {       return( m_bOutline ); }
 
 
protected:
 
        bool                                            m_bCentroid, m_bOutline;
 
 
        virtual void                            Draw_Initialize                  (CSG_Map_DC &dc_Map, int Flags);
 
};
 

//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_TIN : public CSG_Map_Layer
{
public:
        CSG_Map_TIN(CSG_TIN *pTIN = NULL);
 
        virtual bool                            Add_Parameters                    (CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed              (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed            (void);
        virtual bool                            DataObject_Changed            (void);
 
 
public:
 
        int                                                     Get_Field_Value                  (void) { return( m_Stretch.Value  ); }
        int                                                     Get_Field_Normal                (void) { return( m_Stretch.Normal ); }
        double                                          Get_Scale_Normal                (void) { return( m_Stretch.Scale  ); }
 
        virtual bool                            asImage                                 (CSG_Grid *pImage);
 
 
protected:
 
        class CStretch                          { public: int Value = -1, Normal = -1; double Scale = 1.; } m_Stretch;
 
 
        virtual void                            On_Draw                                  (CSG_Map_DC &dc_Map, int Flags);
 
 
private:
 
        typedef struct                          { int x, y; double z; } TPoint;
 
 
        void                                            _Draw_Points                    (CSG_Map_DC &dc_Map);
        void                                            _Draw_Edges                             (CSG_Map_DC &dc_Map);
        void                                            _Draw_Triangles                 (CSG_Map_DC &dc_Map);
        void                                            _Draw_Triangle                  (CSG_Map_DC &dc_Map, TPoint p[3]);
        void                                            _Draw_Triangle_Line             (CSG_Map_DC &dc_Map, int xa, int xb, int y, double za, double zb);
 
};
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Graticule
{
public:
        CSG_Map_Graticule(void);
        virtual ~CSG_Map_Graticule(void);
 
        virtual CSG_Parameters &  Get_Parameters                    (void) { return( m_Parameters ); }
        virtual bool                            Set_Parameters                  (const CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed               (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed              (void);
 
        virtual bool                            Draw                                    (CSG_Map_DC &dc, const CSG_Projection &Projection);
 
 
private:
 
        CSG_Parameters                            m_Parameters;
 
        CSG_Shapes                                    m_Graticule, m_Coordinates;
 
        class CSG_Tool                          *m_pTool = NULL;
 
 
        bool                                            Get_Graticule                   (const CSG_Rect &Extent, const CSG_Projection &Projection);
 
        CSG_String                                    Get_Unit                                (CSG_Shape *pPoint, int Units, int Decimals, bool bLatitude);
 
};
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_BaseMap
{
public:
        CSG_Map_BaseMap(void);
        virtual ~CSG_Map_BaseMap(void);
 
        virtual CSG_Parameters &  Get_Parameters                    (void) { return( m_Parameters ); }
        virtual bool                            Set_Parameters                  (const CSG_Parameters &Parameters);
 
        virtual bool                            Parameter_Changed               (CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags);
 
        virtual bool                            Parameters_Changed              (void);
 
        virtual bool                            Draw                                    (CSG_Map_DC &dc, const CSG_Projection &Projection);
 
 
private:
 
        CSG_Parameters                            m_Parameters;
 
        CSG_Grid                                        m_BaseMap;
 
        class CSG_Tool                          *m_pTool = NULL;
 
 
        bool                                            Get_BaseMap                             (const CSG_Grid_System &System, const CSG_Projection &Projection);
 
};
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#endif // #ifndef _HEADER_INCLUDED__SAGA_GDI__Map_Layer_H