TYAltimetrieGraphic.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/gui/app/TYSiteModelerFrame.h"
#include "gui/tools/OGLArrayMesh.h"
#include "gui/tools/OGLMesh.h"
#include "gui/tools/OGLMeshInstance.h"
#include "gui/tools/OGLSimpleMaterial.h"
#include "models/common/3d.h"
#include <memory>
#include <numeric>
#include <qcolor.h>
#include <qgenericmatrix.h>
#include <qimage.h>
#include <qmatrix4x4.h>
#include <qnamespace.h>
#include <qopengltexture.h>
#include <qpoint.h>
#include <qtransform.h>
#include <qvector2d.h>
#include <qvector3d.h>
#include <vector>
#ifdef _MSC_VER
    #pragma warning(disable : 4284)
#endif
 
#include "Tympan/core/color.h"
#include "Tympan/models/business/OLocalizator.h"
 
#include "Tympan/models/business/topography/TYAltimetrie.h"
 
#include "Tympan/gui/gl/TYPickingTable.h"
#include "Tympan/models/business/TYPreferenceManager.h"
 
#include "TYAltimetrieGraphic.h"
#include "Tympan/gui/gl/TYRenderContext.h"
#include <QtOpenGL>
 
#include <math.h>
 
#define IMG(id) OLocalizator::getPicture("TYAltimetrieGraphic", (id))
 
TYAltimetrieGraphic::TYAltimetrieGraphic(TYAltimetrie* pElement)
    : TYElementGraphic(pElement), _mesh(std::make_shared<OGLArrayMesh>())
{
    _mesh->setPrimitiveType(OGLPrivimitiveType::Triangles);
    _mesh->material().lightingMode = OGLSimpleMaterial::LightingMode::Shaded;
    float hueRange[2] = {0.4f, 0.15f};
    float saturationRange[2] = {1.0f, 0.8f};
    float valueRange[2] = {0.5f, 0.25f};
    TYColorManager::getLinearColorTable(256, hueRange, saturationRange, valueRange, _oColorMap);
    _angle = 0.0;
    _visible = false;
}
 
TYAltimetrieGraphic::~TYAltimetrieGraphic() {}
 
void TYAltimetrieGraphic::update(bool force /*=false*/)
{
    if (getModified() || force)
    {
        float minHue = 80.0f;
        float minSaturation = 255.0f;
        float minValue = 255.0f;
        float maxHue = 120.0f;
        float maxSaturation = 255.0f;
        float maxValue = 112.0f;
 
#if TY_USE_IHM
        // Couleurs
        if ((TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMinR")) &&
            (TYPreferenceManager::exists(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMaxR")))
        {
            TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMin", minHue,
                                          minSaturation, minValue);
 
            TYPreferenceManager::getColor(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMax", maxHue,
                                          maxSaturation, maxValue);
        }
        else
        {
            TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMin", minHue,
                                          minSaturation, minValue);
            TYPreferenceManager::setColor(TYDIRPREFERENCEMANAGER, "AltiGraphicColorMax", maxHue,
                                          maxSaturation, maxValue);
        }
#endif
        // Get shortest path between min hue and max hue
        float adjustedMaxHue = minHue + 180 - abs(abs(maxHue - minHue) - 180);
        float hueRange[2] = {minHue / 360.f, adjustedMaxHue / 360.f};
        float saturationRange[2] = {minSaturation / 255.f, maxSaturation / 255.f};
        float valueRange[2] = {minValue / 255.f, maxValue / 255.f};
        qDebug() << hueRange << saturationRange << valueRange;
        TYColorManager::getLinearColorTable(256, hueRange, saturationRange, valueRange, _oColorMap);
 
        TYElementGraphic::update(force);
    }
}
 
void TYAltimetrieGraphic::getChilds(TYListPtrTYElementGraphic& childs, bool recursif /*=true*/)
{
    for (int i = 0; i < getElement()->getListFaces().size(); i++)
    {
        TYElementGraphic* pTYElementGraphic = getElement()->getFace(i)->getGraphicObject();
        childs.push_back(pTYElementGraphic);
        if (recursif)
        {
            pTYElementGraphic->getChilds(childs, recursif);
        }
    }
}
 
OBox TYAltimetrieGraphic::computeBoundingBox() const
{
    OBox boundingBox;
 
    for (int i = 0; i < getElement()->getListFaces().size(); i++)
    {
        boundingBox.Enlarge((float)(getElement()->getFace(i)->getPoints()[0]._x),
                            (float)(getElement()->getFace(i)->getPoints()[0]._y),
                            (float)(getElement()->getFace(i)->getPoints()[0]._z));
        boundingBox.Enlarge((float)(getElement()->getFace(i)->getPoints()[1]._x),
                            (float)(getElement()->getFace(i)->getPoints()[1]._y),
                            (float)(getElement()->getFace(i)->getPoints()[1]._z));
        boundingBox.Enlarge((float)(getElement()->getFace(i)->getPoints()[2]._x),
                            (float)(getElement()->getFace(i)->getPoints()[2]._y),
                            (float)(getElement()->getFace(i)->getPoints()[2]._z));
    }
    return boundingBox;
}
 
void TYAltimetrieGraphic::display(TYRenderContext& renderContext)
{
    if (getElement() == NULL)
    {
        return;
    }
 
    if (_visible && renderContext.type == TYRenderType::Picking)
    {
        TYPickingTable::addElement(getElement());
        glPushName((GLuint)(TYPickingTable::getIndex()));
 
        for (int i = 0; i < getElement()->getListFaces().size(); i++)
        {
            TYElementGraphic* pTYElementGraphic = getElement()->getFace(i)->getGraphicObject();
            LPTYPolygonGraphic pPolygonGraphic = (TYPolygonGraphic*)pTYElementGraphic;
            if (pPolygonGraphic != NULL)
            {
                pPolygonGraphic->display(renderContext);
            }
        }
 
        glPopName();
    }
}
 
void TYAltimetrieGraphic::setBackgroundImage(std::shared_ptr<QImage>& image, int semiX, int semiY,
                                             TYPoint ptPosition, OVector3D bgImageOrientation)
{
    _image = image;
    _semiX = semiX;
    _semiY = semiY;
    _imagePosition = ptPosition;
    _bgImageOrientation = bgImageOrientation;
    update(true);
}
 
void TYAltimetrieGraphic::unsetBackgroundImage()
{
    _image.reset();
    _semiX = 0;
    _semiY = 0;
    _imagePosition = TYPoint();
    _bgImageOrientation = OVector3D();
}
 
void TYAltimetrieGraphic::collectMeshInstances(std::vector<OGLMeshInstance>& meshInstances,
                                               TYRenderContext* renderContext) const
{
    bool renderBackgroundImage = _image != nullptr;
 
    // Texture transform
    double angle = 0.0;
    OVector3D vecOrientation = _bgImageOrientation;
 
    // 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;
    }
    QMatrix4x4 backgroundImageTransform;
    backgroundImageTransform.translate(0.5, 0.5);
    backgroundImageTransform.scale(1. / _semiX / 2, 1. / _semiY / 2, 1);
    backgroundImageTransform.translate(-_imagePosition._x, -_imagePosition._y);
    backgroundImageTransform.rotate(-angle * 180 / M_PI, 0, 0, 1);
 
    std::vector<QVector3D> vertices;
    std::vector<QVector3D> normals;
    std::vector<QVector2D> textureCoordinates;
    std::vector<QColor> verticesColors;
    float zmin = NAN, zmax = NAN, zrange = NAN;
    zmin = boundingBox()._min._z;
    zmax = boundingBox()._max._z;
    zrange = zmax - zmin;
    for (auto face : getElement()->getListFaces())
    {
        OVector3D normal = face->normal();
        for (int i : {0, 1, 2})
        {
            OPoint3D point = face->getPoint(i);
            vertices.emplace_back(point._x, point._y, point._z);
            normals.emplace_back(normal._x, normal._y, normal._z);
            if (zrange != 0)
            {
                float scalar = (point._z - zmin) / zrange;
                verticesColors.emplace_back(_oColorMap[scalar * 255]);
            }
            textureCoordinates.emplace_back(backgroundImageTransform * QVector3D(point._x, point._y, 1));
        }
    }
    if (renderBackgroundImage)
    {
        _mesh->material().image = _image;
        _mesh->material().textureBlend = OGLSimpleMaterial::TextureBlend::Overlay;
    }
    else
    {
        _mesh->material().image = nullptr;
        _mesh->material().textureBlend = OGLSimpleMaterial::TextureBlend::Multiply;
    }
    _mesh->setNormals(normals);
    _mesh->setVertices(vertices);
    std::vector<unsigned int> indices(vertices.size());
    std::iota(indices.begin(), indices.end(), 0);
    _mesh->setIndices(indices);
    _mesh->setVerticesColors(verticesColors);
    _mesh->setTextureCoordinates(textureCoordinates);
    _mesh->material().lightingMode = OGLSimpleMaterial::LightingMode::Shaded;
    meshInstances.emplace_back(_mesh, globalMatrix());
}