TYTopographieGraphic.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012-2024> <EDF-DTG> <FRANCE>
 * This file is part of Code_TYMPAN (R).
 * Code_TYMPAN (R) 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 3 of the License, or
 * (at your option) any later version.
 * Code_TYMPAN (R) 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 Code_TYMPAN (R). If not, see <https://www.gnu.org/licenses/>.
 */
 
#include "Tympan/models/business/TYPreferenceManager.h"
#include "Tympan/models/business/infrastructure/TYTopographie.h"
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "Tympan/gui/gl/TYAltimetrieGraphic.h"
#include "TYTopographieGraphic.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "gui/gl/TYGeometryNodeGraphic.h"
#include "gui/tools/OGLArrayMesh.h"
#include "gui/tools/OGLMeshInstance.h"
#include "gui/tools/OGLPolyLineMesh.h"
#include "gui/tools/OGLSimpleMaterial.h"
#include <memory>
#include <qcolor.h>
#include <qmatrix4x4.h>
#include <qvector3d.h>
 
TYTopographieGraphic::TYTopographieGraphic(TYTopographie* pElement)
    : TYElementGraphic(pElement),
      _empriseMesh(std::make_shared<OGLPolyLineMesh>(OGLPolyLineMesh::EndType::Closed))
{
    OGLSimpleMaterial empriseMaterial;
    // Get emprise color
    float r = 0.0f, g = 0.0f, b = 0.0f;
#if TY_USE_IHM // L'emprise est de la couleur par defaut des polylines
    if (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "TYPolylineGraphicColorRR"))
    {
        TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "TYPolylineGraphicColorR", r, g, b);
    }
#endif
    empriseMaterial.color = QColor(r, g, b);
 
    _empriseMesh->setMaterial(empriseMaterial);
 
    recomputeEmpriseMesh();
}
 
void TYTopographieGraphic::update(bool force /*=false*/)
{
    // Cet element est toujours actif quelque soit le calcul courant
    if (getModified() || force)
    {
        getElement()->setInCurrentCalcul(true);
 
        recomputeEmpriseMesh();
    }
    TYElementGraphic::update(force);
}
 
void TYTopographieGraphic::getChilds(TYListPtrTYElementGraphic& childs, bool recursif /*=true*/)
{
    TYListPtrTYElementGraphic Localchilds;
 
    unsigned int i = 0;
 
    // 1 altimetry for all the site hierarchy. From the topography, retrieve the parent
    // site, and from this site, the root site and its altimetry.
    TYTopographie* pTYTopographie = getElement();
    LPTYSiteNode pParentSite = dynamic_cast<TYSiteNode*>(pTYTopographie->getParent());
    assert(pParentSite != nullptr && "The parent of a TYTopographie element must be a TYSiteNode");
    if (pParentSite->getRoot())
    {
        LPTYAltimetrie altimetrie = pParentSite->getAltimetry();
        Localchilds.push_back(altimetrie->getGraphicObject().getRealPointer());
    }
 
    // Courbes de niveau
    TYTabCourbeNiveauGeoNode* pTabCrbNiv = &getElement()->getListCrbNiv();
    for (i = 0; i < pTabCrbNiv->size(); i++)
    {
        TYCourbeNiveauGeoNode* pCrbNivGeoNode = pTabCrbNiv->operator[](i);
        Localchilds.push_back(pCrbNivGeoNode->getGraphicObject().getRealPointer());
    }
 
    // Plans d'eau
    TYTabPlanEauGeoNode* pTabPlanEau = &getElement()->getListPlanEau();
    for (i = 0; i < pTabPlanEau->size(); i++)
    {
        TYPlanEauGeoNode* pPlanEauGeoNode = pTabPlanEau->operator[](i);
        Localchilds.push_back(pPlanEauGeoNode->getGraphicObject().getRealPointer());
    }
 
    // Terrains
    TYTabTerrainGeoNode* pTabTerrain = &getElement()->getListTerrain();
    for (i = 0; i < pTabTerrain->size(); i++)
    {
        TYTerrainGeoNode* pTerrainGeoNode = pTabTerrain->operator[](i);
        Localchilds.push_back(pTerrainGeoNode->getGraphicObject().getRealPointer());
    }
 
    // Cours d'Eau
    TYTabCoursEauGeoNode* pTabCrsEau = &getElement()->getListCrsEau();
    for (i = 0; i < pTabCrsEau->size(); i++)
    {
        TYCoursEauGeoNode* pCrsEauGeoNode = pTabCrsEau->operator[](i);
        Localchilds.push_back(pCrsEauGeoNode->getGraphicObject().getRealPointer());
    }
 
    TYListPtrTYElementGraphic::iterator ite = Localchilds.begin();
    for (i = 0; i < Localchilds.size(); i++)
    {
        TYElementGraphic* pTYElementGraphic = (TYElementGraphic*)(*ite);
        childs.push_back(pTYElementGraphic);
        if (recursif)
        {
            pTYElementGraphic->getChilds(childs, recursif);
        }
        ite++;
    }
}
 
void TYTopographieGraphic::display(TYRenderContext& renderContext)
{
    unsigned int i = 0;
 
    TYTopographie* pTYTopographie = getElement();
    LPTYSiteNode pParentSite = dynamic_cast<TYSiteNode*>(pTYTopographie->getParent());
    if (pParentSite->getRoot())
    {
        assert(pParentSite != nullptr && "The parent of a TYTopographie element must be a TYSiteNode");
        LPTYAltimetrie altimetrie = pParentSite->getAltimetry();
        LPTYElementGraphic ElementGraphic = altimetrie->getGraphicObject();
        ElementGraphic->display(renderContext);
    }
 
    // Plans d'eau
    TYTabPlanEauGeoNode* pTabPlanEau = &getElement()->getListPlanEau();
    TYPlanEauGeoNode* pPlanEauGeoNode = NULL;
    for (i = 0; i < pTabPlanEau->size(); i++)
    {
        pPlanEauGeoNode = pTabPlanEau->operator[](i);
        pPlanEauGeoNode->getGraphicObject()->display(renderContext);
    }
 
    // Terrains
    TYTabTerrainGeoNode* pTabTerrain = &getElement()->getListTerrain();
    TYTerrainGeoNode* pTerrainGeoNode = NULL;
    for (i = 0; i < pTabTerrain->size(); i++)
    {
        pTerrainGeoNode = pTabTerrain->operator[](i);
        pTerrainGeoNode->getGraphicObject()->display(renderContext);
    }
 
    // Cours d'Eau
    TYTabCoursEauGeoNode* pTabCrsEau = &getElement()->getListCrsEau();
    TYCoursEauGeoNode* pCrsEauGeoNode = NULL;
    for (i = 0; i < pTabCrsEau->size(); i++)
    {
        pCrsEauGeoNode = pTabCrsEau->operator[](i);
        pCrsEauGeoNode->getGraphicObject()->display(renderContext);
    }
 
    // Courbes de niveau
    // xbh: les courbes de niveau en dernier et separement pour que l'anti-aliasing soit correct
    TYTabCourbeNiveauGeoNode* pTabCrbNiv = &getElement()->getListCrbNiv();
    TYCourbeNiveauGeoNode* pCrbNivGeoNode = NULL;
    for (i = 0; i < pTabCrbNiv->size(); i++)
    {
        pCrbNivGeoNode = pTabCrbNiv->operator[](i);
        pCrbNivGeoNode->getGraphicObject()->display(renderContext);
    }
}
 
void TYTopographieGraphic::setBackgroundImage(std::shared_ptr<QImage>& image, int semiX, int semiY,
                                              TYPoint ptPosition, OVector3D bgOrientation)
{
    TYTopographie* pTYTopographie = getElement();
    LPTYSiteNode pParentSite = dynamic_cast<TYSiteNode*>(pTYTopographie->getParent());
    assert(pParentSite != nullptr && "The parent of a TYTopographie element must be a TYSiteNode");
    if (pParentSite->getRoot())
    {
        LPTYAltimetrie altimetrie = pParentSite->getAltimetry();
        LPTYElementGraphic ElementGraphic = altimetrie->getGraphicObject();
        ((TYAltimetrieGraphic*)((TYElementGraphic*)ElementGraphic))
            ->setBackgroundImage(image, semiX, semiY, ptPosition, bgOrientation);
    }
}
 
void TYTopographieGraphic::unsetBackgroundImage()
{
    TYTopographie* pTYTopographie = getElement();
    LPTYSiteNode pParentSite = dynamic_cast<TYSiteNode*>(pTYTopographie->getParent());
    assert(pParentSite != nullptr && "The parent of a TYTopographie element must be a TYSiteNode");
    if (pParentSite->getRoot())
    {
        LPTYAltimetrie altimetrie = pParentSite->getAltimetry();
        LPTYElementGraphic ElementGraphic = altimetrie->getGraphicObject();
        ((TYAltimetrieGraphic*)((TYElementGraphic*)ElementGraphic))->unsetBackgroundImage();
    }
}
 
void TYTopographieGraphic::collectMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                                TYRenderContext* renderContext) const
{
    meshInstances.emplace_back(_empriseMesh, globalMatrix());
}
 
void TYTopographieGraphic::recomputeEmpriseMesh()
{
    std::vector<QVector3D> vertices;
    for (auto point : getElement()->getEmprise())
    {
        vertices.emplace_back(point._x, point._y, point._z);
    }
    _empriseMesh->setVertices(vertices);
}