TYAcousticPathFinder.cpp

Go to the documentation of this file.

/*
 * Copyright (C) <2012> <EDF-R&D> <FRANCE>
 * This program 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.
 * This program 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, write to the Free Software Foundation, Inc.,
 * 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA.
 */
 
#include "Tympan/models/solver/config.h"
#include "Tympan/geometric_methods/ConvexHullFinder/TYCalculParcours.h"
#include "TYSolver.h"
#include "TYAcousticPathFinder.h"
 
TYAcousticPathFinder::TYAcousticPathFinder(TYSolver& solver) : _solver(solver), _bCalcTrajetHorizontaux(false)
{
}
 
TYAcousticPathFinder::~TYAcousticPathFinder() {}
 
void TYAcousticPathFinder::init()
{
    _bCalcTrajetHorizontaux = tympan::SolverConfiguration::get()->UseLateralDiffraction;
}
 
void TYAcousticPathFinder::computePath(const std::deque<TYSIntersection>& tabIntersect,
                                       const TYTrajet& trajet, TabPoint3D& ptsTop, TabPoint3D& ptsLeft,
                                       TabPoint3D& ptsRight)
{
    bool dessus = true, lateral = false;
 
    // Construction du rayon SR
    OSegment3D rayon;
    trajet.getPtSetPtRfromOSeg3D(rayon);
 
    // Determination du parcours et calcul des chemins
    // 1. Parcours vertical
    // le dernier ptsTop n'est pas affecte
    computeParcoursLateraux(tabIntersect, rayon, dessus, ptsTop, ptsTop);
 
    // Parcours gauche & droits si necessaire
    computeParcoursLateraux(tabIntersect, rayon, lateral, ptsLeft, ptsRight);
}
 
bool TYAcousticPathFinder::computeParcoursLateraux(const std::deque<TYSIntersection>& tabIntersect,
                                                   const OSegment3D& rayon, const bool& dessus,
                                                   TabPoint3D& ptsLeft, TabPoint3D& ptsRight) const
{
    // Si on est en trajet lateral non demande par le calcul
    if (!_bCalcTrajetHorizontaux && !dessus)
    {
        return false;
    }
 
    size_t nbFaces = tabIntersect.size();
 
    short indiceIntersect = dessus ? 0 : 1;
    TYCalculParcours Parcours(static_cast<int>(nbFaces), dessus != 0); // dessus = vue de cote
 
    // Quoiqu'il arrive, on ajoute la source:
    ptsLeft.push_back(rayon._ptA);
    // Si on a une vue de haut, on doit aussi calculer les trajets a droite:
    if (!dessus)
    {
        ptsRight.push_back(rayon._ptA);
    }
 
    // Creation du segment SR
    Parcours.AjouterSegmentSR(const_cast<double*>(rayon._ptA._value), const_cast<double*>(rayon._ptB._value));
 
    for (size_t i = 0; i < nbFaces; i++)
    {
        if (tabIntersect[i].bIntersect[indiceIntersect])
        {
            TYSIntersection inter = tabIntersect[i];
            Parcours.AjouterSegmentCoupe((double*)inter.segInter[indiceIntersect]._ptA._value,
                                         (double*)inter.segInter[indiceIntersect]._ptB._value, inter.isInfra,
                                         inter.isEcran);
        }
    }
 
    // Traitement du parcours
    Parcours.Traitement();
 
    // La liste a retourner ne contient pas le dernier point (Recepteur)
    // On retourne 2 listes si on est en vue de haut (parcours lateraux),
    // sinon une seule (vue de face => trajet par dessus les obstacles)
    double dPointTemp[3];
    // Que l'on soit en vue de haut ou non, il faut le trajet gauche
    int nNbrePointsTrajetGauche = Parcours.NombrePointsTrajetGauche();
    OPoint3D pt;
    for (int j = 1; j < (nNbrePointsTrajetGauche - 1);
         j++) //-1: pas de recepteur en sortie; 1 car la source a deja ete ajoutee
    {
        Parcours.PointTrajetGauche(j, dPointTemp);
        pt._x = dPointTemp[0];
        pt._y = dPointTemp[1];
        pt._z = dPointTemp[2]; // x y z
        ptsLeft.push_back(pt);
    }
 
    if (!dessus)
    {
        int nNbrePointsTrajetDroite = Parcours.NombrePointsTrajetDroite();
        OPoint3D pt;
        for (int j = 1; j < (nNbrePointsTrajetDroite - 1);
             j++) //-1: pas de recepteur en sortie; 1 car la source a deja ete ajoutee
        {
            Parcours.PointTrajetDroite(j, dPointTemp);
            pt._x = dPointTemp[0];
            pt._y = dPointTemp[1];
            pt._z = dPointTemp[2]; // x y z
            ptsRight.push_back(pt);
        }
    }
 
    return true;
}