map_dc.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                      map_dc.cpp                       //
//                                                       //
//                 Copyright (C) 2024 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"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_DC::CSG_Map_DC(void)
{
        // nop
}
 
//---------------------------------------------------------
CSG_Map_DC::CSG_Map_DC(const CSG_Rect &rWorld, const wxRect &rDC, double Scale, int Background, bool bAlpha)
{
        Create(rWorld, rDC, Scale, Background, bAlpha);
}
 
//---------------------------------------------------------
CSG_Map_DC::CSG_Map_DC(const CSG_Rect &rWorld, const CSG_Rect_Int &rDC, double Scale, int Background, bool bAlpha)
{
        Create(rWorld, rDC, Scale, Background, bAlpha);
}
 
//---------------------------------------------------------
CSG_Map_DC::~CSG_Map_DC(void)
{
        Destroy();
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_DC::Create(const CSG_Rect &rWorld, const CSG_Rect_Int &rDC, double Scale, int Background, bool bAlpha)
{
        return( Create(rWorld, wxRect(rDC.xMin, rDC.yMin, rDC.Get_XRange(), rDC.Get_YRange()), Scale, Background, bAlpha) );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Create(const CSG_Rect &rWorld, const wxRect &rDC, double Scale, int Background, bool bAlpha)
{
        m_rWorld = rWorld;
        m_rDC    = rDC;
        m_Scale  = Scale;
 
        m_img_nx = m_rDC.GetWidth ();
        m_img_ny = m_rDC.GetHeight(); m_img_nPixels = m_img_nx * m_img_ny;
 
        if( m_img_nx < 1 || m_img_ny < 1 )
        {
                Destroy();
 
                return( false );
        }
 
        //-----------------------------------------------------
        if( m_rWorld.Get_XRange() == 0. || m_rWorld.Get_YRange() == 0. )
        {
                m_rWorld.Inflate(m_rWorld.Get_XRange() ? 0. : 1., m_rWorld.Get_YRange() ? 0. : 1., false);
        }
 
        // ensure cellsize in x-/y-direction are identical...
        double dxdyDC    = (double)m_img_nx / (double)m_img_ny;
        double dxdyWorld = m_rWorld.Get_XRange() / m_rWorld.Get_YRange();
 
        if( dxdyDC > dxdyWorld )
        {
                m_rWorld.Inflate(0.5 * (m_rWorld.Get_YRange() * dxdyDC - m_rWorld.Get_XRange()), 0., false);
        }
        else if( dxdyDC < dxdyWorld )
        {
                m_rWorld.Inflate(0., 0.5 * (m_rWorld.Get_XRange() / dxdyDC - m_rWorld.Get_YRange()), false);
        }
 
        m_World2DC = m_img_nx / m_rWorld.Get_XRange();
        m_DC2World = m_rWorld.Get_XRange() / m_img_nx;
 
        //-----------------------------------------------------
        m_bmp.Create(m_img_nx, m_img_ny);
        m_dc.SelectObject(m_bmp);
        m_dc.SetBackground(wxBrush(Background < 0 ? *wxWHITE : wxColour(SG_GET_R(Background), SG_GET_G(Background), SG_GET_B(Background))));
        m_dc.Clear();
 
        if( (m_img_alpha = bAlpha ? (BYTE *)m_Alpha.Create(sizeof(BYTE), m_img_nPixels) : NULL) != NULL )
        {
                memset(m_img_alpha, 0, m_img_nPixels);
        }
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Destroy(void)
{
        m_img.Destroy(); m_img_rgb = NULL; m_img_alpha = NULL; m_img_nx = 0; m_img_nPixels = 0;
 
        m_Alpha.Destroy();
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
int CSG_Map_DC::Get_Background(void) const
{
        return( SG_Get_Color(m_dc.GetBackground().GetColour()) );
}
 
//---------------------------------------------------------
wxBitmap CSG_Map_DC::Get_Bitmap(void)
{
        wxBitmap Bitmap; Get_Bitmap(Bitmap); return( Bitmap );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Get_Bitmap(wxBitmap &Bitmap)
{
        if( m_bmp.IsOk() )
        {
                if( m_img_alpha )
                {
                        wxImage Image;
 
                        if( Get_Image(Image) )
                        {
                                Bitmap = wxBitmap(Image);
 
                                return( true );
                        }
                }
                else
                {
                        m_dc.SelectObject(wxNullBitmap);
 
                        Bitmap = m_bmp;
 
                        m_dc.SelectObject(m_bmp);
 
                        return( true );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Get_Image(wxImage &Image)
{
        if( m_bmp.IsOk() )
        {
                m_dc.SelectObject(wxNullBitmap);
 
                Image = m_bmp.ConvertToImage();
 
                if( m_img_alpha )
                {
                        if( Image.HasAlpha() == false )
                        {
                                Image.SetAlpha();
                        }
 
                        #pragma omp parallel for
                        for(int y=0; y<m_img_ny; y++)
                        {
                                for(int x=0, i=y*m_img_nx; x<m_img_nx; x++, i++)
                                {
                                        Image.SetAlpha(x, y, m_img_alpha[i]);
                                }
                        }
                }
 
                m_dc.SelectObject(m_bmp);
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Get_Image(CSG_Grid &Map)
{
        wxImage Image;
 
        if( Get_Image(Image) && Map.Create(SG_DATATYPE_Int, Image.GetWidth(), Image.GetHeight(), m_DC2World, m_rWorld.xMin, m_rWorld.yMin) )
        {
                #pragma omp parallel for
                for(int y=0; y<Map.Get_NY(); y++)
                {
                        for(int x=0, yy=Map.Get_NY()-1-y; x<Map.Get_NX(); x++)
                        {
                                BYTE rgb[4] = { Image.GetRed(x, yy), Image.GetGreen(x, yy), Image.GetBlue(x, yy), Image.GetAlpha(x, yy) };
 
                                Map.Set_Value(x, y, *(int *)rgb);
                        }
                }
 
                return( true );
        }
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_DC::Draw_Layer_Begin(void)
{
        m_bmp_layer.Create(m_img_nx, m_img_ny);
        m_dc       .SelectObject(m_bmp_layer);
        m_dc       .SetBackground    (*wxWHITE_BRUSH);
        m_dc       .Clear();
 
        m_bmp_alpha.Create(m_img_nx, m_img_ny);
        m_dc_alpha .SelectObject(m_bmp_alpha);
        m_dc_alpha .SetBrush         (*wxWHITE_BRUSH);
        m_dc_alpha .SetPen           (*wxWHITE_PEN);
        m_dc_alpha .SetTextForeground(*wxWHITE);
        m_dc_alpha .SetBackground    (*wxBLACK_BRUSH);
        m_dc_alpha .Clear();
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Draw_Layer_End(double Transparency)
{
        m_dc.SelectObject(m_bmp); m_dc_alpha.SelectObject(wxNullBitmap);
 
        if( Draw_Image_Begin(Transparency) )
        {
                wxImage img_layer = m_bmp_layer.ConvertToImage(); BYTE *rgb   = img_layer.GetData();
                wxImage img_alpha = m_bmp_alpha.ConvertToImage(); BYTE *alpha = img_alpha.GetData();
 
                #pragma omp parallel for
                for(int i=0; i<m_img_nPixels; i++)
                {
                        if( alpha[i * 3] )
                        {
                                _Draw_Image_Pixel(i, *((int *)(rgb + i * 3)));
                        }
                }
 
                Draw_Image_End();
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
void CSG_Map_DC::Draw_Polygon(CSG_Shape_Polygon *pPolygon)
{
        if( m_World2DC * pPolygon->Get_Extent().Get_XRange() <= 2.
        &&  m_World2DC * pPolygon->Get_Extent().Get_YRange() <= 2. )
        {
                DrawPoint(
                        (int)xWorld2DC(pPolygon->Get_Extent().Get_XCenter()),
                        (int)yWorld2DC(pPolygon->Get_Extent().Get_YCenter())
                );
        }
 
        //-----------------------------------------------------
        else if( pPolygon->Get_Part_Count() == 1 && pPolygon->Get_Point_Count(0) > 2 )
        {
                wxPoint *Points = new wxPoint[pPolygon->Get_Point_Count()];
 
                for(int iPoint=0; iPoint<pPolygon->Get_Point_Count(0); iPoint++)
                {
                        Points[iPoint].x = (int)xWorld2DC(pPolygon->Get_Point(iPoint, 0).x);
                        Points[iPoint].y = (int)yWorld2DC(pPolygon->Get_Point(iPoint, 0).y);
                }
 
                DrawPolygon(pPolygon->Get_Point_Count(), Points);
 
                delete[](Points);
        }
 
        //-----------------------------------------------------
        else if( pPolygon->Get_Part_Count() > 1 )
        {
                wxPoint *Points = new wxPoint[pPolygon->Get_Point_Count()];
                int    *nPoints = new int    [pPolygon->Get_Part_Count ()];
 
                for(int iPart=0, jPoint=0; iPart<pPolygon->Get_Part_Count(); iPart++)
                {
                        nPoints[iPart] = pPolygon->Get_Point_Count(iPart);
 
                        for(int iPoint=0; iPoint<pPolygon->Get_Point_Count(iPart); iPoint++, jPoint++)
                        {
                                Points[jPoint].x = (int)xWorld2DC(pPolygon->Get_Point(iPoint, iPart).x);
                                Points[jPoint].y = (int)yWorld2DC(pPolygon->Get_Point(iPoint, iPart).y);
                        }
                }
 
                DrawPolyPolygon(pPolygon->Get_Part_Count(), nPoints, Points, 0, 0, wxODDEVEN_RULE);
 
                delete[]( Points);
                delete[](nPoints);
        }
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_DC::Draw_Image_Begin(double Transparency, Mode Mode)
{
        if( m_DC2World <= 0. || m_img_nx < 1 || m_img_ny < 1 )
        {
                return( false );
        }
 
        m_Opacity = Transparency < 0. ? 1. : Transparency > 1. ? 0. : 1. - Transparency;
 
        if( m_Opacity <= 0. && (Mode == Mode::Transparent || Mode == Mode::Alpha) )
        {
                return( false );
        }
 
        if( Mode == Mode::Transparent && m_Opacity >= 1. )
        {
                Mode = Mode::Opaque;
        }
 
        m_img_mode = Mode;
 
        //-----------------------------------------------------
        wxMemoryDC copy_dc; wxBitmap copy_bmp(m_img_nx, m_img_ny);
 
        copy_dc.SelectObject(copy_bmp);
        copy_dc.Blit(0, 0, m_img_nx, m_img_ny, &m_dc, 0, 0);
        copy_dc.SelectObject(wxNullBitmap);
 
        if( copy_bmp.IsOk() )
        {
                m_img = copy_bmp.ConvertToImage();
 
                if( m_img.IsOk() )
                {
                        m_img_rgb = m_img.GetData();
 
                        return( true );
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_DC::Draw_Image_End(void)
{
        if( m_img.Ok() )
        {
                m_dc.DrawBitmap(wxBitmap(m_img), 0, 0, true);
 
                m_img.Destroy(); m_img_rgb = NULL;
 
                return( true );
        }
 
        return( false );
}
 
//---------------------------------------------------------
void CSG_Map_DC::Draw_Image_Pixels(int x1, int y1, int x2, int y2, int Color)
{
        if( x1 > x2 ) { double x = x1; x1 = x2; x2 = x; }
        if( y1 > y2 ) { double y = y1; y1 = y2; y2 = y; }
 
        if( y1 < 0        ) { y1 = 0;        }
        if( y2 > m_img_ny ) { y2 = m_img_ny; }
 
        if( x1 < 0        ) { x1 = 0;        }
        if( x2 > m_img_nx ) { x2 = m_img_nx; }
 
        //-----------------------------------------------------
        for(int y=y1; y<y2; y++)
        {
                for(int x=x1, i=y*m_img_nx+x1; x<x2; x++, i++)
                {
                        _Draw_Image_Pixel(i, Color);
                }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_DC::Set_Font(wxFont &Font)
{
        if( Font.Ok() )
        {
                Font.SetPointSize((int)(m_Scale * Font.GetPointSize()));
 
                SetFont(Font);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::SetFont(const wxFont &Font)
{
        m_dc.SetFont(Font);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.SetFont(Font);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::SetPen(const wxPen &Pen)
{
        m_dc.SetPen(Pen);
 
        if( m_dc_alpha.IsOk() )
        {
                wxPen _Pen(Pen); _Pen.SetColour(*wxWHITE);
 
                m_dc_alpha.SetPen(_Pen);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::SetBrush(const wxBrush &Brush)
{
        m_dc.SetBrush(Brush);
 
        if( m_dc_alpha.IsOk() )
        {
                wxBrush _Brush(Brush); _Brush.SetColour(*wxWHITE);
 
                m_dc_alpha.SetBrush(_Brush);
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_DC::DrawPoint(int x, int y)
{
        m_dc.DrawPoint(x, y);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawPoint(x, y);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawLine(int x1, int y1, int x2, int y2)
{
        m_dc.DrawLine(x1, y1, x2, y2);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawLine(x1, y1, x2, y2);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawRectangle(int x, int y, int width, int height)
{
        m_dc.DrawRectangle(x, y, width, height);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawRectangle(x, y, width, height);
        }
}
 
void CSG_Map_DC::DrawRectangle(const wxRect &r)
{
        m_dc.DrawRectangle(r);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawRectangle(r);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawCircle(int x, int y, int radius)
{
        m_dc.DrawCircle(x, y, radius);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawCircle(x, y, radius);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawArc(int xStart, int yStart, int xEnd, int yEnd, int xc, int yc)
{
        m_dc.DrawArc(xStart, yStart, xEnd, yEnd, xc, yc);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawArc(xStart, yStart, xEnd, yEnd, xc, yc);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawPolygon(int n, const wxPoint points[], int xoffset, int yoffset, wxPolygonFillMode fill_style)
{
        m_dc.DrawPolygon(n, points, xoffset, yoffset, fill_style);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawPolygon(n, points, xoffset, yoffset, fill_style);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawPolyPolygon(int n, const int count[], const wxPoint points[], int xoffset, int yoffset, wxPolygonFillMode fill_style)
{
        m_dc.DrawPolyPolygon(n, count, points, xoffset, yoffset, fill_style);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawPolyPolygon(n, count, points, xoffset, yoffset, fill_style);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawBitmap(const wxBitmap &bitmap, int x, int y, bool useAlpha)
{
        m_dc.DrawBitmap(bitmap, x, y, useAlpha);
 
        if( m_dc_alpha.IsOk() )
        {
                m_dc_alpha.DrawBitmap(bitmap, x, y, useAlpha);
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_DC::DrawText(int Align, int x, int y, const wxString &Text)
{
        SG_DC_Draw_Text(m_dc, Align, x, y, Text);
 
        if( m_dc_alpha.IsOk() )
        {
                SG_DC_Draw_Text(m_dc_alpha, Align, x, y, Text);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawText(int Align, int x, int y, double Angle, const wxString &Text)
{
        SG_DC_Draw_Text(m_dc, Align, x, y, Angle, Text);
 
        if( m_dc_alpha.IsOk() )
        {
                SG_DC_Draw_Text(m_dc_alpha, Align, x, y, Angle, Text);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawText(int Align, int x, int y, const wxString &Text, int Effect, wxColour Effect_Color, int Effect_Size)
{
        SG_DC_Draw_Text(m_dc, Align, x, y, Text, Effect, Effect_Color, Effect_Size);
 
        if( m_dc_alpha.IsOk() )
        {
                SG_DC_Draw_Text(m_dc_alpha, Align, x, y, Text, Effect, Effect_Color, Effect_Size);
        }
}
 
//---------------------------------------------------------
void CSG_Map_DC::DrawText(int Align, int x, int y, double Angle, const wxString &Text, int Effect, wxColour Effect_Color, int Effect_Size)
{
        SG_DC_Draw_Text(m_dc, Align, x, y, Angle, Text, Effect, Effect_Color, Effect_Size);
 
        if( m_dc_alpha.IsOk() )
        {
                SG_DC_Draw_Text(m_dc_alpha, Align, x, y, Angle, Text, Effect, Effect_Color, Effect_Size);
        }
}
 

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