CAD4FE_MCNode.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_MCNode.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#pragma hdrstop
 
                 
#include "gestionversion.h"
#include "CAD4FE_MCNode.h"    
#include "mg_maillage.h"
#include "mg_geometrie.h"
#include "CAD4FE_FaceBoundaryPoint.h"
#include "CAD4FE_MCVertex.h"         
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCFace.h"
#include "CAD4FE_Geometric_Tools.h"
#include <math.h>
 
 
#pragma package(smart_init)
 
using namespace CAD4FE;
 
MCNode::MCNode()
: MG_NOEUD (0, 0, 0, 0, 0), _saveFormat(0)
{
    Creator = unknown;
}
MCNode::MCNode(unsigned long num,MG_ELEMENT_TOPOLOGIQUE* mcTopo,MG_ELEMENT_TOPOLOGIQUE* __refTopo,double xx,double yy,double zz)
: MG_NOEUD (num, mcTopo, xx,yy,zz,MAGIC::ORIGINE::MAILLEUR_AUTO),_refTopo(__refTopo), _saveFormat(0)
{           
    Creator = unknown;
    ConstructMapping();
}
MCNode::MCNode(MG_ELEMENT_TOPOLOGIQUE* mcTopo,MG_ELEMENT_TOPOLOGIQUE* __refTopo,double xx,double yy,double zz)
: MG_NOEUD(mcTopo,xx,yy,zz,MAGIC::ORIGINE::MAILLEUR_AUTO),_refTopo(__refTopo), _saveFormat(0)
{         
    Creator = unknown;
    ConstructMapping();
}
MCNode::MCNode(MG_ELEMENT_TOPOLOGIQUE* mcTopo,MG_FACE* __refFace, double __uv[2], double __xyz[3])
: MG_NOEUD(mcTopo,__xyz[0],__xyz[1],__xyz[2],MAGIC::ORIGINE::MAILLEUR_AUTO),_refTopo(__refFace), _saveFormat(0)
{                
    Creator = unknown;
    OT_VECTEUR_3D uv(__uv[0], __uv[1], 0);
    _F.insert(std::make_pair(__refFace, uv));
}
MCNode::MCNode(MG_ELEMENT_TOPOLOGIQUE* mcTopo,MG_ARETE* __refEdge, double __t, double __xyz[3])
: MG_NOEUD(mcTopo,__xyz[0],__xyz[1],__xyz[2],MAGIC::ORIGINE::MAILLEUR_AUTO),_refTopo(__refEdge), _saveFormat(0)
{               
    Creator = unknown;
    _E.insert(std::make_pair(__refEdge, __t));  
    ConstructMapping();
}
MCNode::~MCNode()
{
}
MCNode::MCNode(const MCNode& __src)
: MG_NOEUD ((MG_NOEUD & )__src)
{
/*    for (FMapCIterator itF = __src._F.begin();
        itF != __src._F.end();
        itF++)
        _F.insert(std::make_pair(itF->first,itF->second));
    for (EMapCIterator itE = __src._E.begin();
        itE != __src._E.end();
        itE++)
        _E.insert(std::make_pair(itE->first,itE->second));
    for (VMapCIterator itV = __src._V.begin();
        itV != __src._V.end();
        itV++)
        _V.insert(*itV);  */    
    Creator = __src.Creator;
    _F=__src._F;
    _E=__src._E;
    _V=__src._V;
    _refTopo = __src._refTopo;
}                           
void MCNode::CopyGeometry(const MCNode& __src)
{
    /*_F.clear();
    for (FMapCIterator itF = __src._F.begin();
        itF != __src._F.end();
        itF++)
        _F.insert(std::make_pair(itF->first,itF->second));
    _E.clear();
    for (EMapCIterator itE = __src._E.begin();
        itE != __src._E.end();
        itE++)
        _E.insert(std::make_pair(itE->first,itE->second));
    _V.clear();
    for (VMapCIterator itV = __src._V.begin();
        itV != __src._V.end();
        itV++)
        _V.insert(*itV);  */
    _F.clear();_E.clear();_V.clear();
    _F=__src._F;
    _E=__src._E;
    _V=__src._V;
    _refTopo = __src._refTopo;
    for (int i=0;i<3;i++)xyz[i]=__src.xyz[i];
}
int MCNode::get_type_entite ()
{
    return IDMCNODE;
}                            
MG_ELEMENT_TOPOLOGIQUE * MCNode::get_lien_topologie_reference()
{
    return _refTopo;
}                                        
void MCNode::change_lien_topologie_reference(MG_ELEMENT_TOPOLOGIQUE *__refTopo)
{
    _refTopo = __refTopo;
}            
MCNode::FMap  & MCNode::GetRefFaceMapping() {return _F;}
MCNode::EMap  & MCNode::GetRefEdgeMapping() {return _E;}
MCNode::VMap  & MCNode::GetRefVertexMapping() {return _V;}
void MCNode::SetRefFaceMapping(MG_FACE * __face, double * __uv) {OT_VECTEUR_3D vec(__uv[0],__uv[1],0);_F[__face] = vec;}
void MCNode::SetRefEdgeMapping(MG_ARETE * __edge, double __t) {_E[__edge] = __t;}
void MCNode::SetRefVertexMapping(MG_SOMMET * __vertex) { _V.insert(__vertex); }
void MCNode::ConstructMapping()
{
    MG_ELEMENT_TOPOLOGIQUE * topo = _refTopo;
    _F.clear(); _E.clear(); _V.clear();
 
    if (topo == NULL) // should happen rarely
        return;
 
    switch (topo->get_dimension())
    {
    case 0:
    {
        // Look for an existing MC Node on this vertex
        MG_SOMMET* vertex=(MG_SOMMET*)topo;
        MCNode * mcNode = 0;
 
        TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage = vertex->get_lien_maillage();
        TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
        MG_ELEMENT_MAILLAGE* element;
        int nb = lien_maillage->get_nb();
        int i=0;
        for (element = lien_maillage->get_premier(it); i++ < nb && element ; element = lien_maillage->get_suivant(it) )
        {
            int elementType = element->get_type_entite();
            if ( elementType == IDMCNODE && element != this )
            {
                MCNode * tmpmcNode = (MCNode*) element;
                if (tmpmcNode->_V.size() && tmpmcNode->_E.size() && tmpmcNode->_F.size())
                {
                    mcNode = tmpmcNode;
                    break;
                }
            }
        }
        // Make a copy of the mapping to the existing MC node
        if (mcNode)
        {
            _V = mcNode->_V;
            _E = mcNode->_E;
            _F = mcNode->_F;
        }
        // Compute the topology mapping
        else
        {                                                 
            _V.insert((MG_SOMMET*)topo);
            if (get_lien_topologie())
            {
                if (get_lien_topologie()->get_dimension() == 0)
                {
                    MCVertex * mcVertex = (MCVertex*)get_lien_topologie();
                    for (std::map<unsigned long, MG_SOMMET*>::iterator itMergedVertex = mcVertex->GetMergedRefVertices().begin();
                       itMergedVertex != mcVertex->GetMergedRefVertices().end();
                       itMergedVertex++)
                       _V.insert(itMergedVertex->second);
                }
                if (get_lien_topologie()->get_dimension() == 1)
                {
                    MCEdge * mcEdge = (MCEdge*)get_lien_topologie();
                    MCVertex * mcVertex[2];
                    mcVertex[0] = (MCVertex*)mcEdge->get_cosommet1()->get_sommet();   
                    mcVertex[1] = (MCVertex*)mcEdge->get_cosommet2()->get_sommet();
                    for (int j = 0; j<2; j++)
                    {
                        std::map<unsigned long, MG_SOMMET*>::iterator itMergedVertex = mcVertex[j]->GetMergedRefVertices().find(_refTopo->get_id());
                        if (itMergedVertex != mcVertex[j]->GetMergedRefVertices().end())
                        {
                            for (itMergedVertex = mcVertex[j]->GetMergedRefVertices().begin();
                               itMergedVertex != mcVertex[j]->GetMergedRefVertices().end();
                               itMergedVertex++)
                               _V.insert(itMergedVertex->second);
                        }
                    }
                }
            }
            else
            {
                printf("Warning: MC topology of MC Node = NULL!\n");
            }
            for (std::set<MG_SOMMET*>::iterator itV = _V.begin();
                itV != _V.end();
                itV++)
            {
                MG_SOMMET * v = *itV;
                // Init Edge Mapping
                for (int itE = 0; itE < v->get_nb_mg_cosommet(); itE++)
                {
                    MG_ARETE * edge = v->get_mg_cosommet(itE)->get_arete();
                    
                    // edge parameter is the reference vertex parameter
                    MG_SOMMET * refVertex = (MG_SOMMET *) _refTopo;
                    if ( v == refVertex || (edge->get_cosommet1()->get_sommet() != refVertex) && (edge->get_cosommet1()->get_sommet() != refVertex) )
                    {
                        double tEdge = v->get_mg_cosommet(itE)->get_t();
                        double edgePeriod = edge->get_courbe()->get_periode();
                        if ( tEdge < edge->get_tmin() && edgePeriod != 0.0 )
                        {
                            tEdge += edgePeriod;
                        }          
                        _E.insert(std::make_pair(edge, tEdge));
                    }
 
                    // Init Face mapping
                    for (int itF = 0; itF < edge->get_nb_mg_coarete(); itF++)
                    {
                        MG_FACE * face = edge->get_mg_coarete(itF)->get_boucle()->get_mg_face();
 
                        if (v != refVertex && GeometricTools::MG_FACE_Contains_MG_SOMMET(face,refVertex) )
                            continue;
                        
                        if ( _F.find(face) == _F.end() )
                        {
                            // project vertex in face parametrization
                            OT_VECTEUR_3D uv(0,0,0);
                            face->inverser(uv,xyz,1E-6);
                            // correct uv coordinates of 3D points which are not
                            // exactly on "exact surfaces" (torus, sphere, cylinder, cone, etc)
                            GeometricTools::FacePointCorrection(face,xyz,uv);
                            _F.insert(std::make_pair(face, uv));
                        }
                    }
                }
            }
        }
        break;
    }
    case 1:
    {  
        MG_ARETE * edge = (MG_ARETE*) topo;
        
        // Init Edge Mapping
        // Not implemented : parameter of edge mapping
        if (_E.find(edge) == _E.end())
        {                       
            double tEdge;                    
            double edgePeriod = edge->get_courbe()->get_periode();
            edge->inverser(tEdge,xyz);
            if ( tEdge < edge->get_tmin() && edgePeriod != 0.0 )
            {
                            tEdge += edgePeriod;
            }               
            _E.insert(std::make_pair(edge, tEdge)); 
        }
 
        // Init Face mapping
        for (int itF = 0; itF < edge->get_nb_mg_coarete(); itF++)
        {
            MG_FACE * face = edge->get_mg_coarete(itF)->get_boucle()->get_mg_face();
            OT_VECTEUR_3D uv(0,0,0);
            face->inverser(uv,xyz,1E-6);    
            // correct uv coordinates of 3D points which are not
            // exactly on "exact surfaces" (torus, sphere, cylinder, cone, etc)
            GeometricTools::FacePointCorrection(face,xyz,uv);
            _F.insert(std::make_pair(face, uv));
        }
        break;
    }
    case 2:
    {        
        // Init Face Mapping             
        MG_FACE * face = (MG_FACE*) topo;
        OT_VECTEUR_3D uv(0,0,0);
        face->inverser(uv,xyz,1E-6);        
        // correct uv coordinates of 3D points which are not
        // exactly on "exact surfaces" (torus, sphere, cylinder, cone, etc)
        GeometricTools::FacePointCorrection(face,xyz,uv);
        _F.insert(std::make_pair(face, uv));
        break;
    }
 
    }
}                                    
void MCNode::SharedFaces(MCNode * __other, std::set <MG_FACE*> & __setF)
{
    for (MCNode::FMapIterator itF1 = _F.begin();
        itF1 != _F.end();
        itF1 ++ )
        if (__other->_F.find(itF1->first) != __other->_F.end())
            __setF.insert (itF1->first);
}                
void MCNode::SharedEdges(MCNode * __other, std::set <MG_ARETE*> & __setE)
{
    for (MCNode::EMapIterator itE1 = _E.begin();
        itE1 != _E.end();
        itE1 ++ )
        if (__other->_E.find(itE1->first) != __other->_E.end())
            __setE.insert (itE1->first);
}         
void MCNode::SharedVertices(MCNode * __other, std::set <MG_SOMMET*> & __setV)
{
    for (MCNode::VMapIterator itV1 = _V.begin();
        itV1 != _V.end();
        itV1 ++ )
        if (__other->_V.find(*itV1) != __other->_V.end())
            __setV.insert (*itV1);
}
bool MCNode::IsInFace   (MG_FACE   * __e)
{
    FMapIterator itF = _F.find(__e);
    return (itF != _F.end());
}
void MCNode::NormalMCFace(MCFace* __mcFace, double * __normal)
{
    int nbRefFaces=0;
    int dimension=_refTopo->get_dimension();
    switch (dimension)
    {
        case 1:
        {
            __mcFace->calcul_normale_unitaire(GetRefFaceMapping(), __normal, &nbRefFaces);
            return;
        }     
        case 2:
        {
            __mcFace->calcul_normale_unitaire(GetRefFaceMapping(), __normal, &nbRefFaces);
            return;
        }
        case 0:
        {
            __mcFace->calcul_normale_unitaire((MG_SOMMET*) _refTopo, __normal, &nbRefFaces);
        }
    }
}
 
bool MCNode::RefTopoIsInFace   (MG_FACE   * __e)
{
    FMapIterator itF = _F.find(__e);
    if (itF == _F.end()) return false;
    switch (_refTopo->get_dimension())
    {
        case 0:
        if (_V.size() <= 1) // if it's not in a merged vertex, then no further test is required
            return true;
        else
            return (GeometricTools::MG_FACE_Contains_MG_SOMMET(__e, (MG_SOMMET*) _refTopo));
        default:
            return true;
    }
}
bool MCNode::RefTopoIsInEdge   (MG_ARETE  * __e)
{
    EMapIterator itE = _E.find(__e);
    if (itE == _E.end()) return false;
    switch (_refTopo->get_dimension())
    {
        case 0:       
        if (_V.size() <= 1) // if it's not in a merged vertex, then no further test is required
            return true;
        else
            return (GeometricTools::MG_ARETE_Contains_MG_SOMMET(__e, (MG_SOMMET*) _refTopo));
        default:
            return true;
    }
}                
bool MCNode::IsInEdge   (MG_ARETE  * __e)
{
    return (_E.find(__e) != _E.end());
}
bool MCNode::IsInVertex (MG_SOMMET * __e)
{
    return (_V.find(__e) != _V.end());
}       
bool MCNode::RefTopoIsInVertex (MG_SOMMET * __e)
{
    return (_refTopo != __e);
}
MG_SOMMET * MCNode::GetMergedVertex(MG_FACE * __face)
{
    if (_V.size() > 1)
    {
        MG_SOMMET * refVertex = (MG_SOMMET*) _refTopo;
        for (VMapIterator itV = _V.begin();
            itV != _V.end();
            itV++)
        {
            MG_SOMMET * mergedVertex = *itV;
            if (mergedVertex == refVertex)
                continue;
            if (GeometricTools::MG_FACE_Contains_MG_SOMMET(__face, mergedVertex))
                return mergedVertex;
        }
    }
    return NULL;
}
OT_VECTEUR_3D & MCNode::GetFaceParams (MG_FACE  * __e)
{
    static OT_VECTEUR_3D badParam (-1E308,-1E308,-1E308);
    FMapIterator itF = _F.find(__e);
    if (itF != _F.end())
        return itF->second;
    else
        return badParam;
}
OT_VECTEUR_3D & MCNode::UV (MG_FACE  * __e)
{
    return GetFaceParams (__e);
}
double   MCNode::GetEdgeParams (MG_ARETE * __e)
{
    static double badParam = -1E308;
    EMapCIterator itE = _E.find(__e);
    if (itE != _E.end())
        return itE->second;
    else
        return badParam;
}
double   MCNode::T (MG_ARETE * __e)
{
    return GetEdgeParams(__e);
}
           
void MCNode::SetSaveFormat(char __format)
{
    _saveFormat=__format;
    if (__format == 2)
    {
        change_lien_topologie(_refTopo);
    }
}
 
void MCNode::enregistrer(std::ostream& o,double version)
{
   if (_saveFormat==0)
   {
        o << "%" << get_id() << "=CAD4FE_MCNODE($"<< _refTopo->get_id() <<",$" << get_lien_topologie()->get_id() << "," << xyz[0] << "," << xyz[1] << "," << xyz[2] <<   ");" << std::endl;
   }
    else if (_saveFormat==1)
    {
        MG_NOEUD::enregistrer (o,version);
    }
    else if (_saveFormat==2)
   {
        MG_NOEUD::enregistrer (o,version);
   }
}
 
void MCNode::Print()
{
    printf("%f %f %f ", get_x(), get_y(), get_z());
}