map_pointcloud.cpp

Go to the documentation of this file.

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

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_PointCloud::CSG_Map_PointCloud(CSG_PointCloud *pPointCloud)
        : CSG_Map_Layer(SG_DATAOBJECT_TYPE_PointCloud)
{
        Add_Parameters(m_Parameters);
 
        Set_Object(pPointCloud);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_PointCloud::Add_Parameters(CSG_Parameters &Parameters)
{
        CSG_Map_Layer::Add_Parameters(Parameters);
 
        //-----------------------------------------------------
        // Values...
 
        Parameters.Add_Choice("NODE_VALUES", "AGGREGATION", _TL("Aggregation"), _TL(""), CSG_String::Format("%s|%s|%s|%s",
                _TL("first"  ),
                _TL("last"   ),
                _TL("lowest" ),
                _TL("highest")), 3
        );
 
        //-----------------------------------------------------
        // Display...
 
        Parameters.Add_Int("NODE_DISPLAY",
                "DISPLAY_SIZE"           , _TL("Point Size"),
                _TL("Point radius size as number of pixels."),
                1, 1, true, 10, true
        );
 
        //-----------------------------------------------------
        // Colors...
 
        Parameters.Add_Node  ("NODE_COLORS", "NODE_RGB" , _TL("RGB"  ), _TL(""));
        Parameters.Add_Choice("NODE_RGB"   , "RGB_FIELD", _TL("Field"), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
 
        //-----------------------------------------------------
        // LUT
 
        CSG_Table &LUT = *m_Parameters["CLASSIFIED_LUT"].asTable(); LUT.Del_Records();
 
        LUT.Set_Field_Type(CSG_Map_Symbology::LUT_MIN, SG_DATATYPE_String);
        LUT.Set_Field_Type(CSG_Map_Symbology::LUT_MAX, SG_DATATYPE_String);
 
        #define ADD_CLASS(color, name, value) { CSG_Table_Record &r = *LUT.Add_Record(); r.Set_Value(0, color); r.Set_Value(1, name); r.Set_Value(3, value); r.Set_Value(4, value); }
 
        ADD_CLASS(12632256, "Created, Never Classified"   ,  0);
        ADD_CLASS( 8421504, "Unclassified"                ,  1);
        ADD_CLASS( 4227327, "Ground"                      ,  2);
        ADD_CLASS(   65408, "Low Vegetation"              ,  3);
        ADD_CLASS(   54528, "Medium Vegetation"           ,  4);
        ADD_CLASS(   32768, "High Vegetation"             ,  5);
        ADD_CLASS(     255, "Building"                    ,  6);
        ADD_CLASS(   16512, "Low Point (Noise)"           ,  7);
        ADD_CLASS(16711808, "Model Key-Point (Mass Point)",  8);
        ADD_CLASS(16711680, "Water"                       ,  9);
        ADD_CLASS(16711935, "Overlap Points"              , 12);
 
        //-----------------------------------------------------
        if( m_pObject )
        {
                DataObject_Changed(); // update attribute choice lists
 
                m_Parameters["STRETCH_FIELD"].Set_Value(2); // z attribute
 
                Parameter_Changed(m_Parameters, m_Parameters["STRETCH_FIELD"], PARAMETER_CHECK_ALL);
        }
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_PointCloud::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        if( Flags & PARAMETER_CHECK_VALUES )
        {
                // nop
        }
 
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_ENABLE )
        {
                // nop
        }
 
        //-----------------------------------------------------
        return( CSG_Map_Layer::Parameter_Changed(Parameters, Parameter, Flags) );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_PointCloud::DataObject_Changed(void)
{
        CSG_Map_Layer::DataObject_Changed();
 
        //-----------------------------------------------------
        Set_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ], false, false);
        Set_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"   ],  true,  true);
        Set_Fields_Choice(m_Parameters["STRETCH_FIELD" ],  true, false);
        Set_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"],  true,  true);
        Set_Fields_Choice(m_Parameters["RGB_FIELD"    ],  true, false);
 
        //-----------------------------------------------------
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_PointCloud::Parameters_Changed(void)
{
        CSG_Map_Layer::Parameters_Changed();
 
        //-----------------------------------------------------
        switch( m_Parameters["COLOR_SYMBOLS"].asInt() )
        {
        default: // CSG_Map_Symbology::SINGLE
                m_Stretch.Value  = -1;
                break;
 
        case  1: // CSG_Map_Symbology::CLASSIFIED
                m_Stretch.Value  = Get_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ]);
                m_Stretch.Normal = Get_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"]);
                m_Stretch.Scale  = 1.;
                break;
 
        case  2: // CSG_Map_Symbology::DISCRETE
        case  3: // CSG_Map_Symbology::GRADUATED
                m_Stretch.Value  = Get_Fields_Choice(m_Parameters["STRETCH_FIELD"    ]);
                m_Stretch.Normal = Get_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"]);
                m_Stretch.Scale  = m_Parameters("STRETCH_NORMALIZE_FORMAT")->asInt() == 0 ? 1. : 100.;
                break;
 
        case  4: // CSG_Map_Symbology::RGB
                m_Stretch.Value  = Get_Fields_Choice(m_Parameters["RGB_FIELD"]);
                m_Stretch.Normal = -1; m_pSymbology->Set_Mode(CSG_Map_Symbology::RGB);
                break;
        }
 
        if( m_Stretch.Value < 0 )
        {
                m_pSymbology->Set_Mode(CSG_Map_Symbology::SINGLE);
        }
 
        //-----------------------------------------------------
        long Color    = m_Parameters["SINGLE_COLOR"].asColor();
        m_Color_Pen   = wxColour(SG_GET_R(Color), SG_GET_G(Color), SG_GET_B(Color));
 
        m_PointSize   = m_Parameters["DISPLAY_SIZE"].asInt() - 1;
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_PointCloud::asImage(CSG_Grid *pImage)
{
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_PointCloud::On_Draw(CSG_Map_DC &dc_Map, int Flags)
{
        if( m_pObject == NULL || Get_Extent().Intersects(dc_Map.rWorld()) == INTERSECTION_None )
        {
                return;
        }
 
        //-----------------------------------------------------
        if( (Flags & LAYER_DRAW_FLAG_THUMBNAIL) != 0 )
        {
                _Draw_Thumbnail(dc_Map);
 
                return;
        }
 
        //-----------------------------------------------------
        if( dc_Map.Draw_Image_Begin(m_Parameters("TRANSPARENCY")->asDouble() / 100.) )
        {
                _Draw_Points(dc_Map, (Flags & LAYER_DRAW_FLAG_NOEDITS) != 0);
 
                dc_Map.Draw_Image_End();
        }
}
 

//                                                       //
 
//---------------------------------------------------------
inline void CSG_Map_PointCloud::_Draw_Pixel(CSG_Map_DC &dc_Map, int x, int y, double z, int Color)
{
        if( !m_Z.is_Valid() ) // if( m_Aggregation == 1 ) // last value
        {
                dc_Map.Draw_Image_Pixel(x, y, Color);
        }
        else if( m_Z.is_InGrid(x, y) )
        {
                switch( m_Aggregation )
                {
                case 0: // first value
                        if( m_N.asInt(x, y) == 0 )
                        {
                                dc_Map.Draw_Image_Pixel(x, y, Color);
                        }
                        break;
 
                case 2: // lowest z
                        if( m_N.asInt(x, y) == 0 || z < m_Z.asDouble(x, y) )
                        {
                                dc_Map.Draw_Image_Pixel(x, y, Color); m_Z.Set_Value(x, y, z);
                        }
                        break;
 
                case 3: // highest z
                        if( m_N.asInt(x, y) == 0 || z > m_Z.asDouble(x, y) )
                        {
                                dc_Map.Draw_Image_Pixel(x, y, Color); m_Z.Set_Value(x, y, z);
                        }
                        break;
                }
 
                m_N.Add_Value(x, y, 1);
        }
}
 
//---------------------------------------------------------
void CSG_Map_PointCloud::_Draw_Symbol(CSG_Map_DC &dc_Map, const CSG_Point_3D &Point, int Color)
{
        int x = (int)dc_Map.xWorld2DC(Point.x) - m_Symbol.Get_NX() / 2;
        int y = (int)dc_Map.yWorld2DC(Point.y) - m_Symbol.Get_NY() / 2;
 
        for(int iy=0; iy<m_Symbol.Get_NY(); iy++) for(int ix=0; ix<m_Symbol.Get_NX(); ix++)
        {
                if( m_Symbol.asByte(ix, iy) )
                {
                        _Draw_Pixel(dc_Map, x + ix, y + iy, Point.z, Color);
                }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_PointCloud::_Draw_Points(CSG_Map_DC &dc_Map, bool bSkipSelection)
{
        m_Aggregation = m_Parameters("AGGREGATION")->asInt();
 
        if( m_Aggregation != 1 )
        {
                m_Z.Create(SG_DATATYPE_Double, dc_Map.rDC().GetWidth(), dc_Map.rDC().GetHeight());
                m_N.Create(SG_DATATYPE_Int   , dc_Map.rDC().GetWidth(), dc_Map.rDC().GetHeight());
        }
 
        //-----------------------------------------------------
        m_Symbol.Create(SG_DATATYPE_Byte, 1 + 2 * m_PointSize, 1 + 2 * m_PointSize);
 
        for(int iy=0, dy=-m_PointSize; iy<m_Symbol.Get_NY(); iy++, dy++) for(int ix=0, dx=-m_PointSize; ix<m_Symbol.Get_NX(); ix++, dx++)
        {
                m_Symbol.Set_Value(ix, iy, sqrt(dx*dx + dy*dy) <= m_PointSize ? 1 : 0);
        }
 
        //-----------------------------------------------------
        CSG_PointCloud *pPoints = m_pObject->asPointCloud(); bool bNumeric = SG_Data_Type_is_Numeric(pPoints->Get_Field_Type(m_Stretch.Value));
 
        #pragma omp parallel for
        for(sLong i=0; i<pPoints->Get_Count(); i++)
        {
                if( bSkipSelection && pPoints->is_Selected(i) )
                {
                        continue;
                }
 
                if( m_Stretch.Value >= 0 && (pPoints->is_NoData(i, m_Stretch.Value) || (m_Stretch.Normal >= 0 && (pPoints->is_NoData(i, m_Stretch.Normal) || !pPoints->Get_Value(i, m_Stretch.Normal)))) )
                {
                        continue;
                }
 
                TSG_Point_3D Point = pPoints->Get_Point(i);
 
                if( dc_Map.rWorld().Contains(Point.x, Point.y) == false )
                {
                        continue;
                }
 
                //-----------------------------------------------------
                // int x = (int)dc_Map.xWorld2DC(Point.x);
                // int y = (int)dc_Map.yWorld2DC(Point.y);
 
                if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::CLASSIFIED && !bNumeric ) // string
                {
                        int Color; CSG_String Value;
 
                        if( pPoints->Get_Value(i, m_Stretch.Value, Value) && m_pSymbology->Get_Class_Color_byValue(Value, Color) )
                        {
                                _Draw_Symbol(dc_Map, Point, Color);
                        }
                }
                else // number
                {
                        int Color; double Value = pPoints->Get_Value(i, m_Stretch.Value); if( m_Stretch.Normal >= 0 ) { Value *= m_Stretch.Normal / pPoints->Get_Value(i, m_Stretch.Normal); }
                                                
                        if( m_pSymbology->Get_Class_Color_byValue(Value, Color) )
                        {
                                _Draw_Symbol(dc_Map, Point, Color);
                        }
                }
        }
 
        //-----------------------------------------------------
        m_Z.Destroy();
        m_N.Destroy();
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_PointCloud::_Draw_Thumbnail(CSG_Map_DC &dc_Map)
{
        if( dc_Map.Draw_Image_Begin(0.) )
        {
                CSG_PointCloud *pPoints = m_pObject->asPointCloud();
 
                sLong n = 1 + (sLong)(pPoints->Get_Count() / (2 * dc_Map.rDC().GetWidth() * dc_Map.rDC().GetHeight()));
 
        //      #pragma omp parallel for
                for(sLong i=0; i<pPoints->Get_Count(); i+=n)
                {
                        if( m_Stretch.Value < 0 || (!pPoints->is_NoData(i, m_Stretch.Value) && (m_Stretch.Normal < 0 || (!pPoints->is_NoData(i, m_Stretch.Normal) && pPoints->Get_Value(i, m_Stretch.Normal) != 0.))) )
                        {
                                TSG_Point_3D Point = pPoints->Get_Point(i);
 
                                int x = (int)dc_Map.xWorld2DC(Point.x);
                                int y = (int)dc_Map.yWorld2DC(Point.y);
 
                                int Color; double Value = pPoints->Get_Value(i, m_Stretch.Value); if( m_Stretch.Normal >= 0 ) { Value *= m_Stretch.Scale / pPoints->Get_Value(i, m_Stretch.Normal); }
 
                                if( m_pSymbology->Get_Class_Color_byValue(Value, Color) )
                                {
                                        dc_Map.Draw_Image_Pixel(x, y, Color);
                                }
                        }
                }
 
                dc_Map.Draw_Image_End();
        }
}
 

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