TYElementPicker.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/TYRectangularMaillage.h"
#include "Tympan/models/business/TYLinearMaillage.h"
#include "Tympan/gui/gl/TYPickHandler.h"
#include "Tympan/gui/widgets/TYWidget.h"
#include "Tympan/gui/gl/TYPickingTable.h"
#include "Tympan/gui/app/TYApplication.h"
#include "Tympan/gui/app/TYModelerFrame.h"
#include "TYElementPicker.h"
#include "Tympan/gui/gl/TYRenderContext.h"
 
static const float MaillagePickingTolerance = 1.0f;
 
#define BUFSIZE 512
 
TYElementPicker::TYElementPicker(TYModelerFrame* pModeler)
{
    Q_CHECK_PTR(pModeler);
    _pModeler = pModeler;
 
    _pLastPickedElt = NULL;
    _pHighlightedGraphicObject = NULL;
    //_pOutlineActor = NULL;//az--: plus utilise
 
    _x = 0;
    _y = 0;
}
 
TYElementPicker::~TYElementPicker() {}
 
bool TYElementPicker::pick(int x, int y)
{
    bool res = true;
 
    _x = x;
    _y = y;
 
    GLuint selectBuf[BUFSIZE], names = 0, *ptr = nullptr;
    GLint hits = 0;
 
    glSelectBuffer(BUFSIZE, selectBuf);
    (void)glRenderMode(GL_SELECT);
 
    glInitNames();
    QRect viewport = _pModeler->getView()->getViewport();
    glViewport(viewport.x(), viewport.y(), viewport.width(), viewport.height());
    TYRenderContext renderContext = _pModeler->createRenderContext();
    renderContext.type = TYRenderType::Picking;
 
    _pModeler->getView()->getRenderer()->OpenGLRender(renderContext, x, y);
 
    hits = glRenderMode(GL_RENDER);
 
    _pLastPickedElt = NULL;
    int i = 0, j = 0;
 
    ptr = (GLuint*)selectBuf;
 
    TYElement* pElementAutreQueAltimetrie = NULL; // az++
    float zmin = (float)0xFFFFFFFF;               // az++
    float zElementAutreQueAltimetrie = -1;
 
    for (i = 0; i < hits; i++) // Pour chaque primitive OpenGL
    {
        // nombre de noms
        names = *ptr;
        ptr++; // Recuperer la liste de nom correspondant a ce hit
        // z1 : distance minimale, toujours positive
        float z1 = *ptr;
        ptr++;
        // z2 : distance maximale, toujours positive
        ptr++;
 
        TYElement* pElementCourant = NULL; // az++
        QString sCurrentClassName;
        for (j = 0; j < (int)names; j++)
        {
            pElementCourant = TYPickingTable::getElement(*ptr);
            sCurrentClassName = QString(pElementCourant->getClassName());
            if (sCurrentClassName != "TYAltimetrie")
            {
                if (NULL == pElementAutreQueAltimetrie)
                {
                    pElementAutreQueAltimetrie = pElementCourant;
                    zElementAutreQueAltimetrie = z1;
                }
                else
                {
                    if (z1 < zElementAutreQueAltimetrie)
                    {
                        pElementAutreQueAltimetrie = pElementCourant;
                        zElementAutreQueAltimetrie = z1;
                    }
                    else if (z1 == zElementAutreQueAltimetrie)
                    {
                        // Cas des cheminees et autres bouches sur Face, voir des fenetres sur les murs
                        if (pElementAutreQueAltimetrie == pElementCourant->getParent())
                        {
                            pElementAutreQueAltimetrie = pElementCourant;
                            zElementAutreQueAltimetrie = z1;
                        }
                    }
                }
            }
            else
            {
                if (z1 < zmin) // az++
                {
                    // on s'interresse aux z les plus proches
                    zmin = z1;
                    _pLastPickedElt = TYPickingTable::getElement(*ptr);
                }
            }
            ptr++;
        }
    }
    if (pElementAutreQueAltimetrie)
    {
        _pLastPickedElt = pElementAutreQueAltimetrie;
    }
 
    TYPickingTable::purgeElements();
 
    if (_pLastPickedElt)
    {
        writeDebugMsg(QString("Element picke de type : ") + QString(_pLastPickedElt->getClassName()));
 
        // Qq chose de picker
        emit(elementPicked(_pLastPickedElt));
 
        // Recherche des parents
        updateParents(_pLastPickedElt);
    }
    else
    {
        res = false;
    }
 
    return res;
}
 
void TYElementPicker::highlightElement(TYElement* pElt)
{
    bool change = false;
 
    if (_pHighlightedGraphicObject)
    {
        _pHighlightedGraphicObject->setBoundingBoxVisible(false);
        _pHighlightedGraphicObject = NULL;
    }
 
    if (!pElt)
    {
        return;
    }
 
    if (_pHighlightedGraphicObject != pElt->getGraphicObject())
    {
        change = true;
    }
 
    if (!pElt->isA("TYPoint"))
    {
        // On conserve un pointeur sur l'objet graphique
        _pHighlightedGraphicObject = pElt->getGraphicObject();
        _pHighlightedGraphicObject->setBoundingBoxVisible(); // az++
    }
 
    if (change)
    {
        _pModeler->getView()->getRenderer()->invalidateScene();
    } // az++ test
 
    _pModeler->updateView(false, false);
}
 
void TYElementPicker::reset()
{
    if (_pHighlightedGraphicObject)
    {
        _pHighlightedGraphicObject->setBoundingBoxVisible(false);
        _pHighlightedGraphicObject = NULL;
    }
 
    _pLastPickedElt = NULL;
    _pModeler->getView()->getRenderer()->invalidateScene(); // az++ test
 
    _pModeler->getView()->update();
}
 
void TYElementPicker::updateParents(TYElement* pElt)
{
    if (!pElt)
    {
        return;
    }
 
    std::shared_ptr<LPTYElementArray> pElts(new LPTYElementArray());
    TYElement* pTmpElt = pElt;
 
    while (pTmpElt != NULL)
    {
        // Cas particulier du maillage
        TYMaillage* pMail = dynamic_cast<TYMaillage*>(pTmpElt);
        if (pMail != nullptr)
        {
            // Recherche du point de calcul clicke
            TYElement* pPtCalcul = findPointCalculOnMaillage(pMail);
 
            // Detecte le type pour emettre le signal
            if (checkType(pPtCalcul))
            {
                // Ajout
                pElts->push_back(pPtCalcul);
            }
        }
 
        // Detecte le type pour emettre le signal
        checkType(pTmpElt); // DT-- le 31/08/04
 
        // Ajoute a la collection
        pElts->push_back(pTmpElt);
 
        // Recupere le parent
        pTmpElt = pTmpElt->getParent();
    }
 
    // Au moins un parent a ete trouve
    if (pElts->size() > 1)
    {
        // On signale le dernier parent trouve.
        emit(highestParentPicked(pElts->back()));
    }
 
    emit(elementCollectionPicked(pElts));
}
 
bool TYElementPicker::checkType(TYElement* pElt)
{
    if (!pElt)
    {
        return false;
    }
 
    bool ret = true;
 
    if (pElt->isA("TYPoint"))
    {
        emit(pointPicked(pElt));
    }
    else if (pElt->isA("TYPointCalcul"))
    {
        emit(pointCalculPicked(pElt));
    }
    else if (pElt->isA("TYPointControl"))
    {
        emit(pointControlPicked(pElt));
    }
    else if (pElt->isA("TYTerrain"))
    {
        emit(terrainPicked(pElt));
    }
    else if (pElt->isA("TYPlanEau"))
    {
        emit(planEauPicked(pElt));
    }
    else if (pElt->isA("TYCourbeNiveau"))
    {
        emit(courbeNiveauPicked(pElt));
    }
    else if (pElt->isA("TYUserSourcePonctuelle"))
    {
        emit(sourcePonctuellePicked(pElt));
    }
    else if (pElt->isA("TYAcousticLine"))
    {
        emit(acousticLinePicked(pElt));
    }
    else if (pElt->isA("TYReseauTransport"))
    {
        emit(reseauTransportPicked(pElt));
    }
#if WITH_NMPB
    else if (pElt->isA("TYRoute"))
    {
        emit(routePicked(pElt));
    }
#endif
    else if (pElt->isA("TYCoursEau"))
    {
        emit(coursEauPicked(pElt));
    }
    else if (pElt->isA("TYAcousticRectangle"))
    {
        emit(acousticRectanglePicked(pElt));
    }
    else if (pElt->isA("TYMurElement"))
    {
        emit(murElementPicked(pElt));
    }
    else if (pElt->isA("TYDalle"))
    {
        emit(dallePicked(pElt));
    }
    else if (pElt->isA("TYAcousticCircle"))
    {
        emit(acousticCirclePicked(pElt));
    }
    else if (pElt->isA("TYAcousticSemiCircle"))
    {
        emit(acousticSemiCirclePicked(pElt));
    }
    else if (pElt->isA("TYAcousticCylinder"))
    {
        emit(acousticCylinderPicked(pElt));
    }
    else if (pElt->isA("TYAcousticSemiCylinder"))
    {
        emit(acousticSemiCylinderPicked(pElt));
    }
    else if (pElt->isA("TYMaillage"))
    {
        emit(maillagePicked(pElt));
    }
    else if (pElt->isA("TYRectangularMaillage"))
    {
        emit(rectangularMaillagePicked(pElt));
    }
    else if (pElt->isA("TYLinearMaillage"))
    {
        emit(linearMaillagePicked(pElt));
    }
    else if (pElt->isA("TYAcousticRectangleNode"))
    {
        emit(acousticRectangleNodePicked(pElt));
    }
    else if (pElt->isA("TYMur"))
    {
        emit(murPicked(pElt));
    }
    else if (pElt->isA("TYAcousticBox"))
    {
        emit(acousticBoxPicked(pElt));
    }
    else if (pElt->isA("TYAcousticVolumeNode"))
    {
        emit(acousticVolumeNodePicked(pElt));
    }
    else if (pElt->isA("TYEtage"))
    {
        emit(etagePicked(pElt));
    }
    else if (pElt->isA("TYMachine"))
    {
        emit(machinePicked(pElt));
    }
    else if (pElt->isA("TYBatiment"))
    {
        emit(batimentPicked(pElt));
    }
    else if (pElt->isA("TYTopographie"))
    {
        emit(topographiePicked(pElt));
    }
    else if (pElt->isA("TYSiteNode"))
    {
        emit(sitePicked(pElt));
    }
    else if (pElt->isA("TYSiteNode")) //???
    {
        emit(siteNodePicked(pElt));
    }
    else if (pElt->isA("TYEcran"))
    {
        emit(ecranPicked(pElt));
    }
    else if (pElt->isA("TYAcousticFaceSet"))
    {
        emit(acousticFaceSetPicked(pElt));
    }
    else
    {
        ret = false;
    }
 
    return ret;
}
 
TYPointCalcul* TYElementPicker::findPointCalculOnMaillage(TYMaillage* pMaillage)
{
    Q_ASSERT(pMaillage);
    TYPointCalcul* pPtCalcul = NULL;
 
    float mapperPos[2];
    mapperPos[0] = _x;
    mapperPos[1] = _y;
 
    for (unsigned int i = 0; i < pMaillage->getPtsCalcul().size(); i++)
    {
        pPtCalcul = pMaillage->getPtsCalcul()[i];
        Q_ASSERT(pPtCalcul);
 
        if ((mapperPos[0] <= pPtCalcul->_x + MaillagePickingTolerance) &&
            (mapperPos[0] >= pPtCalcul->_x - MaillagePickingTolerance) &&
            (mapperPos[1] >= pPtCalcul->_y - MaillagePickingTolerance) &&
            (mapperPos[1] <= pPtCalcul->_y + MaillagePickingTolerance))
        {
            // Point trouve
            return pPtCalcul;
        }
    }
 
    return NULL;
}