map_grid.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                     map_grid.cpp                      //
//                                                       //
//                 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                                //
//                                                       //
 
//---------------------------------------------------------
#include "../dc_helper.h"
 
#include "map_symbology.h"
#include "map_legend.h"
 
#include "map_layer.h"
 
#include "../data_manager.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_Grid::CSG_Map_Grid(CSG_Grid *pGrid)
        : CSG_Map_Layer(SG_DATAOBJECT_TYPE_Grid)
{
        Add_Parameters(m_Parameters);
 
        Set_Object(pGrid);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::Add_Parameters(CSG_Parameters &Parameters)
{
        CSG_Map_Layer::Add_Parameters(Parameters);
 
        //-----------------------------------------------------
        Parameters.Add_Bool  ("NODE_VALUES", "VALUES"    , _TL("Show Cell Values"), _TL("Show cell values when zoomed."), false);
        Parameters.Add_Font  ("VALUES", "VALUES_FONT"    , _TL("Font"            ), _TL(""));
        Parameters.Add_Double("VALUES", "VALUES_SIZE"    , _TL("Size"            ), _TL(""), 15, 0, true , 100., true);
        Parameters.Add_Int   ("VALUES", "VALUES_DECIMALS", _TL("Decimals"        ), _TL(""), 2);
        Parameters.Add_Choice("VALUES", "VALUES_EFFECT"  , _TL("Boundary Effect" ), _TL(""), CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s",
                _TL("none"        ),
                _TL("full frame"  ),
                _TL("top"         ),
                _TL("top left"    ),
                _TL("left"        ),
                _TL("bottom left" ),
                _TL("bottom"      ),
                _TL("bottom right"),
                _TL("right"       ),
                _TL("top right"   )), 1
        )->Set_Collapsed();
        Parameters.Add_Color("VALUES_EFFECT", "VALUES_EFFECT_COLOR", _TL("Color"), _TL(""), SG_GET_RGB(255, 255, 255));
 
        //-----------------------------------------------------
        // Display...
 
        Parameters.Add_Grid_Resampling("NODE_DISPLAY", "STRETCH_RESAMPLING", _TL("Resampling"), _TL(""), CSG_Grid_Resampling::Interpolations, CSG_Grid_Resampling::NearestNeighbour);
 
        //-----------------------------------------------------
        // Transparency...
 
        Parameters.Add_Grid("TRANSPARENCY", "TRANSPARENCY_GRID", _TL("Transparency Grid"),
                _TL("Grid values used to define transparency. Transparency will be linearly scaled from full transparency to full opacity value range. Can be combined with overall transparency."),
                PARAMETER_INPUT_OPTIONAL, false
        );
 
        Parameters.Add_Double("TRANSPARENCY_GRID", "TRANSPARENCY_GRID_STRETCH.MIN", _TL("Full Transparency"), _TL(""), 0.);
        Parameters.Add_Double("TRANSPARENCY_GRID", "TRANSPARENCY_GRID_STRETCH.MAX", _TL("Full Opacity"     ), _TL(""), 0.);
 
        //-----------------------------------------------------
        // Shading...
 
        Parameters.Add_Choice("NODE_DISPLAY"   , "SHADING"        , _TL("Shading"     ), _TL(""), CSG_String::Format("%s|%s|%s", _TL("none"), _TL("traditional"), _TL("multidirectional")), 0);
        Parameters.Add_Double("SHADING"        , "SHADING_AZIMUTH", _TL("Azimuth"     ), _TL("Direction of the light source, measured in degree clockwise from the North direction."), 315., 0., true, 360., true);
        Parameters.Add_Double("SHADING"        , "SHADING_HEIGHT" , _TL("Height"      ), _TL("Height of the light source, measured in degree above the horizon."                    ),  45., 0., true,  90., true);
        Parameters.Add_Double("SHADING"        , "SHADING_EXAGG"  , _TL("Exaggeration"), _TL(""), 1. );
        Parameters.Add_Double("SHADING"        , "SHADING_MIN"    , _TL("Minimum"     ), _TL(""), 0. );
        Parameters.Add_Double("SHADING"        , "SHADING_MAX"    , _TL("Maximum"     ), _TL(""), 1.5);
 
        //-----------------------------------------------------
        Parameters.Add_Bool  ("NODE_COLORS"    , "RGB_ALPHA"      , _TL("Alpha Channel"), _TL(""), false);
 
        //-----------------------------------------------------
        Parameters.Add_Node  ("NODE_COLORS"    , "NODE_COMPOSITE" , _TL("RGB Composite"), _TL(""));
        Parameters.Add_Choice("NODE_COMPOSITE" , "COMPOSITE_THIS" , _TL("This Color"   ), _TL(""), CSG_String::Format("%s|%s|%s", _TL("Red"), _TL("Green"), _TL("Blue")), 0);
        Parameters.Add_Grid  ("NODE_COMPOSITE" , "COMPOSITE_R"    , _TL("Red"          ), _TL(""), PARAMETER_INPUT_OPTIONAL, false);
        Parameters.Add_Grid  ("NODE_COMPOSITE" , "COMPOSITE_G"    , _TL("Green"        ), _TL(""), PARAMETER_INPUT_OPTIONAL, false);
        Parameters.Add_Grid  ("NODE_COMPOSITE" , "COMPOSITE_B"    , _TL("Blue"         ), _TL(""), PARAMETER_INPUT_OPTIONAL, false);
 
        //-----------------------------------------------------
        if( m_pObject )
        {
                Parameters["TRANSPARENCY_GRID"].Get_Parent()->Set_Value((void *)&m_pObject->asGrid()->Get_System());
 
                Parameters["COMPOSITE_R"      ].Get_Parent()->Set_Value((void *)&m_pObject->asGrid()->Get_System());
                Parameters["COMPOSITE_G"      ].Get_Parent()->Set_Value((void *)&m_pObject->asGrid()->Get_System());
                Parameters["COMPOSITE_B"      ].Get_Parent()->Set_Value((void *)&m_pObject->asGrid()->Get_System());
        }
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_VALUES )
        {
                if( Parameter.Cmp_Identifier("TRANSPARENCY_GRID") )
                {
                        if( Parameter.asGrid() )
                        {
                                Parameters.Set_Parameter("TRANSPARENCY_GRID_STRETCH.MIN", Parameter.asGrid()->Get_Min());
                                Parameters.Set_Parameter("TRANSPARENCY_GRID_STRETCH.MAX", Parameter.asGrid()->Get_Max());
                        }
                }
        }
 
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_ENABLE )
        {
                if(     Parameter.Cmp_Identifier("SHADING") )
                {
                        Parameters.Set_Enabled("SHADING_AZIMUTH"    , Parameter.asInt() != 0);
                        Parameters.Set_Enabled("SHADING_HEIGHT"     , Parameter.asInt() != 0);
                        Parameters.Set_Enabled("SHADING_EXAGG"      , Parameter.asInt() != 0);
                        Parameters.Set_Enabled("SHADING_MIN"        , Parameter.asInt() != 0);
                        Parameters.Set_Enabled("SHADING_MAX"        , Parameter.asInt() != 0);
                }
 
                if(     Parameter.Cmp_Identifier("COLOR_SYMBOLS") )
                {
                        int Value = Parameter.asInt();
 
                        Parameters.Set_Enabled("NODE_COMPOSITE"     , Value == CSG_Map_Symbology::COMPOSITE );
                        Parameters.Set_Enabled("STRETCH_RESAMPLING" , Value != CSG_Map_Symbology::CLASSIFIED);
                        Parameters.Set_Enabled("TRANSPARENCY_GRID"  , Value != CSG_Map_Symbology::RGB       );
                        Parameters.Set_Enabled("RGB_ALPHA"          , Value == CSG_Map_Symbology::RGB       );
                }
 
                if( Parameter.Cmp_Identifier("TRANSPARENCY_MODE") )
                {
                        Parameters.Set_Enabled("TRANSPARENCY", Parameter.asInt() == 0);
                }
 
                if( Parameter.Cmp_Identifier("TRANSPARENCY_GRID") )
                {
                        Parameter.Set_Children_Enabled(Parameter.asGrid() != NULL);
                }
 
                if(     Parameter.Cmp_Identifier("VALUES") )
                {
                        Parameters.Set_Enabled("VALUES_FONT"        , Parameter.asBool());
                        Parameters.Set_Enabled("VALUES_SIZE"        , Parameter.asBool());
                        Parameters.Set_Enabled("VALUES_DECIMALS"    , Parameter.asBool());
                        Parameters.Set_Enabled("VALUES_EFFECT"      , Parameter.asBool());
                }
 
                if(     Parameter.Cmp_Identifier("VALUES_EFFECT") )
                {
                        Parameters.Set_Enabled("VALUES_EFFECT_COLOR", Parameter.asInt() > 0);
                }
 
                if( Parameter.Cmp_Identifier("COMPOSITE_THIS") )
                {
                        Parameters["COMPOSITE_R"].Get_Parent()->Set_Enabled(Parameter.asInt() != 0);
                        Parameters["COMPOSITE_G"].Get_Parent()->Set_Enabled(Parameter.asInt() != 1);
                        Parameters["COMPOSITE_B"].Get_Parent()->Set_Enabled(Parameter.asInt() != 2);
                }
        }
 
        return( CSG_Map_Layer::Parameter_Changed(Parameters, Parameter, Flags) );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::DataObject_Changed(void)
{
        CSG_Map_Layer::DataObject_Changed();
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::Parameters_Changed(void)
{
        CSG_Map_Layer::Parameters_Changed();
 
        //-----------------------------------------------------
        _Composite_Update();
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::Set_Stretch_Extent(const CSG_Rect &Extent)
{
        if( m_Parameters["COLOR_SYMBOLS"].asInt() == CSG_Map_Symbology::DISCRETE
        ||  m_Parameters["COLOR_SYMBOLS"].asInt() == CSG_Map_Symbology::GRADUATED
        ||  m_Parameters["COLOR_SYMBOLS"].asInt() == CSG_Map_Symbology::COMPOSITE )
        {
                if( m_Parameters["STRETCH"].asInt() < 3 ) // not 'manual'
                {
                        m_Stretch_Extent = m_Parameters["STRETCH"].asInt();
                }
 
                //-------------------------------------------------
                double Minimum, Maximum; _Get_Stretch_Extent(Extent, (CSG_Grid *)m_pObject, Minimum, Maximum);
 
                if( m_Parameters["COLOR_SYMBOLS"].asInt() == CSG_Map_Symbology::DISCRETE
                ||  m_Parameters["COLOR_SYMBOLS"].asInt() == CSG_Map_Symbology::GRADUATED )
                {
                        return( Set_Stretch_Range(Minimum, Maximum) );
                }
 
                //-------------------------------------------------
                m_Parameters.Set_Parameter("STRETCH_RANGE.MIN", Minimum < Maximum ? Minimum : Maximum);
                m_Parameters.Set_Parameter("STRETCH_RANGE.MAX", Minimum < Maximum ? Maximum : Minimum);
 
                const CSG_String Band[3] = { "R", "G", "B" };
 
                for(int i=0; i<3; i++)
                {
                        if( m_Parameters["COMPOSITE_" + Band[i]].is_Enabled() && _Get_Stretch_Extent(Extent, m_Parameters["COMPOSITE_" + Band[i]].asGrid(), Minimum, Maximum) )
                        {
                                m_Composite[i].Scaler.Set_Range(Minimum, Maximum);
                        }
                }
 
                m_Parameters["STRETCH"].Set_Value(3); // 'manual'
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Grid::_Get_Stretch_Extent(const CSG_Rect &Extent, CSG_Grid *pGrid, double &Minimum, double &Maximum) const
{
        if( pGrid )
        {
                switch( m_Stretch_Extent )
                {
                default:
                        {
                                CSG_Simple_Statistics s;
 
                                if( pGrid->Get_Statistics(Extent, s) )
                                {
                                        Minimum = s.Get_Minimum() + s.Get_Range() * m_Parameters("STRETCH_LINEAR.MIN")->asDouble() / 100.;
                                        Maximum = s.Get_Minimum() + s.Get_Range() * m_Parameters("STRETCH_LINEAR.MAX")->asDouble() / 100.;
 
                                        return( true );
                                }
                        }
                        break;
 
                case  1:
                        {
                                CSG_Simple_Statistics s;
 
                                if( pGrid->Get_Statistics(Extent, s) )
                                {
                                        double d = m_Parameters("STRETCH_STDDEV")->asDouble() * s.Get_StdDev();
 
                                        Minimum = s.Get_Mean() - d; if( m_Parameters("STRETCH_STDDEV_RANGE")->asBool() && Minimum < s.Get_Minimum() ) { Minimum = s.Get_Minimum(); }
                                        Maximum = s.Get_Mean() + d; if( m_Parameters("STRETCH_STDDEV_RANGE")->asBool() && Maximum > s.Get_Maximum() ) { Maximum = s.Get_Maximum(); }
 
                                        return( true );
                                }
                        }
                        break;
 
                case  2:
                        {
                                CSG_Histogram h;
 
                                if( pGrid->Get_Histogram (Extent, h) )
                                {
                                        Minimum = h.Get_Quantile(m_Parameters("STRETCH_PERCENT.MIN")->asDouble() / 100.);
                                        Maximum = h.Get_Quantile(m_Parameters("STRETCH_PERCENT.MAX")->asDouble() / 100.);
 
                                        return( true );
                                }
                        }
                        break;
                }
        }
 
        Minimum = Maximum = 0.;
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::Update(CSG_Data_Object *pChanged)
{
        if( pChanged )
        {
                if( pChanged == m_pObject )
                {
                        return( true );
                }
 
                if( pChanged->Get_ObjectType() == SG_DATAOBJECT_TYPE_Grid )
                {
                        return( (m_Parameters["COMPOSITE_R"].is_Enabled() && pChanged->asGrid() == m_Parameters["COMPOSITE_R"].asGrid())
                             || (m_Parameters["COMPOSITE_G"].is_Enabled() && pChanged->asGrid() == m_Parameters["COMPOSITE_G"].asGrid())
                             || (m_Parameters["COMPOSITE_B"].is_Enabled() && pChanged->asGrid() == m_Parameters["COMPOSITE_B"].asGrid())
                        );
                }
 
                if( pChanged->Get_ObjectType() == SG_DATAOBJECT_TYPE_Grids )
                {
                        return( (m_Parameters["COMPOSITE_R"].is_Enabled() && m_Parameters["COMPOSITE_R"].asGrid() && pChanged->asGrids() == m_Parameters["COMPOSITE_R"].asGrid()->Get_Owner())
                             || (m_Parameters["COMPOSITE_G"].is_Enabled() && m_Parameters["COMPOSITE_G"].asGrid() && pChanged->asGrids() == m_Parameters["COMPOSITE_G"].asGrid()->Get_Owner())
                             || (m_Parameters["COMPOSITE_B"].is_Enabled() && m_Parameters["COMPOSITE_B"].asGrid() && pChanged->asGrids() == m_Parameters["COMPOSITE_B"].asGrid()->Get_Owner())
                        );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
CSG_Grid * CSG_Map_Grid::Get_Composite_Band(int Band)
{
        switch( Band )
        {
        case 0: return( Band == m_Parameters["COMPOSITE_THIS"].asInt() ? m_pObject->asGrid() : m_Parameters["COMPOSITE_R"].asGrid() );
        case 1: return( Band == m_Parameters["COMPOSITE_THIS"].asInt() ? m_pObject->asGrid() : m_Parameters["COMPOSITE_G"].asGrid() );
        case 2: return( Band == m_Parameters["COMPOSITE_THIS"].asInt() ? m_pObject->asGrid() : m_Parameters["COMPOSITE_B"].asGrid() );
        }
 
        return( NULL );
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Composite_Update(void)
{
        const CSG_String Band[3] = { "R", "G", "B" }; // update color composite bands (rgb)
 
        for(int i=0; i<3; i++) // update bands
        {
                CSG_Grid *pGrid = m_Parameters["COMPOSITE_" + Band[i]].asGrid();
 
                if( !SG_Get_Data_Manager().Exists(pGrid) )
                {
                        m_Composite[i].pGrid = NULL;
                }
                else if( m_Composite[i].pGrid != pGrid )
                {
                        m_Composite[i].pGrid = pGrid;
 
                        switch( m_Parameters("STRETCH")->asInt() ) // initialize stretch range
                        {
                        case  0: m_Composite[i].Scaler.Set_Linear    (pGrid, 0., m_Parameters["STRETCH_LINEAR.MIN"].asDouble(), m_Parameters["STRETCH_LINEAR.MAX"].asDouble()); break;
                        case  1: m_Composite[i].Scaler.Set_StdDev    (pGrid, 0., m_Parameters["STRETCH_STDDEV"    ].asDouble(), m_Parameters["STRETCH_STDDEV_RANGE"   ].asBool  ()); break;
                        default: m_Composite[i].Scaler.Set_Percentile(pGrid, 0., m_Parameters["STRETCH_PERCENT.MIN"  ].asDouble(), m_Parameters["STRETCH_PERCENT.MAX"  ].asDouble()); break;
                        }
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Composite_Get(CComposite Composite[3])
{
        if( m_pObject )
        {
                switch( m_Parameters("COMPOSITE_THIS")->asInt() )
                {
                default: Composite[0].pGrid = m_pObject->asGrid(); Composite[1] = m_Composite[1]; Composite[2] = m_Composite[2]; break; // this = red
                case  1: Composite[1].pGrid = m_pObject->asGrid(); Composite[0] = m_Composite[0]; Composite[2] = m_Composite[2]; break; // this = green
                case  2: Composite[2].pGrid = m_pObject->asGrid(); Composite[0] = m_Composite[0]; Composite[1] = m_Composite[1]; break; // this = blue
                }
 
                int    Mode     = m_pSymbology->Get_Stretch_Mode    ();
                double LogScale = m_pSymbology->Get_Stretch_LogScale();
 
                for(int i=0; i<3; i++)
                {
                        Composite[i].pReference = m_pObject->asGrid();
 
                        if( Composite[i].pGrid )
                        {
                                switch( m_Parameters("STRETCH")->asInt() )
                                {
                                case  0: Composite[i].Scaler.Set_Linear    (Composite[i].pGrid, m_Parameters["STRETCH_LINEAR.MIN"].asDouble(), m_Parameters["STRETCH_LINEAR.MAX"].asDouble(), Mode, LogScale); break;
                                case  1: Composite[i].Scaler.Set_StdDev    (Composite[i].pGrid, m_Parameters["STRETCH_STDDEV"    ].asDouble(), m_Parameters["STRETCH_STDDEV_RANGE"   ].asBool  (), Mode, LogScale); break;
                                case  2: Composite[i].Scaler.Set_Percentile(Composite[i].pGrid, m_Parameters["STRETCH_PERCENT.MIN"  ].asDouble(), m_Parameters["STRETCH_PERCENT.MAX"  ].asDouble(), Mode, LogScale); break;
                                default:
                                        if( Composite[i].pGrid == m_pObject->asGrid() )
                                        {
                                                Composite[i].Scaler.Create(
                                                        m_Parameters["STRETCH_RANGE.MIN"].asDouble(),
                                                        m_Parameters["STRETCH_RANGE.MAX"].asDouble(), Mode, LogScale
                                                );
                                        }
                                        break;
                                }
                        }
                }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_Grid::On_Draw(CSG_Map_DC &dc_Map, int Flags)
{
        if( m_pObject == NULL || Get_Extent().Intersects(dc_Map.rWorld()) == INTERSECTION_None )
        {
                return;
        }
 
        //-----------------------------------------------------
        m_Alpha.Create(m_Parameters("TRANSPARENCY_GRID")->asGrid(),
                m_Parameters("TRANSPARENCY_GRID_STRETCH.MIN")->asDouble(),
                m_Parameters("TRANSPARENCY_GRID_STRETCH.MAX")->asDouble()
        );
 
        CSG_Map_DC::Mode Mode = m_Parameters("TRANSPARENCY_MODE")->asInt() == 1 ? CSG_Map_DC::Mode::Shade : (
                (m_pSymbology->Get_Mode() != CSG_Map_Symbology::RGB && m_Alpha.is_Okay()) ||
                (m_pSymbology->Get_Mode() == CSG_Map_Symbology::RGB && m_Parameters("RGB_ALPHA")->asBool())
                ? CSG_Map_DC::Mode::Alpha : CSG_Map_DC::Mode::Transparent
        );
 
        if( !dc_Map.Draw_Image_Begin(m_Parameters("TRANSPARENCY")->asDouble() / 100., Mode) )
        {
                return;
        }
 
        //-----------------------------------------------------
        CSG_Grid_Resampling Resampling = m_Parameters(m_pSymbology->Get_Mode() == CSG_Map_Symbology::CLASSIFIED ? "CLASSIFIED_RESAMPLING" : "STRETCH_RESAMPLING")->asGrid_Resampling();
 
        //-----------------------------------------------------
        m_Shading.Create(m_Parameters("SHADING")->asInt(), m_pObject->asGrid(),
                m_Parameters("SHADING_HEIGHT" )->asDouble(),
                m_Parameters("SHADING_AZIMUTH")->asDouble(),
                m_Parameters("SHADING_EXAGG"  )->asDouble(),
                m_Parameters("SHADING_MIN"    )->asDouble(),
                m_Parameters("SHADING_MAX"    )->asDouble()
        );
 
        //-----------------------------------------------------
        CComposite Composite[3];
 
        if( m_Parameters("COLOR_SYMBOLS")->asInt() == CSG_Map_Symbology::COMPOSITE )
        {
                _Composite_Get(Composite);
        }
 
        //-----------------------------------------------------
        if(     dc_Map.DC2World() >= m_pObject->asGrid()->Get_Cellsize() || Resampling != CSG_Grid_Resampling::NearestNeighbour )
        {
                _Draw_Points(dc_Map, Composite, Resampling);
        }
        else
        {
                _Draw_Cells (dc_Map, Composite);
        }
 
        //-----------------------------------------------------
        dc_Map.Draw_Image_End();
 
        if( (Flags & LAYER_DRAW_FLAG_NOLABELS) == 0 )
        {
                _Draw_Values(dc_Map);
        }
 
        if( (Flags & LAYER_DRAW_FLAG_NOEDITS) == 0 )
        {
        //      _Draw_Edit(dc_Map);
        }
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Draw_Cells(CSG_Map_DC &dc_Map, CComposite Composite[3])
{
        CSG_Grid *pGrid = m_pObject->asGrid();
 
        int xa = pGrid->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMin()); if( xa <  0               ) { xa =                   0; }
        int ya = pGrid->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMin()); if( ya <  0               ) { ya =                   0; }
        int xb = pGrid->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMax()); if( xb >= pGrid->Get_NX() ) { xb = pGrid->Get_NX() - 1; }
        int yb = pGrid->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMax()); if( yb >= pGrid->Get_NY() ) { yb = pGrid->Get_NY() - 1; }
 
        double  dDC = pGrid->Get_Cellsize() * dc_Map.World2DC();
 
        double axDC = dc_Map.xWorld2DC(pGrid->Get_System().Get_xGrid_to_World(xa)) + dDC / 2.;
        double ayDC = dc_Map.yWorld2DC(pGrid->Get_System().Get_yGrid_to_World(ya)) - dDC / 2.;
 
        //-----------------------------------------------------
        double  yDC = ayDC;
 
        for(int y=ya, yaDC=(int)(ayDC), ybDC=(int)(ayDC+dDC); y<=yb; y++, ybDC=yaDC, yaDC=(int)(yDC-=dDC))
        {
                double xDC = axDC;
 
                for(int x=xa, xaDC=(int)(axDC-dDC), xbDC=(int)(axDC); x<=xb; x++, xaDC=xbDC, xbDC=(int)(xDC+=dDC))
                {
                        int Color;
 
                        if( m_pSymbology->Get_Mode() != CSG_Map_Symbology::COMPOSITE )
                        {
                                if( pGrid->is_InGrid(x, y) && m_pSymbology->Get_Class_Color_byValue(pGrid->asDouble(x, y), Color) )
                                {
                                        dc_Map.Draw_Image_Pixels(xaDC, yaDC, xbDC, ybDC, _Adjust_Color(x, y, Color));
                                }
                        }
                        else
                        {
                                if( Composite[0].Set_Color(((BYTE *)&Color)[0], x, y)
                                &&  Composite[1].Set_Color(((BYTE *)&Color)[1], x, y)
                                &&  Composite[2].Set_Color(((BYTE *)&Color)[2], x, y) )
                                {
                                        dc_Map.Draw_Image_Pixels(xaDC, yaDC, xbDC, ybDC, _Adjust_Color(x, y, Color));
                                }
                        }
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Draw_Points(CSG_Map_DC &dc_Map, CComposite Composite[3], CSG_Grid_Resampling Resampling)
{
        CSG_Grid *pGrid = m_pObject->asGrid();
 
        CSG_Rect rMap(dc_Map.rWorld());   rMap.Intersect(pGrid->Get_Extent(true));
 
        int axDC = (int)dc_Map.xWorld2DC(rMap.Get_XMin()); if( axDC <  0                        ) { axDC = 0;                            }
        int bxDC = (int)dc_Map.xWorld2DC(rMap.Get_XMax()); if( bxDC >= dc_Map.rDC().GetWidth () ) { bxDC = dc_Map.rDC().GetWidth () - 1; }
        int ayDC = (int)dc_Map.yWorld2DC(rMap.Get_YMin()); if( ayDC >= dc_Map.rDC().GetHeight() ) { ayDC = dc_Map.rDC().GetHeight() - 1; }
        int byDC = (int)dc_Map.yWorld2DC(rMap.Get_YMax()); if( byDC <  0                        ) { byDC = 0;                            }
        int nyDC = abs(ayDC - byDC);
 
        if( pGrid->is_Cached() )
        {
                for(int iyDC=0; iyDC<=nyDC; iyDC++)
                {
                        _Draw_Points(dc_Map, Composite, Resampling, ayDC - iyDC, axDC, bxDC);
                }
        }
        else
        {
                #pragma omp parallel for
                for(int iyDC=0; iyDC<=nyDC; iyDC++)
                {
                        _Draw_Points(dc_Map, Composite, Resampling, ayDC - iyDC, axDC, bxDC);
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Draw_Points(CSG_Map_DC &dc_Map, CComposite Composite[3], CSG_Grid_Resampling Resampling, int yDC, int axDC, int bxDC)
{
        CSG_Point p(dc_Map.xDC2World(axDC), dc_Map.yDC2World( yDC)); CSG_Grid *pGrid = m_pObject->asGrid();
 
        for(int xDC=axDC; xDC<=bxDC; p.x+=dc_Map.DC2World(), xDC++)
        {
                double Value;
 
                if( pGrid->Get_Value(p, Value, Resampling, false, m_pSymbology->Get_Mode() == CSG_Map_Symbology::RGB) )
                {
                        int Color;
 
                        if( m_pSymbology->Get_Mode() != CSG_Map_Symbology::COMPOSITE )
                        {
                                if( m_pSymbology->Get_Class_Color_byValue(Value, Color) )
                                {
                                        dc_Map.Draw_Image_Pixel(xDC, yDC, _Adjust_Color(p, Color, Resampling));
                                }
                        }
                        else
                        {
                                if( Composite[0].Set_Color(((BYTE *)&Color)[0], p, Resampling)
                                &&  Composite[1].Set_Color(((BYTE *)&Color)[1], p, Resampling)
                                &&  Composite[2].Set_Color(((BYTE *)&Color)[2], p, Resampling) )
                                {
                                        dc_Map.Draw_Image_Pixel(xDC, yDC, _Adjust_Color(p, Color, Resampling));
                                }
                        }
                }
        }
}
 
//---------------------------------------------------------
inline int CSG_Map_Grid::_Adjust_Color(int x, int y, int Color)
{
        if( m_Shading.is_Okay() )
        {
                m_Shading.Set_Shading(Color, x, y);
        }
 
        if( m_Alpha.is_Okay() )
        {
                ((BYTE *)&Color)[3] = m_Alpha.Get_Alpha(m_pObject->asGrid()->Get_System(), x, y);
        }
 
        return( Color );
}
 
//---------------------------------------------------------
inline int CSG_Map_Grid::_Adjust_Color(const CSG_Point &Point, int Color, CSG_Grid_Resampling Resampling)
{
        if( m_Shading.is_Okay() )
        {
                m_Shading.Set_Shading(Color, Point, Resampling);
        }
 
        if( m_Alpha.is_Okay() )
        {
                m_Alpha.Set_Alpha(Color, Point);
        }
 
        return( Color );
}
 
//---------------------------------------------------------
void CSG_Map_Grid::_Draw_Values(CSG_Map_DC &dc_Map)
{
        CSG_Grid *pGrid = m_pObject->asGrid();
 
        if(     !m_Parameters("VALUES")->asBool() || pGrid->Get_Cellsize() * dc_Map.World2DC() <= 40 )
        {
                return;
        }
 
        //-----------------------------------------------------
        double   dDC = pGrid->Get_Cellsize() * dc_Map.World2DC();
        int Decimals = m_Parameters("VALUES_DECIMALS")->asInt();
        wxFont  Font = SG_Get_wxFont(m_Parameters("VALUES_FONT")); Font.SetPointSize((int)(dDC * m_Parameters("VALUES_SIZE")->asDouble() / 100.));
        dc_Map.SetFont(Font);
        dc_Map.Get_DC().SetTextForeground(SG_Get_wxColor(m_Parameters("VALUES_FONT")->asColor()));
 
        int Effect;
 
        switch( m_Parameters("VALUES_EFFECT")->asInt() )
        {
        default: Effect = SG_DC_TEXTEFFECT_NONE       ; break;
        case  1: Effect = SG_DC_TEXTEFFECT_FRAME      ; break;
        case  2: Effect = SG_DC_TEXTEFFECT_TOP        ; break;
        case  3: Effect = SG_DC_TEXTEFFECT_TOPLEFT    ; break;
        case  4: Effect = SG_DC_TEXTEFFECT_LEFT       ; break;
        case  5: Effect = SG_DC_TEXTEFFECT_BOTTOMLEFT ; break;
        case  6: Effect = SG_DC_TEXTEFFECT_BOTTOM     ; break;
        case  7: Effect = SG_DC_TEXTEFFECT_BOTTOMRIGHT; break;
        case  8: Effect = SG_DC_TEXTEFFECT_RIGHT      ; break;
        case  9: Effect = SG_DC_TEXTEFFECT_TOPRIGHT   ; break;
        }
 
        wxColour Effect_Color = m_Parameters("VALUES_EFFECT_COLOR")->asColor();
 
        //-------------------------------------------------
        int ax = pGrid->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMin());
        int ay = pGrid->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMin());
        int bx = pGrid->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMax());
        int by = pGrid->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMax());
 
        if( ax < 0 ) { ax = 0; } if( bx >= pGrid->Get_NX() ) { bx = pGrid->Get_NX() - 1; }
        if( ay < 0 ) { ax = 0; } if( by >= pGrid->Get_NY() ) { by = pGrid->Get_NY() - 1; }
 
        double axDC = dc_Map.xWorld2DC(pGrid->Get_System().Get_xGrid_to_World(ax));
        double ayDC = dc_Map.yWorld2DC(pGrid->Get_System().Get_yGrid_to_World(ay));
 
        int ny = by - ay;
 
        //-------------------------------------------------
        for(int y=0; y<=ny; y++)
        {
                double xDC = axDC, yDC = ayDC - y * dDC; // dc_Map.World2DC();
 
                for(int x=ax; x<=bx; x++, xDC+=dDC)
                {
                        if( pGrid->is_InGrid(x, ay + y) )
                        {
                                double Value = pGrid->asDouble(x, ay + y);
 
                                switch( m_pSymbology->Get_Mode() )
                                {
                                case CSG_Map_Symbology::RGB:
                                        dc_Map.DrawText(SG_DC_TEXTALIGN_CENTER, (int)xDC, (int)yDC, wxString::Format(
                                                "R%03d G%03d B%03d", SG_GET_R((int)Value), SG_GET_G((int)Value), SG_GET_B((int)Value)
                                        ), Effect, Effect_Color);
                                        break;
 
                                default:
                                        dc_Map.DrawText(SG_DC_TEXTALIGN_CENTER, (int)xDC, (int)yDC, wxString::Format(
                                                "%.*f", Decimals, Value
                                        ), Effect, Effect_Color);
                                        break;
                                }
                        }
                }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grid::asImage(CSG_Grid *pImage)
{
        wxImage Image;
 
        if( m_pObject && pImage && Get_Image(Image) )
        {
                pImage->Create(m_pObject->asGrid(), SG_DATATYPE_Int);
 
                #pragma omp parallel for
                for(int y=0; y<pImage->Get_NY(); y++) for(int x=0; x<pImage->Get_NX(); x++)
                {
                        if( Image.HasAlpha() && !Image.GetAlpha(x, y) )
                        {
                                pImage->Set_NoData(x, y);
                        }
                        else
                        {
                                pImage->Set_Value(x, y, SG_GET_RGB(Image.GetRed(x, y), Image.GetGreen(x, y), Image.GetBlue(x, y)));
                        }
                }
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Grid::Get_Image(wxImage &Image, bool bFitSize, int Width, int Height)
{
        if( m_pObject )
        {
                if( bFitSize || Width  < 1 ) { Width  = m_pObject->asGrid()->Get_NX(); }
                if( bFitSize || Height < 1 ) { Height = m_pObject->asGrid()->Get_NY(); }
 
                if( Width > 0 && Height > 0 && Image.Create(Width, Height) )
                {
                        SG_UI_Process_Set_Busy(true);
 
                        CSG_Map_DC dc_Map(Get_Extent(), wxRect(0, 0, Width, Height), 1., -1, true);
 
                        On_Draw(dc_Map, false);
 
                        dc_Map.Get_Image(Image);
 
                        SG_UI_Process_Set_Busy(false);
 
                        return( true );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Grid::Get_Bitmap(wxBitmap &Bitmap, bool bFitSize, int Width, int Height)
{
        if( m_pObject )
        {
                if( bFitSize || Width  < 1 ) { Width  = bFitSize ? m_pObject->asGrid()->Get_NX() : Bitmap.GetWidth (); }
                if( bFitSize || Height < 1 ) { Height = bFitSize ? m_pObject->asGrid()->Get_NY() : Bitmap.GetHeight(); }
 
                if( Width > 0 && Height > 0 && Bitmap.Create(Width, Height) )
                {
                        SG_UI_Process_Set_Busy(true);
 
                        CSG_Map_DC dc_Map(Get_Extent(), Bitmap.GetSize(), 1., -1, true);
 
                        On_Draw(dc_Map, false);
 
                        dc_Map.Get_Bitmap(Bitmap);
 
                        SG_UI_Process_Set_Busy(false);
 
                        return( true );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Grid::Get_Bitmap_Legend(wxBitmap &Bitmap, double Zoom)
{
        if( Zoom > 0. )
        {
                wxMemoryDC dc; wxSize s(Get_Legend()->Get_Size(Zoom, 1.));
 
                Bitmap.Create(s.GetWidth(), s.GetHeight());
 
                dc.SelectObject(Bitmap);
                dc.SetBackground(*wxWHITE_BRUSH);
                dc.Clear();
 
                Get_Legend()->Draw(dc, Zoom, 1., wxPoint(0, 0));
 
                dc.SelectObject(wxNullBitmap);
 
                return( true );
        }
 
        return( false );
}
 

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