map_symbology.h

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                   map_symbology.h                     //
//                                                       //
//                 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                                //
//                                                       //
 
//---------------------------------------------------------
#ifndef _HEADER_INCLUDED__SAGA_API__Map_Symbology_H
#define _HEADER_INCLUDED__SAGA_API__Map_Symbology_H
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#include "../table.h"
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
class SAGA_API_DLL_EXPORT CSG_Map_Symbology
{
public: 
        CSG_Map_Symbology(class CSG_Map_Layer *pLayer);
        virtual ~CSG_Map_Symbology(void);
 
        bool                                                    Update                                    (void);
 
        bool                                                    Set_Mode                                (int Mode);
        int                                                             Get_Mode                                (void) const { return( m_Mode         ); }
 
        bool                                                    Set_NoData_Color                (int Color);
        int                                                             Get_NoData_Color                (void) const { return( m_NoData_Color ); }
 
        bool                                                    Set_Single_Color                (int Color);
        int                                                             Get_Single_Color                (void) const { return( m_Single_Color ); }
 
 
        //---------------------------------------------------------
        enum
        {
                SINGLE = 0,
                CLASSIFIED,
                DISCRETE,
                GRADUATED,
                COMPOSITE,
                RGB
        };
 
        //---------------------------------------------------------
        enum
        {
                LUT_COLOR = 0,
                LUT_TITLE,
                LUT_DESCRIPTION,
                LUT_MIN,
                LUT_MAX
        };
 
        //---------------------------------------------------------
        enum
        {
                SHADE_MODE_DSC_GREY  = 0,
                SHADE_MODE_ASC_GREY,
                SHADE_MODE_DSC_CYAN,
                SHADE_MODE_ASC_CYAN,
                SHADE_MODE_DSC_MAGENTA,
                SHADE_MODE_ASC_MAGENTA,
                SHADE_MODE_DSC_YELLOW,
                SHADE_MODE_ASC_YELLOW
        };
 

 
        //-----------------------------------------------------
        bool                                                    Set_Class_Count                 (int Count);
 
        int                                                             Get_Class_Count                  (void)  const
        {
                switch( m_Mode )
                {
                case SINGLE    : default:
                        return( 1 );
 
                case CLASSIFIED:
                        return( (int)m_pLUT->Get_Count() );
 
                case DISCRETE  :
                        return( m_pColors->Get_Count() );
 
                case GRADUATED :
                case COMPOSITE :
                        return( m_Count );
                }
        }
 
        //-----------------------------------------------------
        int                                                             Get_Class                              (double Value)
        {
                switch( m_Mode )
                {
                case SINGLE    : default:
                        return( 0 );
 
                case CLASSIFIED:
                        return( _LUT_Get_Class(Value) );
 
                case DISCRETE  :
                case GRADUATED :
                case COMPOSITE :
                        return( _METRIC_Get_Class(Value) );
                }
        }
 
        int                                                             Get_Class                              (const CSG_String &Value)
        {
                if( m_Mode == CLASSIFIED )
                {
                        return( _LUT_Get_Class(Value) );
                }
 
                return( Get_Class(Value.asDouble()) );
        }
 
        //-----------------------------------------------------
        double                                                  Get_Class_Value_Minimum (int Class);
        double                                                  Get_Class_Value_Center  (int Class);
        double                                                  Get_Class_Value_Maximum (int Class);
        wxString                                                Get_Class_Name                  (int Class);
        wxString                                                Get_Class_Name_byValue  (double          Value);
        wxString                                                Get_Class_Name_byValue  (const wxString &Value);
 

 
        //-----------------------------------------------------
        CSG_Colors                                            Get_Class_Colors                (void)  const;
 
        //-----------------------------------------------------
        bool                                                    Get_Class_Color                  (int Class, int &Color) const
        {
                switch( m_Mode )
                {
                case SINGLE    : default:
                        Color = m_Single_Color;
                        break;
 
                case CLASSIFIED:
                        if( Class < 0 || Class >= m_pLUT->Get_Count() )
                        {
                                Color = m_NoData_Color;
 
                                return( false );
                        }
 
                        Color = m_pLUT->Get_Record(Class)->asInt(LUT_COLOR);
                        break;
 
 
                case DISCRETE  :
                        Color = m_pColors->Get_Color(Class < 0 ? 0 : Class >= m_pColors->Get_Count() ? m_pColors->Get_Count() - 1 : Class);
                        break;
 
                case GRADUATED :
                case COMPOSITE :
                        Get_Class_Color_byValue(m_Stretch.from_Relative(Class / (double)m_Count), Color);
                        break;
                }
 
                return( true );
        }
 
        //-----------------------------------------------------
        int                                                             Get_Class_Color                  (int Class)     const
        {
                int Color; return( Get_Class_Color(Class, Color) ? Color : 0 );
        }
 
        //-----------------------------------------------------
        bool                                                    Get_Class_Color_byValue  (double Value, int &Color)      const
        {
                switch( m_Mode )
                {
                case SINGLE    : default:
                {
                        return( Get_Class_Color(0, Color) );
                }
 
                case CLASSIFIED:
                {
                        return( Get_Class_Color(_LUT_Get_Class(Value), Color) );
                }
 
                case DISCRETE  :
                {
                        return( Get_Class_Color(_METRIC_Get_Class(Value), Color) );
                }
 
                case GRADUATED :
                {
                        Color = m_pColors->Get_Interpolated(m_Stretch.to_Relative(Value) * (m_pColors->Get_Count() - 1));
 
                        return( true );
                }
 
                case COMPOSITE :
                {
                        int c = (int)(255. * m_Stretch.to_Relative(Value)); if( c < 0 ) { c = 0; } else if( c > 255 ) { c = 255; }
 
                        Color = SG_GET_RGB(c, c, c);
 
                        return( true );
                }
 
                case RGB       :
                {
                        Color = (int)Value;
 
                        return( true );
                }
                }
        }
 
        bool                                                    Get_Class_Color_byValue  (const CSG_String &Value, int &Color) const
        {
                if( m_Mode == CLASSIFIED )
                {
                        return( Get_Class_Color(_LUT_Get_Class(Value), Color) );
                }
 
                return( Get_Class_Color_byValue(Value.asDouble(), Color) );
        }
 
        //-----------------------------------------------------
        int                                                             Get_Class_Color_byValue  (double Value)  const
        {
                int Color; return( Get_Class_Color_byValue(Value, Color) ? Color : 0 );
        }
 
        int                                                             Get_Class_Color_byValue  (const CSG_String &Value)     const
        {
                int Color; return( Get_Class_Color_byValue(Value, Color) ? Color : 0 );
        }
 

 
        //-----------------------------------------------------
        CSG_Colors &                                  Get_Colors                                    (void)               { return( *m_pColors ); }
        const CSG_Colors &                            Get_Colors                                    (void)         const { return( *m_pColors ); }
 
        CSG_Scaler &                                  Get_Stretch                                  (void)               { return( m_Stretch ); }
        const CSG_Scaler &                            Get_Stretch                                  (void)         const { return( m_Stretch ); }
 
        bool                                                    Set_Stretch                                  (double Minimum, double Maximum, int Mode = 0, double LogScale = 1.) { return( m_Stretch.Create(Minimum, Maximum, Mode, LogScale) ); }
 
        double                                                  Get_Stretch_Minimum                  (void)         const { return( m_Stretch.Get_Minimum () ); }
        double                                                  Get_Stretch_Maximum                  (void)         const { return( m_Stretch.Get_Maximum () ); }
        double                                                  Get_Stretch_Range                      (void)         const { return( m_Stretch.Get_Range   () ); }
        int                                                             Get_Stretch_Mode                        (void)         const { return( m_Stretch.Get_Mode    () ); }
        double                                                  Get_Stretch_LogScale                (void)         const { return( m_Stretch.Get_LogScale() ); }
 
        double                                                  Get_Stretch_to_Relative          (double Value) const { return( m_Stretch.  to_Relative(Value) ); }
        double                                                  Get_Stretch_from_Relative      (double Value) const { return( m_Stretch.from_Relative(Value) ); }
 

 
        //-----------------------------------------------------
        bool                                                    Histogram_Update                (void);
 
        const CSG_Histogram &                      Histogram_Get                      (void)  const   {       return( m_Histogram );       }
 
        const CSG_Simple_Statistics &      Statistics_Get                    (void)  const   {       return( m_Statistics );     }
 
 
protected: 
 
        int                                                             m_Mode, m_Count, m_Single_Color, m_NoData_Color;
 
        CSG_Scaler                                            m_Stretch;
 
        CSG_Histogram                                      m_Histogram;
 
        CSG_Simple_Statistics                      m_Statistics;
 
        CSG_Colors                                            *m_pColors = NULL;
 
        CSG_Table                                              *m_pLUT    = NULL;
 
        class CSG_Map_Layer                                *m_pLayer  = NULL;
 
 
        //-----------------------------------------------------
        int                                                             _LUT_Cmp_Class                    (double            Value, int Class)    const;
        int                                                             _LUT_Get_Class                    (double            Value           )    const;
 
        int                                                             _LUT_Cmp_Class                    (const CSG_String &Value, int Class)  const;
        int                                                             _LUT_Get_Class                    (const CSG_String &Value           )  const;
 
        int                                                             _METRIC_Get_Class              (double Value)  const
        {
                if( Value < m_Stretch.Get_Minimum() )
                {
                        return( -1 );
                }
 
                if( Value > m_Stretch.Get_Maximum() )
                {
                        return( Get_Class_Count() );
                }
 
                int Class = (int)(m_Stretch.to_Relative(Value) * Get_Class_Count());
 
                return( Class < 0 ? 0 : Class < Get_Class_Count() ? Class : Get_Class_Count() - 1 );
        }
 
 
        //-----------------------------------------------------
        bool                                                    _Histogram_Update               (CSG_Data_Object *pObject);
        bool                                                    _Histogram_Update               (CSG_Table *pTable, int Field, int Normalize = -1, double Scale = 1.);
 
};
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#endif // #ifndef _HEADER_INCLUDED__SAGA_API__Map_Symbology_H