map_basemap.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                   map_graticule.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 "map_dc.h"
#include "map_layer.h"
 
#include "../dc_helper.h"
#include "../tool_library.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_BaseMap::CSG_Map_BaseMap(void)
{
        m_pTool = NULL; // remember the last created base map tool instance
 
        m_Parameters.Set_Name      ("BASEMAP");
        m_Parameters.Set_Identifier("BASEMAP");
 
        //-----------------------------------------------------
        m_Parameters.Add_Node("", "NODE_GENERAL",_TL("General")      , _TL(""));
 
        m_Parameters.Add_String("NODE_GENERAL",
                "NAME"        , _TL("Name"),
                _TL(""),
                _TL("Base Map")
        );
 
        m_Parameters.Add_Choice("NODE_GENERAL",
                "SERVER"      , _TL("Server"),
                _TL(""),
                CSG_String::Format("%s|%s|%s|%s|%s|%s|%s|%s|%s|%s",
                        SG_T("Open Street Map"),
                        SG_T("Google Map"),
                        SG_T("Google Satellite"),
                        SG_T("Google Hybrid"),
                        SG_T("Google Terrain"),
                        SG_T("Google Terrain, Streets and Water"),
                        SG_T("ArcGIS MapServer Tiles"),
                        SG_T("TopPlusOpen"),
                        SG_T("EMODnet Bathymetry WMTS service"),
                        SG_T("user defined")
                ), 0
        );
 
        m_Parameters.Add_String("SERVER",
                "SERVER_USER", _TL("Server"),
                _TL(""),
                "tile.openstreetmap.org/${z}/${x}/${y}.png"
        );
 
        m_Parameters.Add_Int("SERVER",
                "SERVER_EPSG" , _TL("EPSG"),
                _TL(""),
                3857
        );
 
        //-----------------------------------------------------
        m_Parameters.Add_Bool("NODE_GENERAL",
                "CACHE"       , _TL("Cache"),
                _TL("Enable local disk cache. Allows for offline operation."),
                false
        );
 
        m_Parameters.Add_FilePath("CACHE",
                "CACHE_DIR"   , _TL("Cache Directory"),
                _TL("If not specified the cache will be created in the current user's temporary directory."),
                NULL, NULL, false, true
        );
 
        //-----------------------------------------------------
        m_Parameters.Add_Node("", "NODE_DISPLAY",_TL("Display")      , _TL(""));
 
        m_Parameters.Add_Double("NODE_DISPLAY",
                "TRANSPARENCY", _TL("Transparency"),
                _TL("Transparency specified as percentage."),
                0., 0., true, 100., true
        );
 
        m_Parameters.Add_Double("NODE_DISPLAY",
                "BRIGHTNESS"  , _TL("Maximum Brightness"),
                _TL("Brightness threshold [%] below a pixel is displayed. Set to 100% to display all (default)."),
                100., 0., true, 100., true
        );
 
        m_Parameters.Add_Choice("NODE_DISPLAY",
                "GRAYSCALE"   , _TL("Gray Scale"),
                _TL(""),
                CSG_String::Format("%s|%s|%s",
                        _TL("no"),
                        _TL("yes"),
                        _TL("yes, contrastet")
                ), 0
        );
 
        m_Parameters.Add_Double("NODE_DISPLAY",
                "RESOLUTION"  , _TL("Resolution"),
                _TL("resolution measured in screen pixels"),
                1., 1., true
        );
}
 
//---------------------------------------------------------
CSG_Map_BaseMap::~CSG_Map_BaseMap(void)
{
        SG_Get_Tool_Library_Manager().Delete_Tool(m_pTool);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_BaseMap::Set_Parameters(const CSG_Parameters &Parameters)
{
        int n = 0;
 
        for(int i=0; i<Parameters.Get_Count(); i++)
        {
                CSG_Parameter *pParameter = m_Parameters(Parameters[i].Get_Identifier());
 
                if( pParameter && pParameter->Get_Type() == Parameters[i].Get_Type() )
                {
                        CSG_String oldValue = pParameter->asString();
 
                        if( pParameter->Assign(Parameters(i)) && oldValue.Cmp(pParameter->asString())
                        && !pParameter->Cmp_Identifier("NAME"     )
                        && !pParameter->Cmp_Identifier("CACHE"    )
                        && !pParameter->Cmp_Identifier("CACHE_DIR") )
                        {
                                n++;
                        }
                }
        }
 
        if( n > 0 )
        {
                m_BaseMap.Destroy(); // forcing a base map refresh
        }
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_BaseMap::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        if( Flags & PARAMETER_CHECK_ENABLE )
        {
                if(     Parameter.Cmp_Identifier("SERVER") )
                {
                        bool bUser = Parameter.asInt() >= Parameter.asChoice()->Get_Count() - 1;
 
                        Parameters.Set_Enabled("SERVER_USER", bUser);
                        Parameters.Set_Enabled("SERVER_EPSG", bUser);
                }
 
                if( Parameter.Cmp_Identifier("CACHE") )
                {
                        Parameters.Set_Enabled("CACHE_DIR"  , Parameter.asBool());
                }
        }
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_BaseMap::Parameters_Changed(void)
{
        m_BaseMap.Destroy(); // forcing a base map refresh
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_BaseMap::Draw(CSG_Map_DC &dc_Map, const CSG_Projection &Projection)
{
        CSG_Grid_System  System(dc_Map.DC2World(), dc_Map.rWorld().Get_XMin(), dc_Map.rWorld().Get_YMin(), dc_Map.rDC().GetWidth(), dc_Map.rDC().GetHeight());
 
        if( System != m_BaseMap.Get_System() )
        {
                if( !Get_BaseMap(System, Projection) )
                {
                        wxColour oldColour(dc_Map.Get_DC().GetTextForeground()); dc_Map.Get_DC().SetTextForeground(*wxLIGHT_GREY);
                        wxFont   oldFont  (dc_Map.Get_DC().GetFont          ()); dc_Map.Get_DC().SetFont(wxSystemSettings::GetFont(wxSYS_SYSTEM_FONT));
 
                        wxString Text(_TL("Base Map Error")); wxSize Size(dc_Map.Get_DC().GetTextExtent(Text));
 
                        for(int y=dc_Map.rDC().GetTop(), x0=0; y<=dc_Map.rDC().GetBottom(); y+=2*Size.y, x0=x0?0:Size.x)
                        {
                                for(int x=dc_Map.rDC().GetLeft()+x0; x<=dc_Map.rDC().GetRight(); x+=2*Size.x)
                                {
                                        SG_DC_Draw_Text(dc_Map.Get_DC(), SG_DC_TEXTALIGN_CENTER, x, y, 0., Text, SG_DC_TEXTEFFECT_FRAME, *wxWHITE, 1);
                                }
                        }
 
                        dc_Map.Get_DC().SetTextForeground(oldColour);
                        dc_Map.Get_DC().SetFont          (oldFont  );
 
                        return( false );
                }
        }
 
        //-----------------------------------------------------
        if( dc_Map.Draw_Image_Begin(m_Parameters["TRANSPARENCY"].asDouble() / 100.) )
        {
                #pragma omp parallel for
                for(int y=0; y<m_BaseMap.Get_NY(); y++) for(int x=0, yy=m_BaseMap.Get_NY()-y-1; x<m_BaseMap.Get_NX(); x++)
                {
                        if( !m_BaseMap.is_NoData(x, yy) )
                        {
                                dc_Map.Draw_Image_Pixel(x, y, m_BaseMap.asInt(x, yy));
                        }
                }
 
                dc_Map.Draw_Image_End();
        }
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_BaseMap::Get_BaseMap(const CSG_Grid_System &System, const CSG_Projection &Projection)
{
        CSG_Tool *pTool;
 
        if(     !Projection.is_Okay() || !(pTool = SG_Get_Tool_Library_Manager().Create_Tool("io_gdal", 9)) )
        {
                m_BaseMap.Destroy();
 
                return( false );
        }
 
        SG_UI_ProgressAndMsg_Lock(true);
 
        //-----------------------------------------------------
        CSG_Grid_System _System(System);
 
        if( m_Parameters["RESOLUTION"].asDouble() > 1. )
        {
                _System.Create(m_Parameters["RESOLUTION"].asDouble() * System.Get_Cellsize(), System.Get_Extent(true));
        }
 
        if( _System != m_BaseMap.Get_System() )
        {
                m_BaseMap.Create(_System, SG_DATATYPE_Int);
        }
 
        m_BaseMap.Get_Projection() = Projection;
 
        m_pTool = pTool; // remember the last created base map tool instance
 
        pTool->Set_Manager(NULL); pTool->Set_Callback(false);
 
        if( pTool->Set_Parameter("TARGET"     , &m_BaseMap)
        &&  pTool->Set_Parameter("TARGET_MAP" , &m_BaseMap)
        &&  pTool->Set_Parameter("SERVER"     , m_Parameters("SERVER"     ))
        &&  pTool->Set_Parameter("SERVER_USER", m_Parameters("SERVER_USER"))
        &&  pTool->Set_Parameter("SERVER_EPSG", m_Parameters("SERVER_EPSG"))
        &&  pTool->Set_Parameter("CACHE"      , m_Parameters("CACHE"      ))
        &&  pTool->Set_Parameter("CACHE_DIR"  , m_Parameters("CACHE_DIR"  ))
        &&  pTool->Set_Parameter("GRAYSCALE"  , m_Parameters["GRAYSCALE"  ].asInt() != 0)
        &&  pTool->On_Before_Execution() && pTool->Execute() && pTool == m_pTool )
        {
                m_pTool = NULL;
 
                int bGrayscale = m_Parameters["GRAYSCALE"].asInt();
 
                if( System != m_BaseMap.Get_System() )
                {
                        CSG_Grid BaseMap(m_BaseMap); m_BaseMap.Create(System, SG_DATATYPE_DWord);
 
                        #pragma omp parallel for
                        for(int y=0; y<m_BaseMap.Get_NY(); y++) for(int x=0; x<m_BaseMap.Get_NX(); x++)
                        {
                                double c;
 
                                if( BaseMap.Get_Value(System.Get_Grid_to_World(x, y), c, CSG_Grid_Resampling::Bicubic_2, false, !bGrayscale) )
                                {
                                        m_BaseMap.Set_Value(x, y, c);
                                }
                                else
                                {
                                        m_BaseMap.Set_NoData(x, y);
                                }
                        }
                }
 
                if( bGrayscale )
                {
                        double offset = 0., scale = 1.;
 
                        if( bGrayscale == 2 && m_BaseMap.Get_Range() > 0. )
                        {
                                offset = m_BaseMap.Get_Min(); scale = 255. / m_BaseMap.Get_Range();
                        }
 
                        #pragma omp parallel for
                        for(int y=0; y<m_BaseMap.Get_NY(); y++) for(int x=0; x<m_BaseMap.Get_NX(); x++)
                        {
                                if( m_BaseMap.is_NoData(x, y) == false )
                                {
                                        int c = (int)(scale * (m_BaseMap.asDouble(x, y) - offset));
 
                                        m_BaseMap.Set_Value(x, y, SG_GET_RGB(c, c, c));
                                }
                        }
                }
 
                if( m_Parameters["BRIGHTNESS"].asDouble() < 100. )
                {
                        int Threshold = (int)(0.5 + 3 * 255 * m_Parameters["BRIGHTNESS"].asDouble() / 100.);
 
                        #pragma omp parallel for
                        for(sLong i=0; i<m_BaseMap.Get_NCells(); i++)
                        {
                                int c = m_BaseMap.asInt(i);
 
                                if( Threshold < (SG_GET_R(c) + SG_GET_G(c) + SG_GET_B(c)) )
                                {
                                        m_BaseMap.Set_NoData(i);
                                }
                        }
                }
        }
        else if( pTool == m_pTool )
        {
                m_pTool = NULL;
 
                m_BaseMap.Destroy();
        }
 
        //-----------------------------------------------------
        SG_UI_ProgressAndMsg_Lock(false);
 
        SG_Get_Tool_Library_Manager().Delete_Tool(pTool);
 
        return( m_BaseMap.is_Valid() );
}
 

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