CAD4FE_ShortestPath.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       CAD4FE_ShortestPath.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#pragma hdrstop
 
#include "gestionversion.h"
 
#include <fstream>
#include "CAD4FE_ShortestPath.h"
#include "mg_geometrie.h"     
#include "ot_algorithme_geometrique.h"
#include "CAD4FE_MCNode.h"
#include "CAD4FE_MCFace.h"     
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_Intersection_Plane_MG_ARETE.h"  
#include "CAD4FE_Geometric_Tools.h"
#include "CAD4FE_FaceBoundaryPoint.h"
#include "CAD4FE_ClosestPoint_Segment_MG_ARETE.h"
 
using namespace CAD4FE;
 
                         
#pragma package(smart_init)
 
ShortestPath::~ShortestPath()
{
    if (_intrAdjacencyGraph)
    {
        delete _intrAdjacencyGraph;
        _intrAdjacencyGraph = NULL;
    }
}
                                     
MCNode * ShortestPath::GetStartNode()
{
    return _mcNode[0];
}
 
MCNode * ShortestPath::GetEndNode()
{
    return _mcNode[1];
}
 
void ShortestPath::InitializeAdjacencyGraph()
{
    int nodeId = 1;
    if (_intrAdjacencyGraph)
    {
        delete _intrAdjacencyGraph;
        _intrAdjacencyGraph=0;
    } 
    _intrAdjacencyGraph = new Graph::Graph;
 
    std::map < MCNode * , int > mapGraphNodeByP;
 
    for (std::set<MCNode*>::iterator itP = _facePoints.begin();
        itP != _facePoints.end();
        itP++)
    {
        MCNode * mcNode = *itP;
        Graph::Node * n = _intrAdjacencyGraph->AddNode(nodeId++);
        n->SetUserData(mcNode);
        n->SetUserData(2,this);
        mapGraphNodeByP[mcNode]=n->Id();
    }
 
    std::map<MG_FACE*, std::set<MCNode*> > map_listP_by_F;  
    std::map<MG_ARETE*, std::set<MCNode*> > map_listP_by_E; 
    std::map<MG_SOMMET*, std::set<MCNode*> > map_listP_by_V;
    
    for (std::set<MCNode*>::iterator itP = _facePoints.begin();
        itP != _facePoints.end();
        itP++)
    {
        MCNode * P = *itP;
        for (MCNode::FMapIterator itF = P->GetRefFaceMapping().begin();
            itF != P->GetRefFaceMapping().end();
            itF ++ )
        {
            MG_FACE * F = itF->first;
            if ( _polySurface->Contains(F) )
            if ( P->GetRefVertexMapping().size() <=1 || P->RefTopoIsInFace(F) )
            {
                if (map_listP_by_F.find(F) == map_listP_by_F.end())
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->AddArc(F->get_id(), 1, mapGraphNodeByP[P]);
                    arc->SetUserData(F);
                    std::set<MCNode*> listP;
                    listP.insert( P );
                    map_listP_by_F.insert(std::make_pair(F,listP));
                }
                else
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->GetArc(F->get_id());
                    Graph::Node * n = _intrAdjacencyGraph->GetNode(mapGraphNodeByP[P]);
                    arc->Add( n );
                    n->Add(arc);
                    map_listP_by_F[F].insert(P);
                }
            }
        }  
        for (MCNode::EMapIterator itE = P->GetRefEdgeMapping().begin();
            itE != P->GetRefEdgeMapping().end();
            itE ++ )
        {
            MG_ARETE * E = itE->first; 
            if ( _polySurface->Contains(E) )
            if ( P->GetRefVertexMapping().size() <=1 || P->RefTopoIsInEdge(E) )
            {
                if (map_listP_by_E.find(E) == map_listP_by_E.end())
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->AddArc(E->get_id(), 1, mapGraphNodeByP[P]);
                    arc->SetUserData(E);
                    std::set<MCNode*> listP;
                    listP.insert( P );
                    map_listP_by_E.insert(std::make_pair(E,listP));
                }
                else
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->GetArc(E->get_id());
                    Graph::Node * n = _intrAdjacencyGraph->GetNode(mapGraphNodeByP[P]);
                    arc->Add( n );
                    n->Add(arc);
                    map_listP_by_E[E].insert(P);
                }
            }
        }
        for (MCNode::VMapIterator itV = P->GetRefVertexMapping().begin();
            itV != P->GetRefVertexMapping().end();
            itV ++ )
        {
            MG_SOMMET * V = *itV;
            {
                if (map_listP_by_V.find(V) == map_listP_by_V.end())
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->AddArc(V->get_id(), 1, mapGraphNodeByP[P]);
                    arc->SetUserData(V);
                    std::set<MCNode*> listP;
                    listP.insert( P );
                    map_listP_by_V.insert(std::make_pair(V,listP));
                }
                else
                {
                    Graph::Arc * arc = _intrAdjacencyGraph->GetArc(V->get_id());
                    Graph::Node * n = _intrAdjacencyGraph->GetNode(mapGraphNodeByP[P]);
                    arc->Add( n );
                    n->Add(arc);
                    map_listP_by_V[V].insert(P);
                }
            }
        }
    }
}
 
double ShortestPath::Find(std::vector <MCNode *> * __shortestPathNodes, std::vector <MG_ELEMENT_TOPOLOGIQUE *> * __shortestPathTopo)
{                
    std::vector <Graph::Node *> path;
    std::vector <Graph::Arc *> pathArcs;
    Graph::Node * nStart, * nEnd;
    for (Graph::Graph::MapNodesById::const_iterator itNode = _intrAdjacencyGraph->GetNodes().begin();
        itNode != _intrAdjacencyGraph->GetNodes().end();
        itNode++)
    {
        Graph::Node * n = itNode->second;
        if ((MCNode *)n->GetUserData() == _mcNode[0])
            nStart = n;
        else
            if ((MCNode *)n->GetUserData() == _mcNode[1])
                nEnd = n;
    }
    double distance = Graph::Dijkstra(_intrAdjacencyGraph,nStart,nEnd,Distance,path,pathArcs);
                                                                
    for (unsigned i=0; i<path.size();i++)
        _shortestPath.push_back((MCNode *)path[i]->GetUserData());
        
    if (__shortestPathNodes)
    {
        for (unsigned i=0; i<path.size();i++)
        {
            MCNode * mcNode = (MCNode *)path[i]->GetUserData();
            __shortestPathNodes->push_back(mcNode);
        }
    }
 
    if (__shortestPathTopo)  
    {
        for (unsigned i=0; i<pathArcs.size();i++)
        {
            MG_ELEMENT_TOPOLOGIQUE * topo = (MG_ELEMENT_TOPOLOGIQUE *)pathArcs[i]->GetUserData();
            __shortestPathTopo->push_back(topo);
        }
    }
 
 
    return distance;
}