mapping.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                     mapping.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/>.                       //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//    contact:    Olaf Conrad                            //
//                Institute of Geography                 //
//                University of Hamburg                  //
//                Germany                                //
//                                                       //
//    e-mail:     oconrad@saga-gis.org                   //
//                                                       //
 
//---------------------------------------------------------
#include "../dc_helper.h"
 
#include "map_dc.h"
#include "map_layer.h"
#include "map_classify.h"
#include "map_legend.h"
 
#include "mapping.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap_Canvas::CMap_Canvas(void)
{
        m_pDC = new wxMemoryDC(); m_pBitmap = new wxBitmap;
}
 
//---------------------------------------------------------
CMap_Canvas::CMap_Canvas(int Width, int Height, int Background)
{
        m_pDC = new wxMemoryDC(); m_pBitmap = new wxBitmap;
 
        Create(Width, Height, Background);
}
 
//---------------------------------------------------------
CMap_Canvas::~CMap_Canvas(void)
{
        delete(m_pDC); delete(m_pBitmap);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CMap_Canvas::Create(int Width, int Height, int Background)
{
        m_pDC->SelectObject(wxNullBitmap);
 
        if( Width > 0 && Height > 0 && m_pBitmap->Create(Width, Height) )
        {
                m_pDC->SelectObject(*m_pBitmap);
                m_pDC->SetBackground(wxBrush(Background < 0 ? *wxWHITE : wxColour(SG_GET_R(Background), SG_GET_G(Background), SG_GET_B(Background))));
                m_pDC->Clear();
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CMap_Canvas::Clear(void)
{
        m_pDC->Clear();
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CMap_Canvas::Save(const char       *File) { return( Save(CSG_String(File)) ); }
bool CMap_Canvas::Save(const wchar_t    *File) { return( Save(CSG_String(File)) ); }
bool CMap_Canvas::Save(const CSG_String &File)
{
        if( m_pBitmap->IsOk() )
        {
                if( SG_File_Cmp_Extension(File, "jpg") && !wxImage::FindHandler(wxBITMAP_TYPE_JPEG) ) { wxImage::AddHandler(new wxJPEGHandler); }
                if( SG_File_Cmp_Extension(File, "png") && !wxImage::FindHandler(wxBITMAP_TYPE_PNG ) ) { wxImage::AddHandler(new wxPNGHandler ); }
                if( SG_File_Cmp_Extension(File, "tif") && !wxImage::FindHandler(wxBITMAP_TYPE_TIF ) ) { wxImage::AddHandler(new wxTIFFHandler); }
                if( SG_File_Cmp_Extension(File, "gif") && !wxImage::FindHandler(wxBITMAP_TYPE_GIF ) ) { wxImage::AddHandler(new wxGIFHandler ); }
 
                m_pDC->SelectObject(wxNullBitmap);
                wxImage Image = m_pBitmap->ConvertToImage();
                m_pDC->SelectObject(*m_pBitmap);
 
                return( Image.SaveFile(File.wx_str()) );
        }
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CMap_Canvas::Draw_Map(CMap &Map, int x, int y, int Frame)
{
        return( Map.Draw(*this, x, y, Frame) );
}
 
//---------------------------------------------------------
bool CMap_Canvas::Draw_ScaleBar(CMap &Map, int x, int y, int Width, int Height, int Style)
{
        double w = Width * Map.Get_Extent().Get_XRange() / Map.Get_Width();
 
        SG_DC_Draw_Scale(*m_pDC, wxRect(x, y, Width, Height), 0., w, SG_DC_SCALE_HORIZONTAL, 5, Style);
 
        return( true );
}
 
//---------------------------------------------------------
bool CMap_Canvas::Draw_Legend(CMap_Layer &Layer, int x, int y, double Zoom)
{
        return( Layer.Draw_Legend(*this, x, y, Zoom) );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap::CMap(void)
{
        m_pDC = new CSG_Map_DC();
}
 
//---------------------------------------------------------
CMap::CMap(const CSG_Rect &rWorld, int Width, int Height, double Scale, int Background, bool bAlpha)
{
        m_pDC = new CSG_Map_DC();
 
        Create(rWorld, Width, Height, Scale, Background, bAlpha);
}
 
//---------------------------------------------------------
CMap::~CMap(void)
{
        delete(m_pDC);
}
 
//---------------------------------------------------------
bool CMap::Create(const CSG_Rect &rWorld, int Width, int Height, double Scale, int Background, bool bAlpha)
{
        return( m_pDC->Create(rWorld, wxRect(0, 0, Width, Height), Scale, Background, bAlpha) );
}
 
//---------------------------------------------------------
bool CMap::Clear(void)
{
        return( m_pDC->Create(m_pDC->rWorld(), m_pDC->rDC(), m_pDC->Scale(), m_pDC->Get_Background(), m_pDC->has_Alpha()) );
}
 
//---------------------------------------------------------
const CSG_Rect & CMap::Get_Extent(void) const { return( m_pDC->rWorld() ); }
 
//---------------------------------------------------------
int CMap::Get_Width (void) const { return( m_pDC->DC_Width ()); }
int CMap::Get_Height(void) const { return( m_pDC->DC_Height()); }
 

//                                                       //
 
//---------------------------------------------------------
bool CMap::Draw(CMap_Canvas &Canvas, int x, int y, int Frame)
{
        wxDC &dc = *Canvas.m_pDC;
 
        dc.DrawBitmap(m_pDC->Get_Bitmap(), x, y);
 
        if( Frame > 5 )
        {
                wxRect rMap(x, y, m_pDC->DC_Width(), m_pDC->DC_Height());
                CSG_Rect rWorld = m_pDC->rWorld(); int Width = Frame; bool bUseDCFont = false; bool bScaleBar = false;
 
                SG_DC_Draw_Edge(dc, SG_DC_EDGE_STYLE_SIMPLE, rMap.GetLeft(), rMap.GetTop(), rMap.GetRight(), rMap.GetBottom());
 
                wxRect rFrame(rMap); rFrame.Inflate(Width);
 
                SG_DC_Draw_Scale(dc, wxRect(rMap  .GetLeft(), rFrame.GetTop(), rMap.GetWidth (), Width),
                        rWorld.Get_XMin(), rWorld.Get_XMax(),  true,  true, false, "", bUseDCFont
                );
 
                SG_DC_Draw_Scale(dc, wxRect(rFrame.GetLeft(), rMap  .GetTop(), Width, rMap.GetHeight()),
                        rWorld.Get_YMin(), rWorld.Get_YMax(), false, false, false, "", bUseDCFont
                );
 
                if( bScaleBar == false )
                {
                        SG_DC_Draw_Scale(dc, wxRect(rMap.GetLeft (), rMap.GetBottom(), rMap.GetWidth (), Width),
                                rWorld.Get_XMin(), rWorld.Get_XMax(),  true,  true, true, "", bUseDCFont
                        );
 
                        SG_DC_Draw_Scale(dc, wxRect(rMap.GetRight(), rMap.GetTop   (), Width, rMap.GetHeight()),
                                rWorld.Get_YMin(), rWorld.Get_YMax(), false, false, true, "", bUseDCFont
                        );
                }
                else
                {
                        SG_DC_Draw_Scale(dc, wxRect(rMap.GetLeft (), rMap.GetBottom(), rMap.GetWidth (), Width),
                                0., rWorld.Get_XRange(),  true,  true, true, "", bUseDCFont
                        );
 
                        SG_DC_Draw_Scale(dc, wxRect(rMap.GetRight(), rMap.GetTop   (), Width, rMap.GetHeight()),
                                0., rWorld.Get_YRange(), false, false, true, "", bUseDCFont
                        );
                }
 
                SG_DC_Draw_Edge(dc, SG_DC_EDGE_STYLE_SIMPLE, rFrame.GetLeft(), rFrame.GetTop(), rFrame.GetRight(), rFrame.GetBottom());
        }
 
        return( true );
}
 
//---------------------------------------------------------
bool CMap::Draw(CMap_Base_Layer &Layer)
{
        return( Layer.Draw(*this) );
}
 
//---------------------------------------------------------
bool CMap::Save(const char       *File) { return( Save(CSG_String(File)) ); }
bool CMap::Save(const wchar_t    *File) { return( Save(CSG_String(File)) ); }
bool CMap::Save(const CSG_String &File)
{
        wxImage Image;
 
        if( m_pDC->Get_Image(Image) )
        {
                if( SG_File_Cmp_Extension(File, "jpg") && !wxImage::FindHandler(wxBITMAP_TYPE_JPEG) ) { wxImage::AddHandler(new wxJPEGHandler); }
                if( SG_File_Cmp_Extension(File, "png") && !wxImage::FindHandler(wxBITMAP_TYPE_PNG ) ) { wxImage::AddHandler(new wxPNGHandler ); }
                if( SG_File_Cmp_Extension(File, "tif") && !wxImage::FindHandler(wxBITMAP_TYPE_TIF ) ) { wxImage::AddHandler(new wxTIFFHandler); }
                if( SG_File_Cmp_Extension(File, "gif") && !wxImage::FindHandler(wxBITMAP_TYPE_GIF ) ) { wxImage::AddHandler(new wxGIFHandler ); }
 
                return( Image.SaveFile(File.wx_str()) );
        }
 
        return( false );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap_Base_Layer::CMap_Base_Layer(void)
{}
 
//---------------------------------------------------------
CMap_Base_Layer::~CMap_Base_Layer(void)
{}
 
//---------------------------------------------------------
const SG_Char * CMap_Base_Layer::List_Parameters(bool bDescription, bool bConstraints, bool bValue) const
{
        static CSG_String Listing; Listing.Printf("\n___\n%s\n___\n", Get_Name().c_str());
 
        Listing += Get_Parameters().Get_Parameter_Listing(false, bDescription, bConstraints, bValue);
 
        return( Listing.c_str() );
}
 
//---------------------------------------------------------
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, const char       *Value) { return( Set_Parameter(ID, CSG_String(Value)) ); }
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, const wchar_t    *Value) { return( Set_Parameter(ID, CSG_String(Value)) ); }
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, const CSG_String &Value)
{
        return( Get_Parameters().Set_Parameter(ID, Value) );
}
 
//---------------------------------------------------------
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, int Value)
{
        return( Get_Parameters().Set_Parameter(ID, Value) );
}
 
//---------------------------------------------------------
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, double Value)
{
        return( Get_Parameters().Set_Parameter(ID, Value) );
}
 
//---------------------------------------------------------
bool CMap_Base_Layer::Set_Parameter(const SG_Char *ID, const CSG_Colors &Value)
{
        return( Get_Parameters().Set_Parameter(ID, Value) );
}
 
//---------------------------------------------------------
bool CMap_Base_Layer::Draw(CMap &Map)
{
        return( On_Draw(*Map.m_pDC) );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap_Layer::CMap_Layer(void)
{
        m_pLayer = NULL; m_pClassify = new CSG_Map_Classify();
}
 
//---------------------------------------------------------
CMap_Layer::CMap_Layer(CSG_Data_Object &Layer)
{
        m_pLayer = NULL; m_pClassify = new CSG_Map_Classify();
 
        Create(Layer);
}
 
//---------------------------------------------------------
CMap_Layer::~CMap_Layer(void)
{
        Destroy(); delete(m_pClassify);
}
 
//---------------------------------------------------------
bool CMap_Layer::Create(CSG_Data_Object &Layer)
{
        Destroy();
 
        switch( Layer.Get_ObjectType() )
        {
        case SG_DATAOBJECT_TYPE_Grid      : m_pLayer = new CSG_Map_Grid          (Layer.asGrid      ()); return( true );
        case SG_DATAOBJECT_TYPE_Grids     : m_pLayer = new CSG_Map_Grids         (Layer.asGrids     ()); return( true );
        case SG_DATAOBJECT_TYPE_PointCloud: m_pLayer = new CSG_Map_PointCloud    (Layer.asPointCloud()); return( true );
        case SG_DATAOBJECT_TYPE_TIN       : m_pLayer = new CSG_Map_TIN           (Layer.asTIN       ()); return( true );
        case SG_DATAOBJECT_TYPE_Shapes    :
                switch( Layer.asShapes()->Get_Type() )
                {
                case SHAPE_TYPE_Point         : m_pLayer = new CSG_Map_Shapes_Point  (Layer.asShapes    ()); return( true );
                case SHAPE_TYPE_Points        : m_pLayer = new CSG_Map_Shapes_Points (Layer.asShapes    ()); return( true );
                case SHAPE_TYPE_Line          : m_pLayer = new CSG_Map_Shapes_Line   (Layer.asShapes    ()); return( true );
                case SHAPE_TYPE_Polygon       : m_pLayer = new CSG_Map_Shapes_Polygon(Layer.asShapes    ()); return( true );
 
                default                       : return( false );
                }
 
        default                           : return( false );
        }
}
 
//---------------------------------------------------------
bool CMap_Layer::Destroy(void)
{
        if( m_pLayer )
        {
                delete( m_pLayer );
 
                m_pLayer = NULL;
        }
 
        return( true );
}
 
//---------------------------------------------------------
CSG_Parameters & CMap_Layer::Get_Parameters(void) const
{
        static CSG_Parameters Dummy;
 
        return( m_pLayer ? m_pLayer->Get_Parameters() : Dummy );
}
 
//---------------------------------------------------------
bool CMap_Layer::On_Draw(CSG_Map_DC &dc_Map)
{
        return( m_pLayer && m_pLayer->Parameters_Changed() && m_pLayer->Draw(dc_Map) );
}
 
//---------------------------------------------------------
CSG_String CMap_Layer::Get_Name(void) const
{
        if( m_pLayer && m_pLayer->Get_Object() )
        {
                if( m_pLayer->Get_Object()->asShapes() )
                {
                        return( SG_Get_ShapeType_Name(m_pLayer->Get_Object()->asShapes()->Get_Type()) + ": " + m_pLayer->Get_Object()->Get_Name() );
                }
 
                return( SG_Get_DataObject_Name(m_pLayer->Get_ObjectType()) + ": " + m_pLayer->Get_Object()->Get_Name() );
        }
 
        return( _TL("have no layer") );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CMap_Layer::_Classify_Initialize(const SG_Char *_Field, const SG_Char *_Normalize)
{
        if( m_pLayer && m_pLayer->Get_Object() )
        {
                if( m_pLayer->Get_Object()->asTable(true) )
                {
                        Get_Parameters().Set_Parameter("CLASSIFIED_FIELD"    , _Field    ); int     Field = -1; Get_Parameters()["CLASSIFIED_FIELD"    ].asChoice()->Get_Data(Field    );
                        Get_Parameters().Set_Parameter("CLASSIFIED_NORMALIZE", _Normalize); int Normalize = -1; Get_Parameters()["CLASSIFIED_NORMALIZE"].asChoice()->Get_Data(Normalize);
 
                        return( m_pClassify->Create(m_pLayer->Get_Object()->asTable(true), Field, Normalize) );
                }
                else
                {
                        return( m_pClassify->Create(m_pLayer->Get_Object()) );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CMap_Layer::_Classify_Finalize(int ColorsID)
{
        CSG_Colors Colors(0, ColorsID); if( ColorsID < 0 ) { Colors.Create(*Get_Parameters()["STRETCH_COLORS"].asColors()); }
 
        return( m_pLayer && m_pLayer->Get_Object() && m_pClassify->Set_LUT(*Get_Parameters()["CLASSIFIED_LUT"].asTable(), Colors, 0) && Set_Parameter(SG_T("COLOR_SYMBOLS"), 1) );
}
 
//---------------------------------------------------------
bool CMap_Layer::Classify_Unique   (int maxCount                             , int ColorsID, const SG_Char *Field                          ) { return( _Classify_Initialize(Field, NULL     ) && m_pClassify->Classify_Unique   (maxCount               ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Equal    (int Count, double Minimum, double Maximum, int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Equal    (Count, Minimum, Maximum) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Equal    (int Count                                , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Equal    (Count                  ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Defined  (double Interval, double Offset           , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Defined  (Interval, Offset       ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Defined  (double Interval                          , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Defined  (Interval               ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Quantile (int Count, bool bHistogram               , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Quantile (Count, bHistogram      ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Geometric(int Count, bool bIncreasing              , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Geometric(Count, bIncreasing     ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_Natural  (int Count                                , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_Natural  (Count                  ) && _Classify_Finalize(ColorsID) ); }
bool CMap_Layer::Classify_StdDev   (double StdDev, double StdDev_Max         , int ColorsID, const SG_Char *Field, const SG_Char *Normalize) { return( _Classify_Initialize(Field, Normalize) && m_pClassify->Classify_StdDev   (StdDev, StdDev_Max     ) && _Classify_Finalize(ColorsID) ); }
 
//---------------------------------------------------------
bool CMap_Layer::Draw_Legend(CMap_Canvas &Canvas, int x, int y, double Zoom)
{
        if( m_pLayer && m_pLayer->Get_Object() )
        {
                m_pLayer->Get_Legend()->Draw(*Canvas.m_pDC, Zoom, 1., wxPoint(x, y));
 
                return( true );
        }
 
 
        return( false );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap_Graticule::CMap_Graticule(void)
{
        m_pLayer = new CSG_Map_Graticule();
}
 
//---------------------------------------------------------
CMap_Graticule::CMap_Graticule(const CSG_Projection &Projection)
{
        m_pLayer = new CSG_Map_Graticule();
 
        Create(Projection);
}
 
//---------------------------------------------------------
CMap_Graticule::~CMap_Graticule(void)
{
        delete(m_pLayer);
}
 
//---------------------------------------------------------
bool CMap_Graticule::Create(const CSG_Projection &Projection)
{
        m_Projection = Projection;
 
        return( m_Projection.is_Okay() );
}
 
//---------------------------------------------------------
CSG_Parameters & CMap_Graticule::Get_Parameters(void) const
{
        return( m_pLayer->Get_Parameters() );
}
 
//---------------------------------------------------------
bool CMap_Graticule::On_Draw(CSG_Map_DC &dc_Map)
{
        return( m_pLayer->Parameters_Changed() && m_pLayer->Draw(dc_Map, m_Projection) );
}
 
//---------------------------------------------------------
CSG_String CMap_Graticule::Get_Name(void) const
{
        return( "Graticule" );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CMap_BaseMap::CMap_BaseMap(void)
{
        m_pLayer = new CSG_Map_BaseMap();
}
 
//---------------------------------------------------------
CMap_BaseMap::CMap_BaseMap(const CSG_Projection &Projection)
{
        m_pLayer = new CSG_Map_BaseMap();
 
        Create(Projection);
}
 
//---------------------------------------------------------
CMap_BaseMap::~CMap_BaseMap(void)
{
        delete(m_pLayer);
}
 
//---------------------------------------------------------
bool CMap_BaseMap::Create(const CSG_Projection &Projection)
{
        m_Projection = Projection;
 
        return( m_Projection.is_Okay() );
}
 
//---------------------------------------------------------
CSG_Parameters & CMap_BaseMap::Get_Parameters(void) const
{
        return( m_pLayer->Get_Parameters() );
}
 
//---------------------------------------------------------
bool CMap_BaseMap::On_Draw(CSG_Map_DC &dc_Map)
{
        return( m_pLayer->Parameters_Changed() && m_pLayer->Draw(dc_Map, m_Projection) );
}
 
//---------------------------------------------------------
CSG_String CMap_BaseMap::Get_Name(void) const
{
        return( "Base Map" );
}
 

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