TYSiteNodeGraphic.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 <cstddef>
#include <memory>
#include <qcolor.h>
#include <qimage.h>
#include <qmatrix4x4.h>
#include <qnamespace.h>
#include <qopengltexture.h>
#include <qsize.h>
#include "Tympan/models/business/infrastructure/TYSiteNode.h"
#include "Tympan/gui/gl/TYTopographieGraphic.h"
#include "TYSiteNodeGraphic.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include "gui/app/TYSiteModelerFrame.h"
#include "gui/tools/OGLMeshInstance.h"
#include "gui/tools/OGLRectangleMesh.h"
#include "gui/tools/OGLSimpleMaterial.h"
#include "models/common/acoustic_path.h"
 
TYSiteNodeGraphic::TYSiteNodeGraphic(TYSiteNode* pElement)
    : TYElementGraphic(pElement), _backgroundImage(std::shared_ptr<QImage>()),
      _imageMesh(std::make_shared<OGLRectangleMesh>(QSizeF(0., 0.)))
{
    _visible = true;
    updateBackgroundImage();
}
 
TYSiteNodeGraphic::~TYSiteNodeGraphic() {}
 
void TYSiteNodeGraphic::update(bool force /*=false*/)
{
    if (getModified() || force)
    {
        updateBackgroundImage();
        TYElementGraphic::update(force);
    }
}
 
void TYSiteNodeGraphic::updateBackgroundImage()
{
    TYSiteNode* pSite = getElement();
    QString topoFileName = pSite->getTopoFileName();
    if (_sOldTopoFile != topoFileName)
    {
        _sOldTopoFile = topoFileName;
        _backgroundImage = std::make_shared<QImage>();
        bool loaded = _backgroundImage->load(topoFileName);
        if (loaded)
        {
            *_backgroundImage = _backgroundImage->mirrored();
        }
        else
        {
            _backgroundImage.reset();
        }
        _imageMesh->material().image = _backgroundImage;
    }
    TYTopographieGraphic* topoGraphic =
        ((TYTopographieGraphic*)((TYElementGraphic*)getElement()->getTopographie()->getGraphicObject()));
    if (pSite->getUseTopoFile() && _backgroundImage != nullptr && !_backgroundImage->isNull())
    {
        float width = _backgroundImage->width() * getElement()->getEchelle();
        float height = _backgroundImage->height() * getElement()->getEchelle();
        _imageMesh->setDimensions({width, height});
        TYPoint pt = getElement()->getPosition();
        OVector3D vecOrientation = getElement()->getOrientation().toVector3D();
        topoGraphic->setBackgroundImage(_backgroundImage, width / 2, height / 2, pt, vecOrientation);
    }
    else
    {
        topoGraphic->unsetBackgroundImage();
    }
}
 
void TYSiteNodeGraphic::getChilds(TYListPtrTYElementGraphic& childs, bool recursif /*=true*/)
{
    TYElementGraphic* pTYElementGraphic = nullptr;
 
    pTYElementGraphic = getElement()->getTopographie()->getGraphicObject().getRealPointer();
    childs.push_back(pTYElementGraphic);
    if (recursif)
    {
        pTYElementGraphic->getChilds(childs, recursif);
    }
 
    pTYElementGraphic = getElement()->getInfrastructure()->getGraphicObject().getRealPointer();
    childs.push_back(pTYElementGraphic);
    if (recursif)
    {
        pTYElementGraphic->getChilds(childs, recursif);
    }
 
    // Sites childs
    TYSiteNode* pTYSiteNode = getElement();
    TYTabSiteNodeGeoNode& TabSite = pTYSiteNode->getListSiteNode();
    for (unsigned int i = 0; i < TabSite.size(); i++)
    {
        pTYElementGraphic = TabSite.at(i)->getGraphicObject().getRealPointer();
        childs.push_back(pTYElementGraphic);
        if (recursif)
        {
            pTYElementGraphic->getChilds(childs, recursif);
        }
    }
}
 
void TYSiteNodeGraphic::display(TYRenderContext& renderContext)
{
    if (!getElement()->isInCurrentCalcul())
    {
        return;
    }
 
    TYElementGraphic::display(renderContext);
 
    // Draw site node displayed in modeler site at z=0
    // Its subsites shall be drawn is same 3D referential
    float fSiteNodeAltitude = (float)getElement()->getAltiEmprise();
    glTranslatef(0.0f, 0.0f, -fSiteNodeAltitude);
 
    getElement()->getTopographie()->getGraphicObject()->display(renderContext);
    getElement()->getInfrastructure()->getGraphicObject()->display(renderContext);
    // Sites childs
    TYSiteNode* pTYSiteNode = getElement(); // az++
 
    glTranslatef(0.0f, 0.0f, 0.01f);
    TYTabSiteNodeGeoNode& TabSite = pTYSiteNode->getListSiteNode(); // az++
    for (unsigned int i = 0; i < TabSite.size(); i++)
    {
        // az++
        // Le site n'est affiché que s'il est dans le calcul courant
        if (TabSite.at(i)->getElement()->isInCurrentCalcul())
        {
            TYSiteNode* pTYSiteNodeChild = dynamic_cast<TYSiteNode*>(TabSite.at(i)->getElement());
            float fSiteNodeChildAltitude = pTYSiteNodeChild->getAltiEmprise();
            // Subsites must be drawn in their parent 3D referential
            glTranslatef(0.0f, 0.0f, fSiteNodeChildAltitude);
            TabSite.at(i)->getGraphicObject()->display(renderContext); // az++
            glTranslatef(0.0f, 0.0f, -fSiteNodeChildAltitude);
        }
    } // az++
 
    glTranslatef(0.0f, 0.0f, -0.01f + fSiteNodeAltitude);
}
 
void TYSiteNodeGraphic::collectMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                             TYRenderContext* renderContext) const
{
    bool renderBackgroundImage = getElement()->getUseTopoFile() && _imageMesh != nullptr;
    if (renderContext != nullptr)
    {
        renderBackgroundImage &= renderContext->showBackgroundImage;
    }
    if (renderBackgroundImage)
        if (getElement()->getUseTopoFile() && _imageMesh != nullptr)
        {
            QMatrix4x4 backgroundImageTransform;
            float fSiteNodeAltitude = (float)getElement()->getAltiEmprise();
            backgroundImageTransform.translate(0, 0, -fSiteNodeAltitude);
 
            double angle = 0.0;
            OVector3D vecOrientation = getElement()->getOrientation().toVector3D();
 
            // On verifie que le vecteur orientation n'est pas nul
            if (vecOrientation.norme() != 0)
            {
                // Calcul de l'angle
                angle = SIGNE(vecOrientation._y) * acos(vecOrientation._x / vecOrientation.norme());
                angle = (M_PI / 2.0) - angle;
            }
 
            float fImgZOffset = 0.1f;
            if (getElement()->getUseEmpriseAsCrbNiv())
            {
                fImgZOffset += (float)getElement()->getAltiEmprise();
            }
            backgroundImageTransform.translate(0, 0, fImgZOffset);
 
            backgroundImageTransform.rotate(angle * 180 / M_PI, 0.0, 0.0, 1.0);
 
            TYPoint pt = getElement()->getPosition();
            backgroundImageTransform.translate(pt._x, pt._y, pt._z);
 
            meshInstances.emplace_back(_imageMesh, globalMatrix() * backgroundImageTransform);
        }
}
 
#if TY_USE_IHM
void TYSiteNodeGraphic::connectUpdateSignal(QObject* pReceiver, const char* member)
{
    //  _pUpdateSignal->connect(pReceiver, member);
}
#endif // TY_USE_IHM
 
#if TY_USE_IHM
void TYSiteNodeGraphic::disconnectUpdateSignal(QObject* pReceiver, const char* member)
{
    //  _pUpdateSignal->disconnect(pReceiver, member);
}
#endif