map_layer.cpp

Go to the documentation of this file.

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

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Parameters & CSG_Map_Layer::Get_Defaults(void)
{
        static CSG_Parameters Parameters;
 
        if( Parameters.Get_Count() == 0 )
        {
                Parameters.Set_Name("Layer Setting Defaults");
 
                Parameters.Add_Choice("", "STRETCH"             , _TL("Stretch"           ), _TL(""), CSG_String::Format("%s|%s|%s", _TL("Linear"), _TL("Standard Deviation"), _TL("Percent Clip")), 1);
                Parameters.Add_Range ("", "STRETCH_LINEAR"      , _TL("Linear"            ), _TL(""), 0., 100., 0., true, 100., true);
                Parameters.Add_Double("", "STRETCH_STDDEV"      , _TL("Standard Deviation"), _TL(""), 2., 0., true);
                Parameters.Add_Bool  ("", "STRETCH_STDDEV_RANGE", _TL("Keep in Range"     ), _TL(""), true);
                Parameters.Add_Range ("", "STRETCH_PERCENT"     , _TL("Percent Clip"      ), _TL(""), 1., 99., 0., true, 100., true);
                Parameters.Add_Choice("", "STRETCH_INVALID"     , _TL("Invalid Range"     ), _TL(""), CSG_String::Format("%s|%s|%s", _TL("ignore"), _TL("ask what to do"), _TL("adjust to full range")), 2);
        }
 
        return( Parameters );
}
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
#define CLASSIFY_UNIQUE    0
#define CLASSIFY_EQUAL     1
#define CLASSIFY_DEFINED   2
#define CLASSIFY_QUANTILE  3
#define CLASSIFY_GEOMETRIC 4
#define CLASSIFY_NATURAL   5
#define CLASSIFY_STDDEV    6
#define CLASSIFY_MANUAL    7
 
//---------------------------------------------------------
#define DEF_LAYER_COLOUR_COUNT  10
 
static int      s_Def_Layer_Colours[DEF_LAYER_COLOUR_COUNT]    =
{
        SG_COLOR_BLUE,
        SG_COLOR_GREEN,
        SG_COLOR_RED,
        SG_COLOR_YELLOW_DARK,
        SG_COLOR_BLUE_DARK,
        SG_COLOR_GREEN_DARK,
        SG_COLOR_RED_DARK,
        SG_COLOR_BLUE_GREEN,
        SG_COLOR_PURPLE,
        SG_COLOR_PINK
};
 

//                                                       //
//                                                       //
//                                                       //
 
//---------------------------------------------------------
CSG_Map_Layer::CSG_Map_Layer(TSG_Data_Object_Type Type)
{
        m_Type       = Type;
        m_pObject    = NULL;
 
        m_pSymbology = new CSG_Map_Symbology(this);
        m_pLegend    = new CSG_Map_Legend   (this);
 
        m_pThumbnail = new wxBitmap();
 
        m_Parameters.Set_Name(SG_Get_DataObject_Name(m_Type));
}
 
//---------------------------------------------------------
CSG_Map_Layer::~CSG_Map_Layer(void)
{
        if( m_pSymbology ) { delete(m_pSymbology); }
        if( m_pLegend    ) { delete(m_pLegend   ); }
 
        if( m_pThumbnail ) { delete(m_pThumbnail); }
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Object(CSG_Data_Object *pObject)
{
        if( pObject && pObject->Get_ObjectType() != m_Type )
        {
                return( false );
        }
 
        if( m_pObject != pObject )
        {
                m_pObject = pObject;
 
                if( m_pObject )
                {
                        m_pSymbology->Update();
 
                        if( m_Parameters["STRETCH"].asInt() == 3 && Get_Stretch_Range() == 0. )
                        {
                                m_Parameters["STRETCH"].Set_Value(1);
                        }
                }
 
                DataObject_Changed();
        }
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Add_Parameters(CSG_Parameters &Parameters)
{
        //-----------------------------------------------------
        // Nodes...
 
        if( !Parameters("NODE_DISPLAY") ) { Parameters.Add_Node("", "NODE_DISPLAY", _TL("Display"  ), _TL("")      ); }
        if( !Parameters("NODE_LEGEND" ) ) { Parameters.Add_Node("", "NODE_LEGEND" , _TL("Legend"   ), _TL(""), true); }
        if( !Parameters("NODE_DISPLAY") ) { Parameters.Add_Node("", "NODE_DISPLAY", _TL("Display"  ), _TL("")      ); }
        if( !Parameters("NODE_COLORS" ) ) { Parameters.Add_Node("", "NODE_COLORS" , _TL("Colors"   ), _TL("")      ); }
        if( !Parameters("NODE_SIZE"   ) ) { Parameters.Add_Node("", "NODE_SIZE"   , _TL("Size"     ), _TL("")      ); }
        if( !Parameters("NODE_LABEL"  ) ) { Parameters.Add_Node("", "NODE_LABEL"  , _TL("Labels"   ), _TL("")      ); }
        if( !Parameters("NODE_CHART"  ) ) { Parameters.Add_Node("", "NODE_CHART"  , _TL("Charts"   ), _TL("")      ); }
 
        //-----------------------------------------------------
        // Values...
 
        if( m_Type == SG_DATAOBJECT_TYPE_Shapes
        ||  m_Type == SG_DATAOBJECT_TYPE_PointCloud
        ||  m_Type == SG_DATAOBJECT_TYPE_TIN )
        {
                Parameters.Add_Choice("NODE_VALUES",
                        "TABLE_FLT_STYLE"   , _TL("Floating Point Numbers"),
                        _TL("Specify floating point decimal precision in table and similar views."),
                        CSG_String::Format("%s|%s|%s",
                                _TL("system default"),
                                _TL("compact"),
                                _TL("fix number of decimals")
                        ), 1
                );
 
                Parameters.Add_Int("TABLE_FLT_STYLE",
                        "TABLE_FLT_DECIMALS", _TL("Decimals"),
                        _TL(""),
                        6, 0, true
                );
        }
 
        //-----------------------------------------------------
        // Legend...
 
        Parameters.Add_Bool  ("NODE_LEGEND" , "LEGEND_SHOW"       , _TL("Map Legends" ), _TL("Include in map legends."), true);
        Parameters.Add_Choice("NODE_LEGEND" , "LEGEND_ORIENTATION", _TL("Orientation" ), _TL(""), CSG_String::Format("%s|%s", _TL("vertical"), _TL("horizontal")), 0);
        Parameters.Add_Choice("NODE_LEGEND" , "LEGEND_TITLE"      , _TL("Title"       ), _TL(""), CSG_String::Format("%s|%s|%s", _TL("data set"), _TL("user defined"), _TL("none")), 0);
        Parameters.Add_String("LEGEND_TITLE", "LEGEND_TITLE_TEXT" , _TL("User Defined"), _TL(""), _TL("Title"));
 
        if( m_Type == SG_DATAOBJECT_TYPE_Shapes
        ||  m_Type == SG_DATAOBJECT_TYPE_PointCloud
        ||  m_Type == SG_DATAOBJECT_TYPE_TIN )
        {
                Parameters.Add_Choice("NODE_LEGEND" , "LEGEND_FIELD"     , _TL("Field Labeling"), _TL(""), CSG_String::Format("%s|%s|%s", _TL("automatic"), _TL("user defined"), _TL("none")), 0);
                Parameters.Add_String("LEGEND_FIELD", "LEGEND_FIELD_TEXT", _TL("User Defined"  ), _TL(""), _TL("Label"));
        }
 
        //-----------------------------------------------------
        // Display...
 
        Parameters.Add_Bool  ("NODE_DISPLAY", "SHOW_ALWAYS", _TL("Show at all scales"), _TL(""), true);
        Parameters.Add_Range ("SHOW_ALWAYS" , "SHOW_RANGE" , _TL("Scale Range"),
                _TL("only show within scale range; values are given as extent measured in map units"),
                100., 1000., 0., true
        );
 
        if( m_Type == SG_DATAOBJECT_TYPE_Grid )
        {
                Parameters.Add_Choice("NODE_DISPLAY", "TRANSPARENCY_MODE", _TL("Overlay Mode"), _TL(""), CSG_String::Format("%s/%s|%s", _TL("Transparency"), _TL("Opacity"), _TL("Hachure")));
        }
 
        Parameters.Add_Double(Parameters("TRANSPARENCY_MODE") ? "TRANSPARENCY_MODE" : "NODE_DISPLAY",
                "TRANSPARENCY", _TL("Transparency"),
                _TL("Transparency specified as percentage."),
                0., 0., true, 100., true
        )->Set_Collapsed();
 
        //-----------------------------------------------------
        // Symbology...
 
        if( m_Type == SG_DATAOBJECT_TYPE_Shapes
        ||  m_Type == SG_DATAOBJECT_TYPE_TIN )
        {
                Parameters.Add_Choice("NODE_COLORS", "COLOR_SYMBOLS", _TL("Type"), _TL(""), CSG_String::Format("%s|%s|%s|%s",
                        _TL("Single Symbol"   ), // CSG_Map_Symbology::SINGLE
                        _TL("Classification"  ), // CSG_Map_Symbology::CLASSIFIED
                        _TL("Discrete Colors" ), // CSG_Map_Symbology::DISCRETE
                        _TL("Graduated Colors")  // CSG_Map_Symbology::GRADUATED
                ), CSG_Map_Symbology::SINGLE);
        }
        else if( m_Type == SG_DATAOBJECT_TYPE_PointCloud )
        {
                Parameters.Add_Choice("NODE_COLORS", "COLOR_SYMBOLS", _TL("Type"), _TL(""), CSG_String::Format("%s|%s|%s|%s|%s",
                        _TL("Single Symbol"   ), // CSG_Map_Symbology::SINGLE
                        _TL("Classification"  ), // CSG_Map_Symbology::CLASSIFIED
                        _TL("Discrete Colors" ), // CSG_Map_Symbology::DISCRETE
                        _TL("Graduated Colors"), // CSG_Map_Symbology::GRADUATED
                        _TL("RGB Coded Values")  // CSG_Map_Symbology::COMPOSITE >> RGB !!!
                ), CSG_Map_Symbology::GRADUATED);
        }
        else if( m_Type == SG_DATAOBJECT_TYPE_Grid )
        {
                Parameters.Add_Choice("NODE_COLORS", "COLOR_SYMBOLS", _TL("Type"), _TL(""), CSG_String::Format("%s|%s|%s|%s|%s|%s",
                        _TL("Single Symbol"   ), // CSG_Map_Symbology::SINGLE
                        _TL("Classification"  ), // CSG_Map_Symbology::CLASSIFIED
                        _TL("Discrete Colors" ), // CSG_Map_Symbology::DISCRETE
                        _TL("Graduated Colors"), // CSG_Map_Symbology::GRADUATED
                        _TL("RGB Composite"   ), // CSG_Map_Symbology::COMPOSITE
                        _TL("RGB Coded Values")  // CSG_Map_Symbology::RGB
                ), CSG_Map_Symbology::GRADUATED);
        }
        else if( m_Type == SG_DATAOBJECT_TYPE_Grids )
        {
                Parameters.Add_Choice("NODE_COLORS", "COLOR_SYMBOLS", _TL("Type"), _TL(""), CSG_String::Format("%s|%s|%s|%s|%s",
                        _TL("Single Symbol"   ), // CSG_Map_Symbology::SINGLE
                        _TL("Classification"  ), // CSG_Map_Symbology::CLASSIFIED
                        _TL("Discrete Colors" ), // CSG_Map_Symbology::DISCRETE
                        _TL("Graduated Colors"), // CSG_Map_Symbology::GRADUATED
                        _TL("RGB Composite"   )  // CSG_Map_Symbology::COMPOSITE
                ), CSG_Map_Symbology::COMPOSITE);
 
                Parameters.Add_Choice("NODE_COLORS", "BAND"         , _TL("Band"      ), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
                Parameters.Add_Choice("NODE_COLORS", "COMPOSITE_FIT", _TL("Statistics"), _TL(""), CSG_String::Format("%s|%s", _TL("all bands"), _TL("each band")), 1);
                Parameters.Add_Choice("NODE_COLORS", "COMPOSITE_R"  , _TL("Red"       ), _TL(""), "");
                Parameters.Add_Choice("NODE_COLORS", "COMPOSITE_G"  , _TL("Green"     ), _TL(""), "");
                Parameters.Add_Choice("NODE_COLORS", "COMPOSITE_B"  , _TL("Blue"      ), _TL(""), "");
        }
 
        //-----------------------------------------------------
        // Symbology: Single Symbol...
 
        static BYTE s_Def_Layer_Colour = 0;
 
        Parameters.Add_Node("NODE_COLORS",
                "NODE_SINGLE"   , _TL("Single Symbol"),
                _TL("")
        );
 
        Parameters.Add_Color("NODE_SINGLE",
                "SINGLE_COLOR"  , _TL("Color"),
                _TL(""),
                s_Def_Layer_Colours[s_Def_Layer_Colour++ % DEF_LAYER_COLOUR_COUNT]
        );
 
        //-----------------------------------------------------
        // Symbology: Classified...
 
        Parameters.Add_Node("NODE_COLORS", "NODE_CLASSIFIED", _TL("Classification"), _TL(""));
 
        if( m_Type == SG_DATAOBJECT_TYPE_Shapes
        ||  m_Type == SG_DATAOBJECT_TYPE_PointCloud
        ||  m_Type == SG_DATAOBJECT_TYPE_TIN )
        {
                Parameters.Add_Choice("NODE_CLASSIFIED", "CLASSIFIED_FIELD"    , _TL("Field"        ), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
                Parameters.Add_Choice("NODE_CLASSIFIED", "CLASSIFIED_NORMALIZE", _TL("Normalization"), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
        }
 
        CSG_Table *pLUT = Parameters.Add_FixedTable("NODE_CLASSIFIED", "CLASSIFIED_LUT", _TL("Look-up Table"), _TL(""))->asTable();
 
        pLUT->Get_MetaData().Add_Child("SAGA_GUI_LUT_TYPE", m_Type);
 
        pLUT->Add_Field(_TL("Color"      ), SG_DATATYPE_Color ); // CSG_Map_Symbology::LUT_COLOR
        pLUT->Add_Field(_TL("Name"       ), SG_DATATYPE_String); // CSG_Map_Symbology::LUT_TITLE
        pLUT->Add_Field(_TL("Description"), SG_DATATYPE_String); // CSG_Map_Symbology::LUT_DESCRIPTION
        pLUT->Add_Field(_TL("Minimum"    ), SG_DATATYPE_Double); // CSG_Map_Symbology::LUT_MIN
        pLUT->Add_Field(_TL("Maximum"    ), SG_DATATYPE_Double); // CSG_Map_Symbology::LUT_MAX
 
        #define ADD_LUT_CLASS(name, desc, min, max) { CSG_Table_Record &r = *pLUT->Add_Record();\
                r.Set_Value(0, SG_Color_Get_Random()); r.Set_Value(1, name); r.Set_Value(2, desc); r.Set_Value(3, min); r.Set_Value(4, max);\
        }
 
        ADD_LUT_CLASS(_TL("Class 1"), _TL( "First Class"), 0., 1.);
        ADD_LUT_CLASS(_TL("Class 2"), _TL("Second Class"), 1., 2.);
 
        #undef ADD_LUT_CLASS
 
        if( m_Type == SG_DATAOBJECT_TYPE_Grid
        ||  m_Type == SG_DATAOBJECT_TYPE_Grids )
        {
                Parameters.Add_Grid_Resampling("NODE_CLASSIFIED", "CLASSIFIED_RESAMPLING", _TL("Resampling"), _TL(""), CSG_Grid_Resampling::Interpolations, CSG_Grid_Resampling::NearestNeighbour);
        }
 
        //-----------------------------------------------------
        // Symbology: Stretched...
 
        Parameters.Add_Node("NODE_COLORS",
                "NODE_STRETCH", _TL("Histogram Stretch"),
                _TL("")
        );
 
        if( m_Type == SG_DATAOBJECT_TYPE_Shapes
        ||  m_Type == SG_DATAOBJECT_TYPE_PointCloud
        ||  m_Type == SG_DATAOBJECT_TYPE_TIN )
        {
                Parameters.Add_Choice("NODE_STRETCH", "STRETCH_FIELD"    , _TL("Field"        ), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
                Parameters.Add_Choice("NODE_STRETCH", "STRETCH_NORMALIZE", _TL("Normalization"), _TL(""), CSG_String::Format("<%s>", _TL("not set")));
 
                Parameters.Add_Choice("STRETCH_NORMALIZE", "STRETCH_NORMALIZE_FORMAT", _TL("Labeling"), _TL(""),
                        CSG_String::Format("%s|%s", _TL("fraction"), _TL("percentage")), 0
                );
        }
 
        if( m_Type == SG_DATAOBJECT_TYPE_Grids )
        {
                Parameters.Add_Range("NODE_STRETCH", "STRETCH_RANGE_R", _TL("Red"  ), _TL(""));
                Parameters.Add_Range("NODE_STRETCH", "STRETCH_RANGE_G", _TL("Green"), _TL(""));
                Parameters.Add_Range("NODE_STRETCH", "STRETCH_RANGE_B", _TL("Blue" ), _TL(""));
        }
 
        //-----------------------------------------------------
        Parameters.Add_Colors("NODE_STRETCH",
                "STRETCH_COLORS"       , _TL("Colors"),
                _TL("")
        );
 
        //-----------------------------------------------------
        Parameters.Add_Choice("NODE_STRETCH",
                "STRETCH"              , _TL("Stretch Type"),
                _TL("Specify how to adjust histogram stretch."),
                CSG_String::Format("%s|%s|%s|%s",
                        _TL("Minimum Maximum"),
                        _TL("Standard Deviation"),
                        _TL("Percent Clip"),
                        _TL("Manual")
                ),
                Get_Defaults()["STRETCH"].asInt()
        );
 
        Parameters.Add_Range("STRETCH",
                "STRETCH_LINEAR"       , _TL("Minimum Maximum"),
                _TL("Apply the stretch between the minimum and maximum values specified as percentage of the full value range."),
                Get_Defaults()["STRETCH_LINEAR.MIN"].asDouble(),
                Get_Defaults()["STRETCH_LINEAR.MAX"].asDouble(), 0., true, 100., true
        );
 
        Parameters.Add_Double("STRETCH",
                "STRETCH_STDDEV"       , _TL("Standard Deviation"),
                _TL("Apply the stretch between a specified number of standard deviations."),
                Get_Defaults()["STRETCH_STDDEV"].asDouble(), 0., true
        );
 
        Parameters.Add_Bool("STRETCH_STDDEV",
                "STRETCH_STDDEV_RANGE" , _TL("Keep in Range"),
                _TL("Prevents that minimum or maximum stretch values fall outside of the actual data value range."),
                Get_Defaults()["STRETCH_STDDEV_RANGE"].asBool()
        );
 
        Parameters.Add_Range("STRETCH",
                "STRETCH_PERCENT"      , _TL("Percent Clip"),
                _TL("Adjust the stretch to the percentiles specified here."),
                Get_Defaults()["STRETCH_PERCENT.MIN"].asDouble(),
                Get_Defaults()["STRETCH_PERCENT.MAX"].asDouble(), 0., true, 100., true
        );
 
        //-----------------------------------------------------
        Parameters.Add_Range("NODE_STRETCH",
                "STRETCH_RANGE"        , _TL("Range"),
                _TL("")
        );
 
        Parameters.Add_Choice("NODE_STRETCH",
                "STRETCH_INTERVALS"    , _TL("Scaling"),
                _TL(""),
                CSG_String::Format("%s|%s|%s|%s",
                        _TL("linear intervals"),
                        _TL("increasing geometric intervals"),
                        _TL("decreasing geometric intervals"),
                        _TL("histogram equalize")
                ), 0
        );
 
        Parameters.Add_Double("STRETCH_INTERVALS",
                "STRETCH_INTERVALS_LOG"  , _TL("Geometric Interval Factor"),
                _TL(""),
                1., 0., true, 16., true
        );
 
        //-----------------------------------------------------
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Parameters(const CSG_Parameters &Parameters)
{
        m_Parameters.Assign_Values(&Parameters);
 
        Parameters_Changed();
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Parameter_Changed(CSG_Parameters &Parameters, CSG_Parameter &Parameter, int Flags)
{
        if( Flags & PARAMETER_CHECK_VALUES )
        {
                if( m_pObject && m_pObject->asTable(true) )
                {
                        if(     Parameter.Cmp_Identifier("COLOR_SYMBOLS")
                        ||      Parameter.Cmp_Identifier("STRETCH_FIELD")
                        ||      Parameter.Cmp_Identifier("STRETCH_NORMALIZE")
                        ||      Parameter.Cmp_Identifier("STRETCH_NORMALIZE_FORMAT") )
                        {
                                if(     Parameter.Cmp_Identifier("STRETCH_FIELD")
                                ||      Parameter.Cmp_Identifier("STRETCH_NORMALIZE")
                                ||      Parameter.Cmp_Identifier("STRETCH_NORMALIZE_FORMAT") )
                                {
                                        m_Normalization.Destroy(); // invalidate, might need updates
 
                                        if( Parameters("STRETCH")->asInt() == 3 ) // manual? no adjustment!
                                        {
                                                Parameters.Set_Parameter("STRETCH", 1); // standard deviation!
                                        }
                                }
 
                                if( Parameters("COLOR_SYMBOLS")->asInt() == 2 || Parameters("COLOR_SYMBOLS")->asInt() == 3 ) // discrete/graduated
                                {
                                        Set_Stretch(Parameters);
                                }
                        }
 
                        if(     Parameter.Cmp_Identifier("CLASSIFIED_FIELD") || (Parameter.Cmp_Identifier("COLOR_SYMBOLS") && Parameter.asInt() == 1) ) // CSG_Map_Symbology::CLASSIFIED
                        {
                                int Field = Parameters("CLASSIFIED_FIELD")->asInt();
 
                                if(     Field >= 0 && Field < m_pObject->asTable(true)->Get_Field_Count() )
                                {
                                        TSG_Data_Type Type = m_pObject->asTable(true)->is_Field_Numeric(Field)
                                                ? SG_DATATYPE_Double : SG_DATATYPE_String;
                        
                                        Parameters("CLASSIFIED_LUT")->asTable()->Set_Field_Type(CSG_Map_Symbology::LUT_MIN, Type);
                                        Parameters("CLASSIFIED_LUT")->asTable()->Set_Field_Type(CSG_Map_Symbology::LUT_MAX, Type);
                                }
                        }
                }
 
                if( Parameter.Cmp_Identifier("STRETCH")
                ||  Parameter.Cmp_Identifier("STRETCH_LINEAR")
                ||  Parameter.Cmp_Identifier("STRETCH_STDDEV")
                ||  Parameter.Cmp_Identifier("STRETCH_STDDEV_RANGE")
                ||  Parameter.Cmp_Identifier("STRETCH_PERCENT")
                ||  Parameter.Cmp_Identifier("BAND") )
                {
                        Set_Stretch(Parameters);
                }
 
                if( Parameter.Cmp_Identifier("STRETCH_RANGE"  )
                ||  Parameter.Cmp_Identifier("STRETCH_RANGE_R")
                ||  Parameter.Cmp_Identifier("STRETCH_RANGE_G")
                ||  Parameter.Cmp_Identifier("STRETCH_RANGE_B") )
                {
                        Parameters.Set_Parameter("STRETCH", 3); // manual
                }
        }
 
        //-----------------------------------------------------
        if( Flags & PARAMETER_CHECK_ENABLE )
        {
                if(     Parameter.Cmp_Identifier("LEGEND_SHOW")
                ||      Parameter.Cmp_Identifier("COLOR_SYMBOLS") )
                {
                        Parameters.Set_Enabled("LEGEND_ORIENTATION",
                                   Parameters("LEGEND_SHOW")->asBool()
                                && Parameters("COLOR_SYMBOLS")->asInt() == CSG_Map_Symbology::GRADUATED
                        );
                }
 
                if(     Parameter.Cmp_Identifier("LEGEND_TITLE") )
                {
                        Parameters.Set_Enabled("LEGEND_TITLE_TEXT", Parameter.asInt() == 1);
                }
 
                if(     Parameter.Cmp_Identifier("LEGEND_FIELD") )
                {
                        Parameters.Set_Enabled("LEGEND_FIELD_TEXT", Parameter.asInt() == 1);
                }
 
                if(     Parameter.Cmp_Identifier("SHOW_ALWAYS") )
                {
                        Parameters.Set_Enabled("SHOW_RANGE", Parameter.asBool() == false);
                }
 
                if(     Parameter.Cmp_Identifier("COLOR_SYMBOLS") )
                {
                        int Value = Parameter.asInt();
 
                        Parameters.Set_Enabled("NODE_SINGLE"    , Value == CSG_Map_Symbology::SINGLE);
                        Parameters.Set_Enabled("NODE_CLASSIFIED", Value == CSG_Map_Symbology::CLASSIFIED);
 
                        switch( Get_ObjectType() )
                        {
                        default                          :
                                Parameters.Set_Enabled("NODE_STRETCH", Value != CSG_Map_Symbology::SINGLE && Value != CSG_Map_Symbology::CLASSIFIED && Value != CSG_Map_Symbology::RGB);
                                break;
 
                        case SG_DATAOBJECT_TYPE_Grids    :
                                Parameters.Set_Enabled("NODE_STRETCH", Value != CSG_Map_Symbology::SINGLE && Value != CSG_Map_Symbology::CLASSIFIED);
                                break;
 
                        case SG_DATAOBJECT_TYPE_PointCloud:
                                Parameters.Set_Enabled("NODE_STRETCH", Value != 4 && Value != CSG_Map_Symbology::SINGLE && Value != CSG_Map_Symbology::CLASSIFIED);
                                Parameters.Set_Enabled("NODE_RGB"     , Value == 4); // RGB Coded Values
                                break;
                        }
 
                        Parameters.Set_Enabled("STRETCH_COLORS"  , Value == CSG_Map_Symbology::DISCRETE || Value == CSG_Map_Symbology::GRADUATED);
                }
 
                if(     Parameter.Cmp_Identifier("STRETCH_FIELD") )
                {
                        Parameters.Set_Enabled("STRETCH_NORMALIZE", Get_Fields_Choice(Parameter) >= 0);
                }
 
                if( Parameter.Cmp_Identifier("STRETCH_NORMALIZE") )
                {
                        Parameter.Set_Children_Enabled(Get_Fields_Choice(Parameter) >= 0);
                }
 
                if(     Parameter.Cmp_Identifier("STRETCH_INTERVALS") )
                {
                        Parameters.Set_Enabled("STRETCH_INTERVALS_LOG", Parameter.asInt() == 1 || Parameter.asInt() == 2);
                }
 
                CSG_Parameter *pStretch = Parameters("STRETCH");
 
                if(     pStretch )
                {
                        Parameters.Set_Enabled("STRETCH_LINEAR" , pStretch->asInt() == 0);
                        Parameters.Set_Enabled("STRETCH_STDDEV" , pStretch->asInt() == 1);
                        Parameters.Set_Enabled("STRETCH_PERCENT", pStretch->asInt() == 2);
                }
        }
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::DataObject_Changed(void)
{
        m_Normalization.Destroy(); // invalidate
 
        if( m_Parameters["COLOR_SYMBOLS"].asInt() == 2 || m_Parameters["COLOR_SYMBOLS"].asInt() == 3 ) // discrete/graduated
        {
                Set_Stretch(m_Parameters);
 
                m_pSymbology->Update();
        }
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Parameters_Changed(void)
{
        m_pSymbology->Set_Mode(m_Parameters["COLOR_SYMBOLS"].asInt());
 
        m_pSymbology->Set_NoData_Color(m_Parameters("NODATA_COLOR") ? m_Parameters["NODATA_COLOR"].asColor() : SG_COLOR_GREY_LIGHT);
 
        m_pSymbology->Set_Single_Color(m_Parameters["SINGLE_COLOR"].asColor());
 
        m_pSymbology->Set_Stretch(
                m_Parameters["STRETCH_RANGE.MIN"     ].asDouble(),
                m_Parameters["STRETCH_RANGE.MAX"     ].asDouble(),
                m_Parameters["STRETCH_INTERVALS"     ].asInt   (),
                m_Parameters["STRETCH_INTERVALS_LOG" ].asDouble()
        );
 
        m_pSymbology->Update();
 
        m_pLegend->m_Title    = Get_Legend_Title   ();
        m_pLegend->m_Subtitle = Get_Legend_Subtitle();
        m_pLegend->Set_Orientation(m_Parameters["LEGEND_ORIENTATION"].asInt() == 0 ? CSG_Map_Legend::VERTICAL : CSG_Map_Legend::HORIZONTAL);
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Sync_Back(CSG_Parameters &Target) const
{
        int n = 0;
 
        for(int i=0; i<m_Parameters.Get_Count(); i++)
        {
                CSG_Parameter *pTarget = Target(m_Parameters[i].Get_Identifier());
 
                if( pTarget && pTarget->Get_Type() == m_Parameters[i].Get_Type() )
                {
                        n++; pTarget->Assign(m_Parameters(i));
                }
        }
 
        return( n == m_Parameters.Get_Count() );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Sync_Forward(const CSG_Parameters &Source)
{
        int n = 0;
 
        for(int i=0; i<m_Parameters.Get_Count(); i++)
        {
                CSG_Parameter *pSource = Source(m_Parameters[i].Get_Identifier());
 
                if( pSource && pSource->Get_Type() == m_Parameters[i].Get_Type() )
                {
                        n++; m_Parameters[i].Assign(pSource);
                }
        }
 
        return( n == m_Parameters.Get_Count() );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Stretch(CSG_Parameters &Parameters, CSG_Data_Object *pObject, const CSG_String &Suffix)
{
        if( Parameters["STRETCH"].asInt() == 3 ) // keep current stretch if set to 'manual'!
        {
                if( Get_Stretch_Range() <= 0. )
                {
                        Parameters["STRETCH"].Set_Value(0); // linear stretch
                        Set_Stretch(Parameters, pObject, Suffix);
                        Parameters["STRETCH"].Set_Value(3); // manual
                }
 
                return( false );
        }
 
        if( !pObject )
        {
                if( !m_pObject )
                {
                        return( false );
                }
 
                pObject = m_pObject;
        }
 
        //-----------------------------------------------------
        int Field = -1; CSG_Table *pTable = _Get_Field_Table(Field, Parameters);
 
        if( pTable && Field < 0 )
        {
                return( false );
        }
 
        if( pObject->asGrids() && Parameters["COLOR_SYMBOLS"].asInt() != CSG_Map_Symbology::COMPOSITE )
        {
                int i = Parameters("BAND") ? Parameters["BAND"].asInt() : -1;
 
                if( i < 0 || i >= pObject->asGrids()->Get_NZ() || !(pObject = pObject->asGrids()->Get_Grid_Ptr(i)) )
                {
                        return( false );
                }
        }
 
        //-----------------------------------------------------
    SG_UI_Process_Set_Busy(true);
 
        double Minimum, Maximum;
 
        switch( Parameters["STRETCH"].asInt() )
        {
        case  0: // linear
                {
                        CSG_Simple_Statistics Statistics = pTable ? pTable->Get_Statistics(Field) : pObject->asGrid() ? pObject->asGrid()->Get_Statistics() : pObject->asGrids()->Get_Statistics();
 
                        Minimum = Statistics.Get_Minimum() + Statistics.Get_Range() * Parameters["STRETCH_LINEAR.MIN"].asDouble() / 100.;
                        Maximum = Statistics.Get_Minimum() + Statistics.Get_Range() * Parameters["STRETCH_LINEAR.MAX"].asDouble() / 100.;
                }
                break;
 
        case  1: // standard deviation
                {
                        CSG_Simple_Statistics Statistics = pTable ? pTable->Get_Statistics(Field) : pObject->asGrid() ? pObject->asGrid()->Get_Statistics() : pObject->asGrids()->Get_Statistics();
 
                        Minimum = Statistics.Get_Mean() - Statistics.Get_StdDev() * Parameters["STRETCH_STDDEV"].asDouble();
                        Maximum = Statistics.Get_Mean() + Statistics.Get_StdDev() * Parameters["STRETCH_STDDEV"].asDouble();
 
                        if( Parameters["STRETCH_STDDEV_RANGE"].asBool() )
                        {
                                if( Minimum < Statistics.Get_Minimum() ) { Minimum = Statistics.Get_Minimum(); }
                                if( Maximum > Statistics.Get_Maximum() ) { Maximum = Statistics.Get_Maximum(); }
                        }
                }
                break;
 
        case  2: // percentile
                {
                        const CSG_Histogram &Histogram = pTable ? pTable->Get_Histogram(Field) : pObject->asGrid() ? pObject->asGrid()->Get_Histogram() : pObject->asGrids()->Get_Histogram();
 
                        Minimum = Histogram.Get_Percentile(Parameters["STRETCH_PERCENT.MIN"].asDouble());
                        Maximum  = Histogram.Get_Percentile(Parameters["STRETCH_PERCENT.MAX"].asDouble());
                }
                break;
 
        default: SG_UI_Process_Set_Busy(false); return( false );
        }
 
        if( Minimum >= Maximum )//&& g_pData->Get_Parameter("STRETCH_NORANGE")->asInt() != 0 )
        {
                CSG_Simple_Statistics Statistics = pTable ? pTable->Get_Statistics(Field) : pObject->asGrid() ? pObject->asGrid()->Get_Statistics() : pObject->asGrids()->Get_Statistics();
 
                if( Statistics.Get_Range() > 0. )//&& (g_pData->Get_Parameter("STRETCH_NORANGE")->asInt() == 2 || DLG_Message_Confirm(wxString::Format("%s\n\n%s", _TL("Minimum stretch range value equals maximum!"), _TL("Adjust to full range?")), _TL("Histogram Stretch"))) )
                {
                        Minimum = Statistics.Get_Minimum();
                        Maximum = Statistics.Get_Maximum();
 
                        bool bCallback = Parameters.Set_Callback(false);
                        Parameters.Set_Parameter("STRETCH", 3); // 'manual'
                        Parameters.Set_Callback(bCallback);
                }
        }
 
    SG_UI_Process_Set_Busy(false);
 
        Parameters.Set_Parameter("STRETCH_RANGE" + Suffix + ".MIN", Minimum);
        Parameters.Set_Parameter("STRETCH_RANGE" + Suffix + ".MAX", Maximum);
 
        return( true );
}
 
//---------------------------------------------------------
double CSG_Map_Layer::Get_Stretch_Minimum(void) const
{
        return( m_Parameters["STRETCH_RANGE.MIN"].asDouble() );
}
 
//---------------------------------------------------------
double CSG_Map_Layer::Get_Stretch_Maximum(void) const
{
        return( m_Parameters["STRETCH_RANGE.MAX"].asDouble() );
}
 
//---------------------------------------------------------
double CSG_Map_Layer::Get_Stretch_Range(void) const
{
        return( Get_Stretch_Maximum() - Get_Stretch_Minimum() );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Stretch_Range(double Minimum, double Maximum)
{
        if( m_Parameters["COLOR_SYMBOLS"].asInt() != CSG_Map_Symbology::DISCRETE
        &&  m_Parameters["COLOR_SYMBOLS"].asInt() != CSG_Map_Symbology::GRADUATED
        &&  m_Parameters["COLOR_SYMBOLS"].asInt() != CSG_Map_Symbology::COMPOSITE )
        {
                m_Parameters["COLOR_SYMBOLS"].Set_Value( CSG_Map_Symbology::GRADUATED );
        }
 
        m_Parameters["STRETCH_RANGE.MIN"].Set_Value(Minimum < Maximum ? Minimum : Maximum);
        m_Parameters["STRETCH_RANGE.MAX"].Set_Value(Minimum < Maximum ? Maximum : Minimum);
 
        m_Parameters["STRETCH"].Set_Value(3); // 'manual'
 
        return( true );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Stretch_FullRange(void)
{
        int Field = -1; CSG_Table *pTable = _Get_Field_Table(Field, m_Parameters);
 
        if( pTable )
        {
                return( Field < 0 ? false : Set_Stretch_Range(pTable->Get_Minimum(Field), pTable->Get_Maximum(Field)) );
        }
 
        CSG_Data_Object *pObject = m_pObject;
 
        if( pObject )
        {
                if( pObject->asGrids() && m_Parameters["COLOR_SYMBOLS"].asInt() != CSG_Map_Symbology::COMPOSITE )
                {
                        int Band = m_Parameters("BAND") ? m_Parameters["BAND"].asInt() : -1;
 
                        if( Band < 0 || Band >= pObject->asGrids()->Get_NZ() || !(pObject = pObject->asGrids()->Get_Grid_Ptr(Band)) )
                        {
                                return( false );
                        }
                }
 
                if( pObject->asGrid () ) { return( Set_Stretch_Range(pObject->asGrid ()->Get_Min(), pObject->asGrid ()->Get_Max()) ); }
                if( pObject->asGrids() ) { return( Set_Stretch_Range(pObject->asGrids()->Get_Min(), pObject->asGrids()->Get_Max()) ); }
        }
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
const wxBitmap * CSG_Map_Layer::Get_Thumbnail(int dx, int dy)
{
        if( dx > 0 && dy > 0 && (!m_pThumbnail->IsOk() || m_pThumbnail->GetWidth() != dx || m_pThumbnail->GetHeight() != dy) )
        {
                m_pThumbnail->Create(dx, dy);
 
                Set_Thumbnail();
        }
 
        return( m_pThumbnail );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Thumbnail(void)
{
        if( m_pObject && m_pThumbnail->IsOk() && m_pThumbnail->GetWidth() > 0 && m_pThumbnail->GetHeight() > 0 )
        {
                CSG_Map_DC dc_Map(Get_Extent(), m_pThumbnail->GetSize(), 1., SG_Get_Color(SG_System_Get_Color(wxSYS_COLOUR_WINDOW)));
 
                if( Draw(dc_Map, LAYER_DRAW_FLAG_NOEDITS|LAYER_DRAW_FLAG_NOLABELS|LAYER_DRAW_FLAG_THUMBNAIL) )
                {
                        wxBitmap Bitmap;
 
                        if( dc_Map.Get_Bitmap(Bitmap) )
                        {
                                wxMemoryDC dc;
 
                                dc.SelectObject(*m_pThumbnail);
                                dc.DrawBitmap(Bitmap, 0, 0, false);
                                dc.SelectObject(wxNullBitmap);
 
                                return( true );
                        }
                }
        }
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
CSG_Rect CSG_Map_Layer::Get_Extent(void) const
{
        if( m_pObject )
        {
                switch( Get_ObjectType() )
                {
                case SG_DATAOBJECT_TYPE_Grid      : return( m_pObject->asGrid      ()->Get_Extent(true) );
                case SG_DATAOBJECT_TYPE_Grids     : return( m_pObject->asGrids     ()->Get_Extent(true) );
                case SG_DATAOBJECT_TYPE_Shapes    : return( m_pObject->asShapes    ()->Get_Extent    () );
                case SG_DATAOBJECT_TYPE_PointCloud: return( m_pObject->asPointCloud()->Get_Extent    () );
                case SG_DATAOBJECT_TYPE_TIN       : return( m_pObject->asTIN       ()->Get_Extent    () );
                default                           : break;
                }
        }
 
        return( CSG_Rect(0., 0., 0., 0.) );
}
 

//                                                       //
 
//---------------------------------------------------------
CSG_Table & CSG_Map_Layer::Get_LUT(void)
{
        return( *m_Parameters["CLASSIFIED_LUT"].asTable() );
}
 
//---------------------------------------------------------
CSG_Colors & CSG_Map_Layer::Get_Colors(void)
{
        return( *m_Parameters["STRETCH_COLORS"].asColors() );
}
 
//---------------------------------------------------------
const CSG_Colors & CSG_Map_Layer::Get_Colors(void) const
{
        return( *m_Parameters["STRETCH_COLORS"].asColors() );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Get_Colors(CSG_Colors &Colors) const
{
        return( Colors.Create(m_pSymbology->Get_Colors()) );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Colors(const CSG_Colors &Colors)
{
        return( m_Parameters["STRETCH_COLORS"].asColors()->Create(Colors) );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Normalization(int Field_Value, int Field_Normalize, double Scale_Normalize, sLong maxSamples)
{
        m_Normalization.Destroy();
 
        CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL;
 
        if( !pTable || Field_Value < 0 || Field_Normalize < 0 || Field_Value >= pTable->Get_Field_Count() || Field_Normalize >= pTable->Get_Field_Count() )
        {
                return( false );
        }
 
        m_Normalization.Add_Field("Normalized", SG_DATATYPE_Double);
 
        for(sLong i=0; i<pTable->Get_Count(); i++)
        {
                double Value, Normalize;
 
                if( pTable->Get_Value(i, Field_Normalize, Normalize) && Normalize != 0. && pTable->Get_Value(i, Field_Value, Value) )
                {
                        m_Normalization.Add_Record()->Set_Value(0, Scale_Normalize * Value / Normalize);
                }
        }
 
        return( m_Normalization.Get_Count() );
}
 
//---------------------------------------------------------
CSG_Table * CSG_Map_Layer::_Get_Field_Table(int &Field, const CSG_Parameters &Parameters)
{
        CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL; Field = -1;
 
        if( pTable && Parameters("STRETCH_FIELD") && Parameters("STRETCH_NORMALIZE") && Parameters("STRETCH_NORMALIZE_FORMAT") )
        {
                Field = Get_Fields_Choice(Parameters["STRETCH_FIELD"]); if( Field >= pTable->Get_Field_Count() ) { Field = -1; }
                
                if( Field >= 0 )
                {
                        if( m_Normalization.Get_Count() || Set_Normalization(Field, Get_Fields_Choice(Parameters["STRETCH_NORMALIZE"]), Parameters["STRETCH_NORMALIZE_FORMAT"].asInt() == 0 ? 1. : 100.) )
                        {
                                pTable = &m_Normalization; Field = 0;
                        }
                }
        }
 
        return( pTable );
}
 

//                                                       //
 
//---------------------------------------------------------
wxString CSG_Map_Layer::Get_Legend_Title(void) const
{
        switch( m_Parameters["LEGEND_TITLE"].asInt() )
        {
        case  0: return( m_pObject ? m_pObject->Get_Name() : SG_T("")); // data set
        case  1: return( m_Parameters["LEGEND_TITLE_TEXT"].asString()); // user defined
        default: return( "" ); // none
        }
}
 
//---------------------------------------------------------
wxString CSG_Map_Layer::Get_Legend_Subtitle(void) const
{
        wxString s; CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL;
 
        if( pTable && m_Parameters["LEGEND_FIELD"].asInt() != 2 ) // no labeling?
        {
                if( m_Parameters["LEGEND_FIELD"].asInt() == 1 ) // user defined
                {
                        s = m_Parameters["LEGEND_FIELD_TEXT"].asString();
                }
                else // automatic
                {
                        int Value = -1, Normal = -1;
 
                        switch( m_Parameters["COLOR_SYMBOLS"].asInt() )
                        {
                        case  1: // CSG_Map_Symbology::CLASSIFIED
                                Value  = Get_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ]);
                                Normal = Get_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"]);
                                break;
 
                        case  2: // CSG_Map_Symbology::DISCRETE
                        case  3: // CSG_Map_Symbology::GRADUATED
                                Value  = Get_Fields_Choice(m_Parameters["STRETCH_FIELD"    ]);
                                Normal = Get_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"]);
                                break;
 
                        case  4: // CSG_Map_Symbology::RGB
                                Value  = Get_Fields_Choice(m_Parameters["RGB_FIELD"]); // point clouds only!
                                break;
                        }
 
                        if( Value >= 0 )
                        {
                                s = pTable->Get_Field_Name(Value);
 
                                if( Normal >= 0 )
                                {
                                        s += " / "; s += pTable->Get_Field_Name(Normal);
                                }
                        }
                }
        }
 
        return( s );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Get_Field_Value(sLong Index, int Field, int Normalize, double Scale, wxString &Value) const
{
        CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL;
 
        if( pTable && Index >= 0 && Index < pTable->Get_Count() )
        {
                if( Field < 0 || Field >= pTable->Get_Field_Count() )
                {
                        Value.Printf("%s: %lld", _TL("Index"), Index + 1);
 
                        return( true );
                }
 
                //-------------------------------------------------
                if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::CLASSIFIED )
                {
                        if( !SG_Data_Type_is_Numeric(pTable->Get_Field_Type(Field)) )
                        {
                                CSG_String s;
 
                                if( pTable->Get_Value(Index, Field, s) )
                                {
                                        Value = m_pSymbology->Get_Class_Name_byValue(s.c_str());
 
                                        return( true );
                                }
                        }
                        else
                        {
                                double d;
 
                                if( Get_Field_Value(Index, Field, Normalize, Scale, d) )
                                {
                                        Value = m_pSymbology->Get_Class_Name_byValue(d);
 
                                        return( true );
                                }
                        }
                }
 
                //-------------------------------------------------
                else if( m_pSymbology->Get_Mode() == CSG_Map_Symbology::RGB )
                {
                        double d;
 
                        if( pTable->Get_Value(Index, Field, d) )
                        {
                                Value.Printf("R%03d G%03d B%03d", SG_GET_R((int)d), SG_GET_G((int)d), SG_GET_B((int)d));
 
                                return( true );
                        }
                }
 
                //-------------------------------------------------
                else // CSG_Map_Symbology::DISCRETE || CSG_Map_Symbology::GRADUATED
                {
                        double d;
 
                        if( Get_Field_Value(Index, Field, Normalize, Scale, d) )
                        {
                                Value.Printf("%f", d);
 
                                return( true );
                        }
                }
        }
 
        return( false );
}
 
//---------------------------------------------------------
bool CSG_Map_Layer::Get_Field_Value(sLong Index, int Field, int Normalize, double Scale, double &Value) const
{
        CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL;
 
        if( pTable && Index >= 0 && Index < pTable->Get_Count() && Field >= 0 && Field < pTable->Get_Field_Count() )
        {
                if( pTable->Get_Value(Index, Field, Value) )
                {
                        if( Normalize < 0 )
                        {
                                return( true );
                        }
 
                        double Divisor;
 
                        if( pTable->Get_Value(Index, Normalize, Divisor) && Divisor != 0. )
                        {
                                Value *= Scale / Divisor;
 
                                return( true );
                        }
                }
        }
 
        return( false );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Set_Fields_Choice(CSG_Parameter &Choice, bool bNumeric, bool bAddNone, bool bSelectNone)
{
        CSG_Parameter_Choice *pChoice = Choice.asChoice();
 
        if( pChoice )
        {
                CSG_Table *pTable = m_pObject ? m_pObject->asTable(true) : NULL;
 
                if( pTable )
                {
                        CSG_String Fields;
 
                        for(int i=0; i<pTable->Get_Field_Count(); i++)
                        {
                                if( !bNumeric || SG_Data_Type_is_Numeric(pTable->Get_Field_Type(i)) )
                                {
                                        Fields += CSG_String::Format("{%d}%s|", i, pTable->Get_Field_Name(i));
                                }
                        }
 
                        if( !Fields.is_Empty() )
                        {
                                if( bAddNone )
                                {
                                        Fields += CSG_String::Format("{-1}<%s>", _TL("none"));
 
                                        if( pChoice->Get_Count() <= 1 || Get_Fields_Choice(Choice) < 0 )
                                        {
                                                bSelectNone = true;
                                        }
                                }
 
                                pChoice->Set_Items(Fields);
 
                                if( bAddNone && bSelectNone )
                                {
                                        pChoice->Set_Value(pChoice->Get_Count() - 1);
                                }
 
                                return( true );
                        }
                }
 
                pChoice->asChoice()->Set_Items(CSG_String::Format("{-1}<%s>", _TL("none")));
        }
 
        return( false );
}
 
//---------------------------------------------------------
int CSG_Map_Layer::Get_Fields_Choice(CSG_Parameter &Choice)
{
        int Field; return( Choice.asChoice() && Choice.asChoice()->Get_Data(Field) ? Field : -1 );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Draw(CSG_Map_DC &dc_Map, int Flags, CSG_Data_Object *pObject)
{
        if( pObject && pObject->is_Valid() && pObject->Get_ObjectType() == Get_ObjectType() )
        {
                CSG_Data_Object  *pOriginal = m_pObject;
 
                m_pObject = pObject;
 
                On_Draw(dc_Map, Flags);
 
                m_pObject = pOriginal;
        }
        else if( m_pObject && m_pObject->is_Valid() )
        {
                On_Draw(dc_Map, Flags);
        }
 
        dc_Map.SetBrush(wxNullBrush);
        dc_Map.SetPen  (wxNullPen  );
 
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_Layer::Classify(const CSG_MetaData &Options)
{
        int Method = -1;
 
        if( !m_pObject || !Options.Get_Content("METHOD", Method) )
        {
                return( false );
        }
 
        //-----------------------------------------------------
        CSG_Map_Classify Classify; CSG_Table *pTable = m_pObject->asTable(true); int Field = -1;
        
        if( pTable )
        {
                if( !Options.Get_Content("FIELD", Field) || Field < 0 || Field >= pTable->Get_Field_Count() )
                {
                        return( false );
                }
 
                Classify.Create(pTable, Field);
        }
        else
        {
                Classify.Create(m_pObject);
        }
 
        //-----------------------------------------------------
        int    Classes_Max; Options.Get_Content("CLASSES_MAX", Classes_Max = 1024);
        int    Classes    ; Options.Get_Content("CLASSES"    , Classes     =   10);
        int    Increasing ; Options.Get_Content("INCREASING" , Increasing  =    1);
        int    Histogram  ; Options.Get_Content("HISTOGRAM"  , Histogram   =    1);
        double StdDev     ; Options.Get_Content("STDDEV"     , StdDev      =  0.5);
        double StdDev_Max ; Options.Get_Content("STDDEV_MAX" , StdDev_Max  =  4.0);
        double Interval   ; Options.Get_Content("INTERVAL"   , Interval    =  0.0);
        double Offset; bool bOffset = Options.Get_Content("OFFSET", Offset =  0.0);
 
        switch( Method )
        {
        case  0: Classify.Classify_Unique   (Classes_Max             );   break;
        case  1: Classify.Classify_Equal    (Classes                 );   break;
        case  2: if( bOffset )
             {   Classify.Classify_Defined  (Interval, Offset        ); }
        else {   Classify.Classify_Defined  (Interval                ); } break;
        case  3: Classify.Classify_Quantile (Classes, Histogram  == 1);   break;
        case  4: Classify.Classify_Geometric(Classes, Increasing == 1);   break;
        case  5: Classify.Classify_Natural  (Classes                 );   break;
        case  6: Classify.Classify_StdDev   (StdDev, StdDev_Max      );   break;
        }
 
        //-----------------------------------------------------
        int ColorsID = -1; Options.Get_Content("COLORS", ColorsID);
        CSG_Colors Colors; if( !Colors.Create(0, ColorsID) ) { Colors.Create(*m_Parameters["STRETCH_COLORS"].asColors()); }
 
        if( Classify.Set_LUT(*m_Parameters["CLASSIFIED_LUT"].asTable(), Colors, 1) )
        {
                if( m_Parameters["CLASSIFIED_LUT"].asTable()->Get_MetaData().Get_Child("SAGA_GUI_LUT_TYPE") == NULL )
                {
                        m_Parameters["CLASSIFIED_LUT"].asTable()->Get_MetaData().Add_Child("SAGA_GUI_LUT_TYPE", Get_ObjectType());
                }
 
                m_Parameters["COLOR_SYMBOLS"].Set_Value(CSG_Map_Symbology::CLASSIFIED); // Lookup Table
 
                if( pTable )
                {
                        m_Parameters["CLASSIFIED_FIELD"    ].Set_Value(Field);
                        m_Parameters["CLASSIFIED_NORMALIZE"].Set_Value(-1);
                }
 
                return( true );
        }
 
        return( false );
}
 

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