map_tin.cpp

Go to the documentation of this file.

//                                                       //
//                         SAGA                          //
//                                                       //
//      System for Automated Geoscientific Analyses      //
//                                                       //
//           Application Programming Interface           //
//                                                       //
//                  Library: SAGA_API                    //
//                                                       //
//-------------------------------------------------------//
//                                                       //
//                  map_shapes_tin.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_TIN::CSG_Map_TIN(CSG_TIN *pTIN)
        : CSG_Map_Layer(SG_DATAOBJECT_TYPE_TIN)
{
        Add_Parameters(m_Parameters);
 
        Set_Object(pTIN);
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_TIN::Add_Parameters(CSG_Parameters &Parameters)
{
        CSG_Map_Layer::Add_Parameters(Parameters);
 
        //-----------------------------------------------------
        // Display...
 
        Parameters.Add_Node("NODE_DISPLAY", "DISPLAY_SHOW" , _TL("Show" ), _TL(""));
        Parameters.Add_Bool("DISPLAY_SHOW", "DISPLAY_NODES", _TL("Nodes"), _TL(""), false);
        Parameters.Add_Bool("DISPLAY_SHOW", "DISPLAY_EDGES", _TL("Edges"), _TL(""),  true);
        Parameters.Add_Bool("DISPLAY_SHOW", "DISPLAY_FACES", _TL("Faces"), _TL(""),  true);
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_TIN::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_TIN::DataObject_Changed(void)
{
        CSG_Map_Layer::DataObject_Changed();
 
        //-----------------------------------------------------
        Set_Fields_Choice(m_Parameters["CLASSIFIED_FIELD"    ], false, false, false);
        Set_Fields_Choice(m_Parameters["CLASSIFIED_NORMALIZE"   ],  true,  true,  true);
        Set_Fields_Choice(m_Parameters["STRETCH_FIELD" ],  true, false, false);
        Set_Fields_Choice(m_Parameters["STRETCH_NORMALIZE"],  true,  true,  true);
 
        //-----------------------------------------------------
        return( true );
}
 

//                                                       //
 
//---------------------------------------------------------
bool CSG_Map_TIN::Parameters_Changed(void)
{
        CSG_Map_Layer::Parameters_Changed();
 
        //-----------------------------------------------------
        switch( m_Parameters["COLOR_SYMBOLS"].asInt() )
        {
        default: // CSG_Map_Symbology::SINGLE
                m_Stretch.Value  = -1;
                m_Stretch.Normal = -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;
        }
 
        if( m_Stretch.Value < 0 )
        {
                m_pSymbology->Set_Mode(CSG_Map_Symbology::SINGLE);
        }
 
        //-----------------------------------------------------
        return( true );
}
 

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

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_TIN::On_Draw(CSG_Map_DC &dc_Map, int Flags)
{
        if( m_pObject && Get_Extent().Intersects(dc_Map.rWorld()) != INTERSECTION_None )
        {
                if( m_Parameters("DISPLAY_FACES")->asBool() ) { _Draw_Triangles(dc_Map); }
                if( m_Parameters("DISPLAY_EDGES")->asBool() ) { _Draw_Edges    (dc_Map); }
                if( m_Parameters("DISPLAY_NODES")->asBool() ) { _Draw_Points   (dc_Map); }
        }
}
 

//                                                       //
 
//---------------------------------------------------------
void CSG_Map_TIN::_Draw_Points(CSG_Map_DC &dc_Map)
{
        for(int i=0; i<m_pObject->asTIN()->Get_Node_Count(); i++)
        {
                TSG_Point_Int Point = dc_Map.World2DC(m_pObject->asTIN()->Get_Node(i)->Get_Point());
 
                dc_Map.DrawCircle(Point.x, Point.y, 5);
        }
}
 
//---------------------------------------------------------
void CSG_Map_TIN::_Draw_Edges(CSG_Map_DC &dc_Map)
{
        for(int i=0; i<m_pObject->asTIN()->Get_Edge_Count(); i++)
        {
                TSG_Point_Int Point[2]; CSG_TIN_Edge *pEdge = m_pObject->asTIN()->Get_Edge(i);
 
                Point[0] = dc_Map.World2DC(pEdge->Get_Node(0)->Get_Point());
                Point[1] = dc_Map.World2DC(pEdge->Get_Node(1)->Get_Point());
 
                dc_Map.DrawLine(Point[0].x, Point[0].y, Point[1].x, Point[1].y);
        }
}
 
//---------------------------------------------------------
void CSG_Map_TIN::_Draw_Triangles(CSG_Map_DC &dc_Map)
{
        if( dc_Map.Draw_Image_Begin(m_Parameters("TRANSPARENCY")->asDouble() / 100.) )
        {
                for(sLong iTriangle=0; iTriangle<m_pObject->asTIN()->Get_Triangle_Count(); iTriangle++)
                {
                        CSG_TIN_Triangle *pTriangle = m_pObject->asTIN()->Get_Triangle(iTriangle);
 
                        if( dc_Map.rWorld().Intersects(pTriangle->Get_Extent()) != INTERSECTION_None )
                        {
                                TPoint p[3];
                                
                                if( m_Stretch.Value < 0 )
                                {
                                        for(int iNode=0; iNode<3; iNode++)
                                        {
                                                CSG_TIN_Node *pNode = pTriangle->Get_Node(iNode);
 
                                                TSG_Point_Int Point = dc_Map.World2DC(pNode->Get_Point());
 
                                                p[iNode].x = Point.x; p[iNode].y = Point.y; p[iNode].z = 0.;
                                        }
 
                                        _Draw_Triangle(dc_Map, p);
                                }
                                else
                                {
                                        bool bOkay = true;
 
                                        for(int iNode=0; bOkay && iNode<3; iNode++)
                                        {
                                                CSG_TIN_Node *pNode = pTriangle->Get_Node(iNode); double Value;
 
                                                if( (bOkay = CSG_Map_Layer::Get_Field_Value(pNode->Get_Index(), m_Stretch.Value, m_Stretch.Normal, m_Stretch.Scale, Value)) == true )
                                                {
                                                        TSG_Point_Int Point = dc_Map.World2DC(pNode->Get_Point());
 
                                                        p[iNode].x = Point.x; p[iNode].y = Point.y; p[iNode].z = Value;
                                                }
                                        }
 
                                        if( bOkay )
                                        {
                                                _Draw_Triangle(dc_Map, p);
                                        }
                                }
                        }
                }
 
                dc_Map.Draw_Image_End();
        }
}
 

//                                                       //
 
//---------------------------------------------------------
#define SORT_POINTS_Y(a, b) if( p[a].y < p[b].y ) { TPoint pp = p[a]; p[a] = p[b]; p[b] = pp; }
#define SORT_POINTS_X(a, b) if( p[a].x < p[b].x ) { TPoint pp = p[a]; p[a] = p[b]; p[b] = pp; }
 
#define DRAW_PIXEL(x, y, z) { int c; if( m_pSymbology->Get_Class_Color_byValue(z, c) ) { dc_Map.Draw_Image_Pixel(x, y, c); } }
 
//---------------------------------------------------------
void CSG_Map_TIN::_Draw_Triangle(CSG_Map_DC &dc_Map, TPoint p[3])
{
        SORT_POINTS_Y(1, 0); SORT_POINTS_Y(2, 0); SORT_POINTS_Y(2, 1);
 
        if( p[2].y == p[0].y )
        {
                if( p[0].y >= 0 && p[0].y < dc_Map.rDC().GetHeight() )
                {
                        SORT_POINTS_X(1, 0); SORT_POINTS_X(2, 0); SORT_POINTS_X(2, 1);
 
                        if( p[2].x == p[0].x )
                        {
                                if(     p[0].x >= 0 && p[0].x < dc_Map.rDC().GetWidth() )
                                {
                                        DRAW_PIXEL(p[0].x, p[0].y, p[0].z > p[1].z
                                                ? (p[0].z > p[2].z ? p[0].z : p[2].z)
                                                : (p[1].z > p[2].z ? p[1].z : p[2].z)
                                        );
                                }
                        }
                        else
                        {
                                _Draw_Triangle_Line(dc_Map, p[0].x, p[1].x, p[0].y, p[0].z, p[1].z);
                                _Draw_Triangle_Line(dc_Map, p[1].x, p[2].x, p[0].y, p[1].z, p[2].z);
                        }
                }
        }
 
        //-----------------------------------------------------
        else if( !((p[0].y < 0 && p[2].y < 0) || (p[0].y >= dc_Map.rDC().GetHeight() && p[2].y >= dc_Map.rDC().GetHeight())) )
        {
                double dy   =  p[2].y - p[0].y;
                double dx_a = (p[2].x - p[0].x) / dy;
                double dz_a = (p[2].z - p[0].z) / dy;
                double x_a  =  p[0].x;
                double z_a  =  p[0].z;
 
                for(int i=0, j=1; i<2; i++, j++)
                {
                        if( (dy = p[j].y - p[i].y) > 0. )
                        {
                                double dx = (p[j].x - p[i].x) / dy;
                                double dz = (p[j].z - p[i].z) / dy;
                                double x  =  p[i].x;
                                double z  =  p[i].z;
                                int    y  =  p[i].y;
 
                                if( y < 0 )
                                {
                                        x   -= y * dx;
                                        z   -= y * dz;
                                        y    = 0;
                                        x_a  = p[0].x - p[0].y * dx_a;
                                        z_a  = p[0].z - p[0].y * dz_a;
                                }
 
                                int yn = p[j].y; if( yn > dc_Map.rDC().GetHeight() ) { yn = dc_Map.rDC().GetHeight(); }
 
                                for( ; y<yn; y++, x+=dx, z+=dz, x_a+=dx_a, z_a+=dz_a)
                                {
                                        if( x < x_a )
                                        {
                                                _Draw_Triangle_Line(dc_Map, (int)x, (int)x_a, y, z, z_a);
                                        }
                                        else
                                        {
                                                _Draw_Triangle_Line(dc_Map, (int)x_a, (int)x, y, z_a, z);
                                        }
                                }
                        }
                }
        }
}
 
//---------------------------------------------------------
inline void CSG_Map_TIN::_Draw_Triangle_Line(CSG_Map_DC &dc_Map, int xa, int xb, int y, double za, double zb)
{
        double dz = xb - xa;
 
        if( dz > 0. )
        {
                dz = (zb - za) / dz;
 
                if( xa < 0 )
                {
                        za -= dz * xa;
                        xa  = 0;
                }
 
                if( xb >= dc_Map.rDC().GetWidth() )
                {
                        xb = dc_Map.rDC().GetWidth() - 1;
                }
 
                for(int x=xa; x<=xb; x++, za+=dz)
                {
                        DRAW_PIXEL(x, y, za);
                }
        }
        else if( xa >= 0 && xa < dc_Map.rDC().GetWidth() )
        {
                DRAW_PIXEL(xa, y, za);
        }
}
 

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