TYCalculParcours.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 <stdio.h>
#include <math.h>
 
#include "Tympan/models/common/3d.h"
#include "TYCalculParcours.h"
#include <assert.h>
 
int nNbAbandonsParPointNuples = 0;
 
TYCalculParcours::TYCalculParcours(int nNbSegMax, bool bVertical)
{
    _bVertical = bVertical;
    _nNbSegMax = nNbSegMax;
    // Creation d'un set geometrique pour les donnees d'entree:
    _geoImporterDXF = new TYSetGeometriqueParcours;
    _geoImporterDXF->_nNbPolylines = 0;
    _geoImporterDXF->AllouerPolylignes(_nNbSegMax);
    _geoImporterDXF->_nNbPointTotal = 0;
    _geoImporterDXF->_ListePoint = new TYPointParcours[2 * _nNbSegMax];
 
    // Creation d'un set geometrique pour le segment d'entree Source-Recepteur:
    _geoSR = new TYSetGeometriqueParcours;
    _geoSR->_nNbPolylines = 0;
    _geoSR->AllouerPolylignes(1);
    _geoSR->_nNbPointTotal = 0;
    _geoSR->_ListePoint = new TYPointParcours[2];
 
    _vectorPoint.clear();
    _estUnPointIntersectant.clear();
}
 
TYCalculParcours::~TYCalculParcours()
{
    SAFE_DELETE(_geoImporterDXF);
    SAFE_DELETE(_geoSR);
    _vectorPoint.clear();
    _estUnPointIntersectant.clear();
}
 
void TYCalculParcours::InitChangementVariable2D3D(bool bAxeXMoinsSignifiant)
{
    // Changement de variable en entree pour traitement 2D (une coordonnee ne sera pas prise en compte)
    if (_bVertical)
    {
        // Lorsque le rayon Source-Recepteur est plus oriente suivant Y que X (repere Tympan),
        // on garde Y (au lieu de X) comme seconde composante (apres Z, l'altitude = la premiere composante
        // 2D). Remarques :
        //* la composante ignoree est tout de meme stockee et restituee a la fin (cgangement de variable)
        //* on ne fait que choisir des points existants
        //(on n'en calcule pas de nouveaux -du moins pour le calcul vertical-)
        //* pour les calculs horizontaux, seuls les points sur le trajet Source-Recepteur sont susceptibles
        // d'etre issus de calculs au lieu de selection. La coordonnee Z de ces points resulte alors d'une
        // interpollation (cf methode IntersectionDroites) Exemple: le rayon Source-Recepteur est parallele a
        // l'axe Y; dans ce cas, le plan 2D est (0y, 0z)
        if (bAxeXMoinsSignifiant)
        {
            _indexXInOut = 1; // Y->X
            _indexYInOut = 2; // Z->Y
            _indexZInOut = 0; // X->Z
        }
        else
        {
            _indexXInOut = 0;
            _indexYInOut = 2; // Z->Y
            _indexZInOut = 1; // Y->Z
        }
    }
    else
    {
        _indexXInOut = 0;
        _indexYInOut = 1;
        _indexZInOut = 2;
    }
}
 
TYCalculParcours::TYCalculParcours(TYSetGeometriqueParcours* geoImporterDXF, TYSetGeometriqueParcours* geoSR,
                                   bool bVertical)
{
    _geoSR = geoSR;
    _geoImporterDXF = geoImporterDXF;
    _bVertical = bVertical;
    _nNbSegMax = -1; // on se souvient que les polylignes ont ete importees petit a petit
}
 
void TYCalculParcours::AjouterSegment(double* ptA, double* ptB, bool isInfra, bool isEcran,
                                      TYSetGeometriqueParcours* geo)
{
    // create point1 from ptA
    TYPointParcours p1_temp;
    p1_temp.isInfra = isInfra;
    p1_temp.isEcran = isEcran;
    p1_temp.x = ptA[_indexXInOut];
    p1_temp.y = ptA[_indexYInOut];
    p1_temp.z = ptA[_indexZInOut];
 
    // create point2 from ptB
    TYPointParcours p2_temp;
    p2_temp.isInfra = isInfra;
    p2_temp.isEcran = isEcran;
    p2_temp.x = ptB[_indexXInOut];
    p2_temp.y = ptB[_indexYInOut];
    p2_temp.z = ptB[_indexZInOut];
 
    bool ptA_AlreadyExists = false;
    bool ptB_AlreadyExists = false;
 
    int indicePt1Doublon = -1;
    int indicePt2Doublon = -1;
 
    // verifier si ptA et ptB pas de doublons dans la liste de point
    for (int i = static_cast<int>(_vectorPoint.size()) - 1; i >= 0; i--)
    {
        if ((_vectorPoint[i]->Identifiant != INDENTIFIANT_SOURCE) &&
            (_vectorPoint[i]->Identifiant != INDENTIFIANT_RECEPTEUR) &&
            (_vectorPoint[i]->isEcran == p1_temp.isEcran) && (_vectorPoint[i]->isInfra == p1_temp.isInfra) &&
            TYPointParcours::Confondus(_vectorPoint[i], &p1_temp))
        {
            ptA_AlreadyExists = true;
            indicePt1Doublon = i;
            break;
        }
    }
 
    for (int i = static_cast<int>(_vectorPoint.size()) - 1; i >= 0; i--)
    {
        if ((_vectorPoint[i]->Identifiant != INDENTIFIANT_SOURCE) &&
            (_vectorPoint[i]->Identifiant != INDENTIFIANT_RECEPTEUR) &&
            (_vectorPoint[i]->isEcran == p2_temp.isEcran) && (_vectorPoint[i]->isInfra == p2_temp.isInfra) &&
            TYPointParcours::Confondus(_vectorPoint[i], &p2_temp))
        {
            ptB_AlreadyExists = true;
            indicePt2Doublon = i;
            break;
        }
    }
 
    if (ptA_AlreadyExists & !ptB_AlreadyExists)
    { // SI doublon ptA
        TYPointParcours* p2 = &(geo->_ListePoint[geo->_nNbPointTotal]);
        p2->isInfra = isInfra;
        p2->isEcran = isEcran;
        p2->x = ptB[_indexXInOut];
        p2->y = ptB[_indexYInOut];
        p2->z = ptB[_indexZInOut];
        p2->Identifiant = geo->_nNbPointTotal;
        p2->Identifiant = geo->_nNbPointTotal;
        _vectorPoint.push_back(p2);
        geo->_nNbPointTotal++;
        geo->_ListePolylines[geo->_nNbPolylines].ajouteSegment(_vectorPoint[indicePt1Doublon], p2);
        geo->_nNbPolylines++;
        // delete p1;
    }
    else if (!ptA_AlreadyExists & ptB_AlreadyExists)
    { // SI doublon ptB
        TYPointParcours* p1 = &(geo->_ListePoint[geo->_nNbPointTotal]);
        p1->isInfra = isInfra;
        p1->isEcran = isEcran;
        p1->x = ptA[_indexXInOut];
        p1->y = ptA[_indexYInOut];
        p1->z = ptA[_indexZInOut];
        p1->Identifiant = geo->_nNbPointTotal;
        p1->Identifiant = geo->_nNbPointTotal;
        _vectorPoint.push_back(p1);
        geo->_nNbPointTotal++;
        geo->_ListePolylines[geo->_nNbPolylines].ajouteSegment(p1, _vectorPoint[indicePt2Doublon]);
        geo->_nNbPolylines++;
        // delete p2;
    }
    else if (ptA_AlreadyExists & ptB_AlreadyExists)
    { // SI doublon ptA et ptB
        geo->_ListePolylines[geo->_nNbPolylines].ajouteSegment(_vectorPoint[indicePt1Doublon],
                                                               _vectorPoint[indicePt2Doublon]);
        geo->_nNbPolylines++;
        // delete p1,p2;
    }
    else
    { // SI aucun doublon
        TYPointParcours* p1 = &(geo->_ListePoint[geo->_nNbPointTotal]);
        p1->isInfra = isInfra;
        p1->isEcran = isEcran;
        p1->x = ptA[_indexXInOut];
        p1->y = ptA[_indexYInOut];
        p1->z = ptA[_indexZInOut];
        p1->Identifiant = geo->_nNbPointTotal;
 
        p1->Identifiant = geo->_nNbPointTotal;
        geo->_nNbPointTotal++;
        TYPointParcours* p2 = &(geo->_ListePoint[geo->_nNbPointTotal]);
        p2->isInfra = isInfra;
        p2->isEcran = isEcran;
        p2->x = ptB[_indexXInOut];
        p2->y = ptB[_indexYInOut];
        p2->z = ptB[_indexZInOut];
        p2->Identifiant = geo->_nNbPointTotal;
        p2->Identifiant = geo->_nNbPointTotal;
        geo->_nNbPointTotal++;
        _vectorPoint.push_back(p1);
        _vectorPoint.push_back(p2);
        // On ajoute une polyligne a geo:
        geo->_ListePolylines[geo->_nNbPolylines].ajouteSegment(p1, p2);
        geo->_nNbPolylines++;
    }
}
 
void TYCalculParcours::AjouterSegmentCoupe(double* ptA, double* ptB, bool isInfra, bool isEcran)
{
    assert(_geoImporterDXF->_nNbPolylines <= _nNbSegMax);
    AjouterSegment(ptA, ptB, isInfra, isEcran, _geoImporterDXF);
}
 
void TYCalculParcours::AjouterSegmentSR(double* ptA, double* ptB)
{
    assert(_geoSR->_nNbPointTotal == 0);
    assert(_geoSR->_nNbPolylines == 0);
    // On fait ici le choix du systeme de coordonnee:
    double dDeltaX = fabs(ptA[0] - ptB[0]);
    double dDeltaY = fabs(ptA[1] - ptB[1]);
    InitChangementVariable2D3D(dDeltaX < dDeltaY);
    // InitChangementVariable2D3D(ptA[0] == ptB[0]);
    AjouterSegment(ptA, ptB, false, false, _geoSR);
 
    // On attribue des identifiants speciaux aux points S & R, pour ne pas les melanger a d'autres
    _geoSR->_ListePoint[0].Identifiant = INDENTIFIANT_SOURCE;
    _geoSR->_ListePoint[1].Identifiant = INDENTIFIANT_RECEPTEUR;
}
 
void TYCalculParcours::PointTrajetGauche(int i, double* pt)
{
    PointTrajet(i, pt, _geoTrajetGauche);
}
 
void TYCalculParcours::PointTrajetDroite(int i, double* pt)
{
    PointTrajet(i, pt, _geoTrajetDroite);
}
 
void TYCalculParcours::PointTrajet(int i, double* pt, TYSetGeometriqueParcours* geo)
{
    assert(i < geo->_nNbPointTotal);
    pt[_indexXInOut] = geo->_ListePoint[i].x;
    pt[_indexYInOut] = geo->_ListePoint[i].y;
    pt[_indexZInOut] = geo->_ListePoint[i].z;
}
 
int TYCalculParcours::NombrePointsTrajetDroite()
{
    if (_geoTrajetDroite == nullptr)
    {
        return 0;
    }
 
    double ptA[3];
    double ptB[3];
    PointTrajet(0, ptA, _geoSR);
    PointTrajet(1, ptB, _geoSR);
 
    return _geoTrajetDroite->_nNbPointTotal;
}
 
int TYCalculParcours::NombrePointsTrajetGauche()
{
    if (_geoTrajetGauche == nullptr)
    {
        return 0;
    }
 
    double ptA[3];
    double ptB[3];
    PointTrajet(0, ptA, _geoSR);
    PointTrajet(1, ptB, _geoSR);
 
    return _geoTrajetGauche->_nNbPointTotal;
}
 
bool TYCalculParcours::Traitement()
{
    _geoTrajetGauche = nullptr;
    _geoTrajetDroite = nullptr;
 
    bool resTraitement =
        Traite(_geoDernierePasseGauche, _geoDernierePasseDroite, _geoTrajetGauche, _geoTrajetDroite);
 
    return resTraitement;
}
 
bool TYCalculParcours::CalculTrajet(TYSetGeometriqueParcours& geoCourant, bool bCoteGauche,
                                    bool* PointsAGauche, bool* PointsADroite,
                                    TYSetGeometriqueParcours& geoPremierePasse,
                                    TYSetGeometriqueParcours*& geoTrajet)
{
    bool bPasEnferme = true;
    // 3.4 Calcul des trajets
    // A partir de maintenant, on ne traite plus qu'un seul cote
    // bool bCoteGauche = true;
    // 3.4.1 Ramener les points traversant la frontiere sur la frontiere
    int* IndexePointsFrontiere = new int[geoCourant._nNbPointTotal];
    int NbPointsFrontiere = 0;
 
    // on considere ici que les polylignes sont en fait des segments (vrai venant de Tympan)
    geoCourant.RamenerPointsTraversantLaFrontiere(
        _geoSR->_ListePoint[0], _geoSR->_ListePoint[1], IndexePointsFrontiere, NbPointsFrontiere,
        _estUnPointIntersectant, bCoteGauche, PointsAGauche, PointsADroite);
 
    // On va plus loin que s'il y a des points d'intersection (sinon, c'est SR)
    if (NbPointsFrontiere)
    {
        // 3.4.2 Mettre bout a bout les polylignes
        // Merger les segments: on considere ici que chaque point ne peut appartenir a plus de 2 polylignes (a
        // verifier en venant de Tympan)
        Connexite* Connexes = new Connexite[geoCourant._nNbPointTotal];
 
        bool bOk = geoCourant.ListerPointsConnexes(Connexes, _estUnPointIntersectant);
        if (!bOk)
        {
            bPasEnferme = false; // on a trouve des points n-uples; comme on ne sait pas les gerer, on
                                 // pretexte un enfermemnt
            nNbAbandonsParPointNuples++;
        }
        else
        {
            // Est-on enferme ? C'est le cas si en suivant une polyligne intersectante,
            // on se retrouve avant S ou apres R sur [S,R]
            // Comme on doit parcourir toutes les polylignes intersectantes, on en profite pour calculer les
            // trajets:
            bPasEnferme = geoCourant.PremierePasse(_geoSR->_ListePoint[0], _geoSR->_ListePoint[1],
                                                   IndexePointsFrontiere, NbPointsFrontiere,
                                                   _estUnPointIntersectant, Connexes, geoPremierePasse);
        }
        if (bPasEnferme)
        {
            geoTrajet = &geoPremierePasse;
        }
 
        SAFE_DELETE_LIST(Connexes);
    }
    SAFE_DELETE_LIST(IndexePointsFrontiere);
 
    return bPasEnferme;
}
 
int TYCalculParcours::Traite(TYSetGeometriqueParcours& geoDernierePasseGauche,
                             TYSetGeometriqueParcours& geoDernierePasseDroite,
                             TYSetGeometriqueParcours*& geoTrajetGauche,
                             TYSetGeometriqueParcours*& geoTrajetDroite)
{
    // Preparation des donnees
    // 1. Le segment SR doit etre present
    assert(NULL != _geoSR);
    if (NULL == _geoSR->_ListePoint)
    {
        return -1;
    }
    // 2. S et R doivent avoir des identifiants speciaux pour ne pas les melanger a d'autres
    assert(_geoSR->_ListePoint[0].Identifiant == INDENTIFIANT_SOURCE);
    assert(_geoSR->_ListePoint[1].Identifiant == INDENTIFIANT_RECEPTEUR);
 
    // S'il n'y a pas d'obstacle:
    if (0 == _geoImporterDXF->_nNbPointTotal)
    {
        // On copie _geoSR
        geoDernierePasseGauche.Copy(*_geoSR);
        geoDernierePasseDroite.Copy(*_geoSR);
 
        // On n'ecrit pas le fichier
        return 0;
    }
 
    // 3.1 Filtrage
    // 3.1.1 Filtrage sur les polylignes
    if (!_bVertical)
    {
        TYPointParcours** pTableauECD = NULL;
        int nbPtsECD = 0;
        TYPointParcours** pTableauECG = NULL;
        TYPointParcours** pTableauFinG = NULL;
        TYPointParcours** pTableauFinD = NULL;
 
        int nbPtsECG = 0;
        int nbPtsFinG = 0;
        int nbPtsFinD = 0;
 
        TYSetGeometriqueParcours geoGauche;
        TYSetGeometriqueParcours geoDroite;
 
        _geoImporterDXF->SupressionPolylignesRedondantes();
 
        // 3.2 Marquage des points a gauche ou a droite
        bool* PointsAGauche = NULL;
        bool* PointsADroite = NULL;
        _geoImporterDXF->MarquePointsADroiteEtAGauche(_geoSR->_ListePoint[0], _geoSR->_ListePoint[1],
                                                      PointsAGauche, PointsADroite);
 
        // 3.3 Separation des points suivants le côté droit au gauche
        // Cette separation donne deja les segments intersectant [SR]
 
        _geoImporterDXF->SeparationDroiteGauche(PointsAGauche, PointsADroite, geoGauche, geoDroite);
 
        // 3.4 Calcul des trajets
        TYSetGeometriqueParcours geoPremierePasseGauche;
        bool bPasEnfermeAGauche = CalculTrajet(geoGauche, true, PointsAGauche, PointsADroite,
                                               geoPremierePasseGauche, geoTrajetGauche);
        if (bPasEnfermeAGauche && geoPremierePasseGauche._nNbPolylines > 0)
        {
            TYSetGeometriqueParcours geoSecondePasseGauche;
            bool bGeoSecondePasseGaucheIntersects = false;
            int nNbBouclesPasseGauche = 0;
            do
            {
                nNbBouclesPasseGauche++;
                geoGauche.SecondePasse(geoPremierePasseGauche, geoSecondePasseGauche, true, pTableauECG,
                                       nbPtsECG);
                geoGauche.SecondePasse(geoSecondePasseGauche, geoDernierePasseGauche, true, pTableauFinG,
                                       nbPtsFinG, MAX_POINTS, true);
                bGeoSecondePasseGaucheIntersects = geoGauche.intersects(geoDernierePasseGauche);
                if (geoPremierePasseGauche.coincideWith(geoDernierePasseGauche))
                {
                    break;
                }
 
                geoPremierePasseGauche.Clean();
                geoPremierePasseGauche.Copy(geoDernierePasseGauche);
            } while (bGeoSecondePasseGaucheIntersects && (nNbBouclesPasseGauche < 4));
 
            if (!bGeoSecondePasseGaucheIntersects)
            {
                geoTrajetGauche = &geoDernierePasseGauche;
            }
            else
            {
                geoTrajetGauche = nullptr;
            }
        }
 
        TYSetGeometriqueParcours geoPremierePasseDroite;
        bool bPasEnfermeADroite = CalculTrajet(geoDroite, false, PointsAGauche, PointsADroite,
                                               geoPremierePasseDroite, geoTrajetDroite);
        if (bPasEnfermeADroite && geoPremierePasseDroite._nNbPolylines > 0)
        {
            TYSetGeometriqueParcours geoSecondePasseDroite;
            bool bGeoSecondePasseDroiteIntersects = false;
            int nNbBouclesPasseDroite = 0;
            do
            {
                nNbBouclesPasseDroite++;
                geoDroite.SecondePasse(geoPremierePasseDroite, geoSecondePasseDroite, false, pTableauECD,
                                       nbPtsECD);
                geoDroite.SecondePasse(geoSecondePasseDroite, geoDernierePasseDroite, false, pTableauFinD,
                                       nbPtsFinD, MAX_POINTS, true);
                bGeoSecondePasseDroiteIntersects = geoDroite.intersects(geoDernierePasseDroite);
                if (geoPremierePasseDroite.coincideWith(geoDernierePasseDroite))
                {
                    break;
                }
 
                geoPremierePasseDroite.Clean();
                geoPremierePasseDroite.Copy(geoDernierePasseDroite);
            } while (bGeoSecondePasseDroiteIntersects && (nNbBouclesPasseDroite < 4));
 
            if (!bGeoSecondePasseDroiteIntersects)
            {
                geoTrajetDroite = &geoDernierePasseDroite;
            }
            else
            {
                geoTrajetDroite = nullptr;
            }
        }
 
        SAFE_DELETE_LIST(PointsAGauche);
        SAFE_DELETE_LIST(PointsADroite);
 
        SAFE_DELETE_LIST(pTableauECD);
        SAFE_DELETE_LIST(pTableauECG);
 
        SAFE_DELETE_LIST(pTableauFinG);
        SAFE_DELETE_LIST(pTableauFinD);
    }
    else
    {
        // Il suffit de calculer l'EC de l'ensemble des points formes par ceux d'abscisse compris entre Sx &
        // Rx, et d'en prendre la partie superieure Avant, on termine le merge entrepris avant, ie qu'on ne
        // reordonne la liste pour mettre en premier les nons doublons
        //_geoImporterDXF->GenerePointNonConfondus();
        // Hypotheses:
        // On suppose que ni source ni recepteur ne sont dans un batiment
        TYPointParcours** TableauDePointsSelectionnes =
            new TYPointParcours*[_geoImporterDXF->_nNbPointTotal +
                                 2]; // +2 pour prendre en compte les points S et R qui sont ajoutes
        int nNbPointsSelectiones = _geoImporterDXF->SelectionnePointsEntreSetRetDuCoteDeSR(
            _geoSR, TableauDePointsSelectionnes, _geoImporterDXF->_nNbPointTotal);
 
        TYPointParcours** TableauDePointsEC = new TYPointParcours*[nNbPointsSelectiones];
        // int nNbPointsEC =
        // TYSetGeometriqueParcours::EnveloppeConvexeLes2PremiersPointsEtantLesPlusBas(TableauDePointsSelectionnes,
        // nNbPointsSelectiones, TableauDePointsEC);
 
        int nNbPointsEC = 0;
        bool bWrong = false;
        int idx = 0;
        TYPointParcours A, B;
 
        // xbh: corrige le pb de trajet vu sur le projet UMP 1.7 insono.xml
        // Ce n'est vraiment pas optimal, mais je n'ai pas trouve de meilleure solution
        // avec l'algorithme actuel que d'eliminer les points posant probleme et de recalculer
        // l'enveloppe convexe a partir du nouvel ensemble de points.
        // Cela a l'air de mieux fonctionner, mais il doit rester des cas ou des problemes persistent.
        // En particulier, on suppose dans le filtrage de l'enveloppe que l'on n'a pas de points de
        // rebroussements. Ce qui est faux dans le cas ou on passe par dessus un mur d'epaisseur nulle (mais
        // ce cas est-il possible dans Tympan??)
        do
        {
            nNbPointsEC = TYSetGeometriqueParcours::EnveloppeConvexeLes2PremiersPointsEtant(
                TableauDePointsSelectionnes, nNbPointsSelectiones, TableauDePointsEC, false);
 
            // xbh: ajout d'une deuxieme passe pour filter l'enveloppe convexe en eliminant les points de
            // rebroussements
            bWrong = false;
            idx = 0;
            for (int i = 0; i < nNbPointsEC; i++)
            {
                if (i > 1)
                {
                    A = TYPointParcours::vecteur2D(*TableauDePointsEC[i - 1], *TableauDePointsEC[i - 2]);
                    B = TYPointParcours::vecteur2D(*TableauDePointsEC[i - 1], *TableauDePointsEC[i]);
 
                    if (TYPointParcours::Scalaire(A, B) >
                        0) // point de rebroussement dans l'enveloppe, on l'oublie pour lisser l'enveloppe
                    {
                        bWrong = true;
                        idx = i - 1;
                        break; // on s'arrete ici...
                    }
                    else if (ABS(TYPointParcours::Scalaire(A, B)) < EPSILON_13)
                    {
                        // on autorise les angles a 90i�� que lors du suivis du contour d'un obstacle
                        if (!_geoImporterDXF->AppartienneMemePolyligne(
                                TableauDePointsEC[i - 2], TableauDePointsEC[i - 1], TableauDePointsEC[i]))
                        {
                            bWrong = true;
                            idx = i - 1;
                            break; // on s'arrete ici...
                        }
                    }
                    else if ((A.x == 0.0f) || (B.x == 0.0f))
                    {
                        // on autorise les segments verticaux que lors du suivis du contour d'un obstacle
                        if (!_geoImporterDXF->AppartienneMemePolyligne(
                                TableauDePointsEC[i - 2], TableauDePointsEC[i - 1], TableauDePointsEC[i]))
                        {
                            bWrong = true;
                            idx = i - 1;
                            break; // on s'arrete ici...
                        }
                    }
                }
            }
 
            if (bWrong) // Si un point pose pb, on l'elimine et on recommence le calcul de l'enveloppe...
            {
                int k = 0;
                for (k = 0; k < nNbPointsSelectiones; k++)
                {
                    if (TableauDePointsEC[idx] == TableauDePointsSelectionnes[k])
                    {
                        idx = k;
                        break; // on a trouve le point, on stop ici
                    }
                }
                for (k = idx; k < nNbPointsSelectiones - 1; k++)
                {
                    // On decale tout le tableau
                    TableauDePointsSelectionnes[k] = TableauDePointsSelectionnes[k + 1];
                }
                nNbPointsSelectiones--;
            }
        } while (bWrong);
 
        // Les points doivent etre ordonnes pour le trajet; on sait que le premier point est S, le second R
        // Si S est a droite de R, il faudra reordonner les points pour le trajet
        bool bAGaucheDeSR = (_geoSR->_ListePoint[0].x < _geoSR->_ListePoint[1].x);
        geoDernierePasseGauche.CreerTrajetAPartirDuneListeDePointsTriee(TableauDePointsEC, nNbPointsEC,
                                                                        bAGaucheDeSR, true);
        geoTrajetGauche = &geoDernierePasseGauche;
 
        SAFE_DELETE_LIST(TableauDePointsEC);
        SAFE_DELETE_LIST(TableauDePointsSelectionnes);
    }
 
    return 0;
}