TYFaceSelector.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/core/defines.h"
#include "Tympan/models/common/plan.h"
#include "Tympan/models/solver/entities.hpp"
#include "TYFaceSelector.h"
#include "TYTrajet.h"
#include "TYSolver.h"
 
TYFaceSelector::TYFaceSelector(TYSolver& solver) : _solver(solver) {}
 
TYFaceSelector::~TYFaceSelector() {}
 
void TYFaceSelector::selectFaces(std::deque<TYSIntersection>& tabIntersect, const TYTrajet& rayon)
{
 
    // Construction des plans de coupe
    TYSPlan plan[2];
    OSegment3D seg;
    rayon.getPtSetPtRfromOSeg3D(seg);
    buildPlans(plan, seg);
 
    size_t nbFaces = _solver.getTabPolygon().size();
 
    // Recuperation de l'ID de la source
    const string source_id = rayon.asrc.volume_id;
 
    // Test des faces qui coupent le plan vertical
    for (unsigned i = 0; i < nbFaces; i++)
    {
        const TYStructSurfIntersect& SI = _solver.getTabPolygon()[i];
 
        // FIX issue #18 (obstacles are not detected correctly)
        if ((SI.volume_id.size() != 0) && (source_id.size() != 0))
        {
            if ((SI.volume_id == source_id) || (SI.tabPoint.size() == 0))
            {
                continue;
            }
        }
 
        // Plan vertical = 0 / Plan horizontal = 1
        TYSIntersection intersection;
        bool bVertical = CalculSegmentCoupe(SI, intersection, plan[0].pt1, plan[0].pt2, plan[0].pt3, 0);
        bool bHorizontal = CalculSegmentCoupe(SI, intersection, plan[1].pt1, plan[1].pt2, plan[1].pt3, 1);
 
        if (bVertical || bHorizontal)
        {
            tabIntersect.push_back(intersection);
        }
    }
 
    reorder_intersect(tabIntersect); // Put infrastructure elements on top
}
 
void TYFaceSelector::reorder_intersect(std::deque<TYSIntersection>& tabIntersect)
{
    std::deque<unsigned int> indices;
    std::deque<TYSIntersection> temp;
 
    // 1 st pass : put infrastructure on top
    for (size_t i = 0; i < tabIntersect.size(); i++)
    {
        if (tabIntersect[i].isInfra)
        {
            temp.push_back(tabIntersect[i]);
        }
        else
        {
            indices.push_back(static_cast<unsigned int>(i));
        }
    }
 
    // 2nd pass : put remainings after
    for (size_t i = 0; i < indices.size(); i++)
    {
        temp.push_back(tabIntersect[indices[i]]);
    }
 
    // last : replace tabIntersect
    tabIntersect = temp;
}
 
bool TYFaceSelector::buildPlans(TYSPlan* plan, const OSegment3D& rayon)
{
    double planOffset = 10.0;
    TYSPlan tmpPlan;
    tmpPlan.pt1 = rayon._ptA;
    tmpPlan.pt2 = rayon._ptB;
 
    // Construction du plan vertical
    // 3eme point simplement en copiant le 1er et changeant l'alti
    tmpPlan.pt3 = tmpPlan.pt1;
    tmpPlan.pt3._z += planOffset;
 
    // Si A et B sont confondus (en 2D) sur le plan que l'on souhaite creer
    if ((tmpPlan.pt1._x == tmpPlan.pt2._x) && (tmpPlan.pt1._y == tmpPlan.pt2._y))
    {
        // On deplace le point 2 pour choisir un plan arbitraire valide
        tmpPlan.pt2._x += planOffset;
        tmpPlan.pt2._y += planOffset;
    }
 
    plan[0] = tmpPlan;
 
    // Construction du plan horizontal
    tmpPlan.pt1 = rayon._ptA;
    tmpPlan.pt2 = rayon._ptB;
 
    if (tmpPlan.pt2._x != tmpPlan.pt1._x)
    {
        tmpPlan.pt3._z = tmpPlan.pt1._z;
        tmpPlan.pt3._y = tmpPlan.pt1._y + planOffset;
        tmpPlan.pt3._x =
            ((tmpPlan.pt1._y - tmpPlan.pt2._y) * planOffset / (tmpPlan.pt2._x - tmpPlan.pt1._x)) +
            (tmpPlan.pt1._x);
    }
    else if (tmpPlan.pt1._y != tmpPlan.pt2._y)
    {
        tmpPlan.pt3._z = tmpPlan.pt1._z;
        tmpPlan.pt3._x = tmpPlan.pt1._x + planOffset;
        tmpPlan.pt3._y =
            ((tmpPlan.pt2._x - tmpPlan.pt1._x) * planOffset / (tmpPlan.pt1._y - tmpPlan.pt2._y)) +
            (tmpPlan.pt1._y);
    }
    else if (tmpPlan.pt1._z != tmpPlan.pt2._z)
    {
        tmpPlan.pt3._y = tmpPlan.pt1._y;
        tmpPlan.pt3._x = tmpPlan.pt1._x + planOffset;
        tmpPlan.pt3._z =
            ((tmpPlan.pt2._x - tmpPlan.pt1._x) * planOffset / (tmpPlan.pt1._z - tmpPlan.pt2._z)) +
            (tmpPlan.pt1._z);
    }
    else
    {
        return false;
    }
 
    plan[1] = tmpPlan;
 
    return true;
}
 
bool TYFaceSelector::CalculSegmentCoupe(const TYStructSurfIntersect& FaceCourante, TYSIntersection& Intersect,
                                        OPoint3D& pt1, OPoint3D& pt2, OPoint3D& pt3, const int& indice) const
{
    bool bRes = false;
    Intersect.isInfra = false;
    Intersect.isEcran = false;
    Intersect.noIntersect = false;
    Intersect.bIntersect[indice] = false;
 
    OSegment3D segInter;
    OPlan planRayon(pt1, pt2, pt3);
    if (planRayon.intersectsSurface(FaceCourante.tabPoint, segInter))
    {
        Intersect.bIntersect[indice] = true;
        Intersect.segInter[indice] = segInter;
        Intersect.isInfra = FaceCourante.is_infra();
        Intersect.isEcran = Intersect.isInfra;
        Intersect.material = FaceCourante.material;
        bRes = true;
    }
 
    return bRes;
}