map_grids.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                     map_grids.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"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_Grids::CSG_Map_Grids(CSG_Grids *pGrids)
        : CSG_Map_Layer(SG_DATAOBJECT_TYPE_Grids)
{
        Add_Parameters(m_Parameters);
 
        Set_Object(pGrids);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::Add_Parameters(CSG_Parameters &Parameters)
{
        CSG_Map_Layer::Add_Parameters(Parameters);
 
        //-----------------------------------------------------
        // 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 Band"),
                _TL("Band 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.);
 
        //-----------------------------------------------------
        // Classification...
 
        Parameters.Add_Grid("COMPOSITE_R", "COMPOSITE_R_GRID", _TL("External Grid"), _TL(""), PARAMETER_INPUT);
        Parameters.Add_Grid("COMPOSITE_G", "COMPOSITE_G_GRID", _TL("External Grid"), _TL(""), PARAMETER_INPUT);
        Parameters.Add_Grid("COMPOSITE_B", "COMPOSITE_B_GRID", _TL("External Grid"), _TL(""), PARAMETER_INPUT);
 
        Set_Grid_Choices(Parameters);
 
        //-----------------------------------------------------
        if( m_pObject )
        {
                Parameters["TRANSPARENCY_GRID"].Get_Parent()->Set_Value((void *)&m_pObject->asGrids()->Get_System());
        }
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        int Classify = Parameters["COLOR_SYMBOLS"].asInt();
 
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_VALUES )
        {
                if( Classify == CSG_Map_Symbology::COMPOSITE && Parameters["COMPOSITE_FIT"].asInt() == 1
                && (Parameter.Cmp_Identifier("STRETCH")
                ||  Parameter.Cmp_Identifier("STRETCH_LINEAR")
                ||  Parameter.Cmp_Identifier("STRETCH_STDDEV")
                ||  Parameter.Cmp_Identifier("STRETCH_STDDEV_RANGE")
                ||  Parameter.Cmp_Identifier("STRETCH_PERCENT")
                ||  Parameter.Cmp_Identifier("COMPOSITE_FIT")
                ||  Parameter.Cmp_Identifier("COMPOSITE_R") || Parameter.Cmp_Identifier("COMPOSITE_R_GRID")
                ||  Parameter.Cmp_Identifier("COMPOSITE_G") || Parameter.Cmp_Identifier("COMPOSITE_G_GRID")
                ||  Parameter.Cmp_Identifier("COMPOSITE_B") || Parameter.Cmp_Identifier("COMPOSITE_B_GRID")) )
                {
                        CSG_Grid *pGrid = NULL;
 
                        if( (pGrid = _Get_Grid(0, Parameters)) != NULL ) { Set_Stretch(Parameters, pGrid, "_R"); }
                        if( (pGrid = _Get_Grid(1, Parameters)) != NULL ) { Set_Stretch(Parameters, pGrid, "_G"); }
                        if( (pGrid = _Get_Grid(2, Parameters)) != NULL ) { Set_Stretch(Parameters, pGrid, "_B"); }
                }
 
                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("COLOR_SYMBOLS")
                ||  Parameter.Cmp_Identifier("COMPOSITE_FIT")
                ||  Parameter.Cmp_Identifier("TRANSPARENCY") )
                {
                        Parameters.Set_Enabled("STRETCH_RESAMPLING", Classify != CSG_Map_Symbology::CLASSIFIED && Classify != CSG_Map_Symbology::SINGLE);
 
                        Parameters.Set_Enabled("BAND"              , Classify == CSG_Map_Symbology::DISCRETE || Classify == CSG_Map_Symbology::GRADUATED || Classify == CSG_Map_Symbology::CLASSIFIED);
 
                        Parameters.Set_Enabled("STRETCH_RANGE"     , Classify == CSG_Map_Symbology::DISCRETE || Classify == CSG_Map_Symbology::GRADUATED || (Classify == CSG_Map_Symbology::COMPOSITE && Parameters["COMPOSITE_FIT"].asInt() == 0));
                        Parameters.Set_Enabled("STRETCH_INTERVALS" , Classify == CSG_Map_Symbology::DISCRETE || Classify == CSG_Map_Symbology::GRADUATED ||  Classify == CSG_Map_Symbology::COMPOSITE);
 
                        Parameters.Set_Enabled("COMPOSITE_R"       , Classify == CSG_Map_Symbology::COMPOSITE);
                        Parameters.Set_Enabled("COMPOSITE_G"       , Classify == CSG_Map_Symbology::COMPOSITE);
                        Parameters.Set_Enabled("COMPOSITE_B"       , Classify == CSG_Map_Symbology::COMPOSITE);
                        Parameters.Set_Enabled("COMPOSITE_FIT"     , Classify == CSG_Map_Symbology::COMPOSITE);
                        Parameters.Set_Enabled("STRETCH_RANGE_R"   , Classify == CSG_Map_Symbology::COMPOSITE && Parameters["COMPOSITE_FIT"].asInt() == 1);
                        Parameters.Set_Enabled("STRETCH_RANGE_G"   , Classify == CSG_Map_Symbology::COMPOSITE && Parameters["COMPOSITE_FIT"].asInt() == 1);
                        Parameters.Set_Enabled("STRETCH_RANGE_B"   , Classify == CSG_Map_Symbology::COMPOSITE && Parameters["COMPOSITE_FIT"].asInt() == 1);
                }
 
                if( m_pObject && Parameter.Cmp_Identifier("COMPOSITE_R") ) { Parameter.Set_Children_Enabled(Parameter.asInt() >= m_pObject->asGrids()->Get_NZ()); }
                if( m_pObject && Parameter.Cmp_Identifier("COMPOSITE_G") ) { Parameter.Set_Children_Enabled(Parameter.asInt() >= m_pObject->asGrids()->Get_NZ()); }
                if( m_pObject && Parameter.Cmp_Identifier("COMPOSITE_B") ) { Parameter.Set_Children_Enabled(Parameter.asInt() >= m_pObject->asGrids()->Get_NZ()); }
 
                if( Parameter.Cmp_Identifier("TRANSPARENCY_GRID") )
                {
                        Parameter.Set_Children_Enabled(Parameter.asGrid() != NULL);
                }
        }
 
        //-----------------------------------------------------
        return( CSG_Map_Layer::Parameter_Changed(Parameters, Parameter, Flags) );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::DataObject_Changed(void)
{
        CSG_Map_Layer::DataObject_Changed();
 
        //-----------------------------------------------------
        Set_Grid_Choices(m_Parameters);
 
        if( m_Parameters["COMPOSITE_R"].asInt() == 0
        &&  m_Parameters["COMPOSITE_G"].asInt() == 0
        &&  m_Parameters["COMPOSITE_B"].asInt() == 0 )
        {
                m_Parameters["COMPOSITE_G"].Set_Value(1);
                m_Parameters["COMPOSITE_B"].Set_Value(2);
        }
 
        Set_Stretch(m_Parameters);
        Set_Stretch(m_Parameters, Get_Grid(0), "_R");
        Set_Stretch(m_Parameters, Get_Grid(1), "_G");
        Set_Stretch(m_Parameters, Get_Grid(2), "_B");
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::Parameters_Changed(void)
{
        CSG_Map_Layer::Parameters_Changed();
 
        //-----------------------------------------------------
        Set_Grid_Choices(m_Parameters);
 
        //-----------------------------------------------------
        if( m_Parameters("COLOR_SYMBOLS")->asInt() == CSG_Map_Symbology::COMPOSITE && m_Parameters("COMPOSITE_FIT")->asInt() != 0 )
        {
                m_Stretch[0].Create(
                        m_Parameters["STRETCH_RANGE_R.MIN"  ].asDouble(),
                        m_Parameters["STRETCH_RANGE_R.MAX"  ].asDouble(),
                        m_Parameters["STRETCH_INTERVALS"    ].asInt   (),
                        m_Parameters["STRETCH_INTERVALS_LOG"].asDouble()
                );
 
                m_Stretch[1].Create(
                        m_Parameters["STRETCH_RANGE_G.MIN"  ].asDouble(),
                        m_Parameters["STRETCH_RANGE_G.MAX"  ].asDouble(),
                        m_Parameters["STRETCH_INTERVALS"    ].asInt   (),
                        m_Parameters["STRETCH_INTERVALS_LOG"].asDouble()
                );
 
                m_Stretch[2].Create(
                        m_Parameters["STRETCH_RANGE_B.MIN"  ].asDouble(),
                        m_Parameters["STRETCH_RANGE_B.MAX"  ].asDouble(),
                        m_Parameters["STRETCH_INTERVALS"    ].asInt   (),
                        m_Parameters["STRETCH_INTERVALS_LOG"].asDouble()
                );
 
                m_Stretch[0].Set_Histogram(Get_Grid(0));
                m_Stretch[1].Set_Histogram(Get_Grid(1));
                m_Stretch[2].Set_Histogram(Get_Grid(2));
        }
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::Set_Grid_Choices(CSG_Parameters &Parameters, int NameField)
{
        if( m_pObject )
        {
                if( NameField < 0 ) { NameField = m_pObject->asGrids()->Get_Z_Name_Field(); }
 
                CSG_String List(_Get_List_Bands(NameField));
 
                bool bReset = Parameters["BAND"].asChoice()->Get_Count() != m_pObject->asGrids()->Get_NZ();
 
                if( Parameters("BAND") ) { Parameters["BAND"].asChoice()->Set_Items(List); }
 
                List += CSG_String::Format("<%s>", _TL("external grid"));
 
                if( Parameters("COMPOSITE_R") ) { Parameters["COMPOSITE_R"].asChoice()->Set_Items(List); if( bReset ) { Parameters["COMPOSITE_R"].Set_Value(2); } }
                if( Parameters("COMPOSITE_G") ) { Parameters["COMPOSITE_G"].asChoice()->Set_Items(List); if( bReset ) { Parameters["COMPOSITE_G"].Set_Value(1); } }
                if( Parameters("COMPOSITE_B") ) { Parameters["COMPOSITE_B"].asChoice()->Set_Items(List); if( bReset ) { Parameters["COMPOSITE_B"].Set_Value(0); } }
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
CSG_Grid * CSG_Map_Grids::Get_Grid(void)
{
        int i = m_Parameters("BAND")->asInt();
 
        return( m_pObject && i >= 0 && i < m_pObject->asGrids()->Get_NZ() ? m_pObject->asGrids()->Get_Grid_Ptr(i) : NULL );
}
 
//---------------------------------------------------------
CSG_Grid * CSG_Map_Grids::Get_Grid(int Band)
{
        return( _Get_Grid(Band, m_Parameters) );
}
 
//---------------------------------------------------------
CSG_String CSG_Map_Grids::Get_Grid_Name(int Band, int Style)
{
        int Choice = -1;
 
        switch( Band )
        {
        case 0: Choice = m_Parameters["COMPOSITE_R"].asInt(); break;
        case 1: Choice = m_Parameters["COMPOSITE_G"].asInt(); break;
        case 2: Choice = m_Parameters["COMPOSITE_B"].asInt(); break;
        }
 
        if( Choice >= 0 )
        {
                if( m_pObject && Choice < m_pObject->asGrids()->Get_NZ() )
                {
                        return( m_pObject->asGrids()->Get_Grid_Name(Choice, Style) );
                }
 
                CSG_Grid *pGrid = NULL;
 
                switch( Band )
                {
                case 0: pGrid = m_Parameters["COMPOSITE_R_GRID"].asGrid(); break;
                case 1: pGrid = m_Parameters["COMPOSITE_G_GRID"].asGrid(); break;
                case 2: pGrid = m_Parameters["COMPOSITE_B_GRID"].asGrid(); break;
                }
 
                if( pGrid )
                {
                        return( pGrid->Get_Name() );
                }
        }
 
        return( "" );
}
 
//---------------------------------------------------------
CSG_Grid * CSG_Map_Grids::_Get_Grid(int Band, const CSG_Parameters &Parameters)
{
        int Choice = -1;
 
        switch( Band )
        {
        case 0: Choice = Parameters["COMPOSITE_R"].asInt(); break;
        case 1: Choice = Parameters["COMPOSITE_G"].asInt(); break;
        case 2: Choice = Parameters["COMPOSITE_B"].asInt(); break;
        }
 
        if( Choice >= 0 )
        {
                if( m_pObject && Choice < m_pObject->asGrids()->Get_NZ() )
                {
                        return( m_pObject->asGrids()->Get_Grid_Ptr(Choice) );
                }
 
                switch( Band )
                {
                case 0: return( Parameters["COMPOSITE_R_GRID"].asGrid() );
                case 1: return( Parameters["COMPOSITE_G_GRID"].asGrid() );
                case 2: return( Parameters["COMPOSITE_B_GRID"].asGrid() );
                }
        }
 
        return( NULL );
}
 

//                                                       //
 
//---------------------------------------------------------
CSG_String CSG_Map_Grids::_Get_List_Attributes(void)
{
        CSG_String List;
 
        for(int i=0; m_pObject && i<m_pObject->asGrids()->Get_Attributes().Get_Field_Count(); i++)
        {
                List += m_pObject->asGrids()->Get_Attributes().Get_Field_Name(i); List += "|";
        }
 
        return( List );
}
 
//---------------------------------------------------------
CSG_String CSG_Map_Grids::_Get_List_Bands(int Attribute)
{
        CSG_String List;
 
        if( m_pObject )
        {
                if( Attribute < 0 || Attribute >= m_pObject->asGrids()->Get_Attributes().Get_Field_Count() )
                {
                        Attribute = m_pObject->asGrids()->Get_Z_Name_Field();
                }
 
                for(int i=0; i<m_pObject->asGrids()->Get_NZ(); i++)
                {
                        List += m_pObject->asGrids()->Get_Attributes()[i].asString(Attribute); List += "|";
                }
        }
 
        return( List );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Grids::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;
 
                if( m_Parameters("COLOR_SYMBOLS")->asInt() == CSG_Map_Symbology::DISCRETE
                ||  m_Parameters("COLOR_SYMBOLS")->asInt() == CSG_Map_Symbology::GRADUATED )
                {
                        return( _Get_Stretch_Extent(Extent, Get_Grid(), Minimum, Maximum) && Set_Stretch_Range(Minimum, Maximum) );
                }
 
                //-------------------------------------------------
                if( m_Parameters("COMPOSITE_FIT")->asInt() == 0 && m_pObject )     // overall band statistics
                {
                        return( _Get_Stretch_Extent(Extent, m_pObject->asGrids(), Minimum, Maximum) && Set_Stretch_Range(Minimum, Maximum) );
                }
 
                //-------------------------------------------------
                if( _Get_Stretch_Extent(Extent, Get_Grid(), 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( _Get_Stretch_Extent(Extent, Get_Grid(i), Minimum, Maximum) )
                        {
                                m_Parameters.Set_Parameter("STRETCH_RANGE_" + Band[i] + ".MIN", Minimum);
                                m_Parameters.Set_Parameter("STRETCH_RANGE_" + Band[i] + ".MAX", Maximum);
                        }
                }
 
                m_Parameters["STRETCH"].Set_Value(3); // 'manual'
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Grids::_Get_Stretch_Extent(const CSG_Rect &Extent, CSG_Data_Object *pObject, double &Minimum, double &Maximum) const
{
        if( pObject )
        {
                switch( m_Stretch_Extent )
                {
                default:
                        {
                                CSG_Simple_Statistics s;
 
                                if( pObject->asGrid() ? pObject->asGrid()->Get_Statistics(Extent, s) : pObject->asGrids() && pObject->asGrids()->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( pObject->asGrid() ? pObject->asGrid()->Get_Statistics(Extent, s) : pObject->asGrids() && pObject->asGrids()->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( pObject->asGrid() ? pObject->asGrid()->Get_Histogram (Extent, h) : pObject->asGrids() && pObject->asGrids()->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_Grids::asImage(CSG_Grid *pImage)
{
        wxImage Image;
 
        if( m_pObject && pImage && Get_Image(Image) )
        {
                pImage->Create(m_pObject->asGrids()->Get_System(), 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() )
                        {
                                pImage->Set_Value(x, y, SG_GET_RGBA(Image.GetRed(x, y), Image.GetGreen(x, y), Image.GetBlue(x, y), Image.GetAlpha(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_Grids::Get_Image(wxImage &Image, bool bFitSize, int Width, int Height)
{
        if( bFitSize || Width  < 1 ) { Width  = Get_Grid()->Get_NX(); }
        if( bFitSize || Height < 1 ) { Height = Get_Grid()->Get_NY(); }
 
        if( Width > 0 && Height > 0 && Image.Create(Width, Height) )
        {
                SG_UI_Process_Set_Busy(true);
 
                CSG_Map_DC dc_Map(Get_Extent(), Image.GetSize(), 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_Grids::Get_Bitmap(wxBitmap &Bitmap, bool bFitSize, int Width, int Height)
{
        if( bFitSize || Width  < 1 ) { Width  = bFitSize ? Get_Grid()->Get_NX() : Bitmap.GetWidth (); }
        if( bFitSize || Height < 1 ) { Height = bFitSize ? Get_Grid()->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_Grids::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 );
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_Grids::On_Draw(CSG_Map_DC &dc_Map, int Flags)
{
        if( m_pObject == NULL || Get_Grid() == NULL || m_pObject->asGrids()->Get_NZ() < 1 || 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_Alpha.is_Okay() ? CSG_Map_DC::Mode::Alpha : CSG_Map_DC::Mode::Transparent;
 
        if( !dc_Map.Draw_Image_Begin(m_Parameters("TRANSPARENCY")->asDouble() / 100., Mode) )
        {
                return;
        }
 
        //-----------------------------------------------------
        switch( m_Parameters("COLOR_SYMBOLS")->asInt() )
        {
        case CSG_Map_Symbology::SINGLE    : m_pSymbology->Set_Mode(CSG_Map_Symbology::SINGLE    ); break;
        case CSG_Map_Symbology::CLASSIFIED: m_pSymbology->Set_Mode(CSG_Map_Symbology::CLASSIFIED); break;
        case CSG_Map_Symbology::DISCRETE  : m_pSymbology->Set_Mode(CSG_Map_Symbology::DISCRETE  ); break;
        case CSG_Map_Symbology::GRADUATED : m_pSymbology->Set_Mode(CSG_Map_Symbology::GRADUATED ); break;
        case CSG_Map_Symbology::COMPOSITE : m_pSymbology->Set_Mode(CSG_Map_Symbology::COMPOSITE ); break;
        }
 
        //-----------------------------------------------------
        if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::SINGLE )
        {
                m_Bands.Resampling = CSG_Grid_Resampling::NearestNeighbour;
        }
        else
        {
                m_Bands.Resampling = m_Parameters(m_pSymbology->Get_Mode() == CSG_Map_Symbology::CLASSIFIED ? "CLASSIFIED_RESAMPLING" : "STRETCH_RESAMPLING")->asGrid_Resampling();
        }
 
        m_Bands.bOverlay = m_pSymbology->Get_Mode() == CSG_Map_Symbology::COMPOSITE;
        m_Bands.bBandStatistics = m_Parameters("COMPOSITE_FIT")->asInt() != 0;
 
        m_Bands.Set_Bands(m_pSymbology->Get_Mode() != CSG_Map_Symbology::COMPOSITE ? Get_Grid() : Get_Grid(0), Get_Grid(1), Get_Grid(2));
 
        //-----------------------------------------------------
        if(     dc_Map.DC2World() >= m_pObject->asGrids()->Get_Cellsize() || m_Bands.Resampling != CSG_Grid_Resampling::NearestNeighbour )
        {
                _Draw_Points(dc_Map);
        }
        else
        {
                _Draw_Cells (dc_Map);
        }
 
        //-----------------------------------------------------
        dc_Map.Draw_Image_End();
}
 
//---------------------------------------------------------
void CSG_Map_Grids::_Draw_Cells(CSG_Map_DC &dc_Map)
{
        int xa = m_pObject->asGrids()->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMin()); if( xa <  0                     ) { xa =                         0; }
        int xb = m_pObject->asGrids()->Get_System().Get_xWorld_to_Grid(dc_Map.rWorld().Get_XMax()); if( xb >= m_pObject->asGrids()->Get_NX() ) { xb = m_pObject->asGrids()->Get_NX() - 1; }
        int ya = m_pObject->asGrids()->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMin()); if( ya <  0                     ) { ya =                         0; }
        int yb = m_pObject->asGrids()->Get_System().Get_yWorld_to_Grid(dc_Map.rWorld().Get_YMax()); if( yb >= m_pObject->asGrids()->Get_NY() ) { yb = m_pObject->asGrids()->Get_NY() - 1; }
 
        double  dDC = m_pObject->asGrids()->Get_Cellsize() * dc_Map.World2DC();
 
        double axDC = dc_Map.xWorld2DC(m_pObject->asGrids()->Get_System().Get_xGrid_to_World(xa)) + dDC / 2.;
        double ayDC = dc_Map.yWorld2DC(m_pObject->asGrids()->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; int Color;
 
                for(int x=xa, xaDC=(int)(axDC-dDC), xbDC=(int)(axDC); x<=xb; x++, xaDC=xbDC, xbDC=(int)(xDC+=dDC))
                {
                        if( _Draw_Get_Color(Color, x, y) )
                        {
                                if( m_Alpha.is_Okay() )
                                {
                                        m_Alpha.Set_Alpha(Color, m_pObject->asGrids()->Get_System(), x, y);
                                }
 
                                dc_Map.Draw_Image_Pixels(xaDC, yaDC, xbDC, ybDC, Color);
                        }
                }
        }
}
 
//---------------------------------------------------------
void CSG_Map_Grids::_Draw_Points(CSG_Map_DC &dc_Map)
{
        CSG_Rect rMap(dc_Map.rWorld()); rMap.Intersect(m_pObject->asGrids()->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 byDC = (int)dc_Map.yWorld2DC(rMap.Get_YMax()); if( byDC <  0                        ) { byDC =                            0; }
        int ayDC = (int)dc_Map.yWorld2DC(rMap.Get_YMin()); if( ayDC >= dc_Map.rDC().GetHeight() ) { ayDC = dc_Map.rDC().GetHeight() - 1; }
 
        int nyDC = abs(ayDC - byDC);
 
        #pragma omp parallel for
        for(int iyDC=0; iyDC<=nyDC; iyDC++)
        {
                int Color, yDC = ayDC - iyDC; CSG_Point Point(dc_Map.xDC2World(axDC), dc_Map.yDC2World(yDC));
 
                for(int xDC=axDC; xDC<=bxDC; Point.x+=dc_Map.DC2World(), xDC++)
                {
                        if( _Draw_Get_Color(Color, Point) )
                        {
                                if( m_Alpha.is_Okay() )
                                {
                                        m_Alpha.Set_Alpha(Color, Point.x, Point.y);
                                }
 
                                dc_Map.Draw_Image_Pixel(xDC, yDC, Color);
                        }
                }
        }
}
 
//---------------------------------------------------------
inline bool CSG_Map_Grids::_Draw_Get_Color(int &Color, int x, int y)
{
        if( !m_Bands.bOverlay )
        {
                return( m_Bands[0]->is_InGrid(x, y) && m_pSymbology->Get_Class_Color_byValue(m_Bands[0]->asDouble(x, y), Color) );
        }
 
        for(int i=0; i<3; i++)
        {
                if( m_Bands[i] == NULL )
                {
                        ((BYTE *)&Color)[i] = 0;
                }
                else
                {
                        double Value;
 
                        if( m_Bands[i]->Get_System() == m_pObject->asGrids()->Get_System() )
                        {
                                if( !m_Bands[i]->is_InGrid(x, y) )
                                {
                                        return( false );
                                }
 
                                Value = m_Bands[i]->asDouble(x, y);
                        }
                        else if( !m_Bands[i]->Get_Value(m_pObject->asGrids()->Get_System().Get_Grid_to_World(x, y), Value, m_Bands.Resampling))
                        {
                                return( false );
                        }
 
                        Value = 255. * (m_Bands.bBandStatistics ? m_Stretch[i].to_Relative(Value) : m_pSymbology->Get_Stretch_to_Relative(Value));
 
                        ((BYTE *)&Color)[i] = Value <= 0. ? 0 : Value >= 255. ? 255 : (BYTE)Value;
                }
        }
 
        return( true );
}
 
//---------------------------------------------------------
inline bool CSG_Map_Grids::_Draw_Get_Color(int &Color, const CSG_Point &Point)
{
        double Value;
 
        if( !m_Bands.bOverlay )
        {
                return( m_Bands.pBands[0]->Get_Value(Point, Value, m_Bands.Resampling, false) && m_pSymbology->Get_Class_Color_byValue(Value, Color) );
        }
 
        for(int i=0; i<3; i++)
        {
                if( m_Bands[i] == NULL )
                {
                        ((BYTE *)&Color)[i] = 0;
                }
                else
                {
                        if( !m_Bands[i]->Get_Value(Point, Value, m_Bands.Resampling, false) )
                        {
                                return( false );
                        }
 
                        Value = 255. * (m_Bands.bBandStatistics ? m_Stretch[i].to_Relative(Value) : m_pSymbology->Get_Stretch_to_Relative(Value));
 
                        ((BYTE *)&Color)[i] = Value <= 0. ? 0 : Value >= 255. ? 255 : (BYTE)Value;
                }
        }
 
        return( true );
}
 

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