CAD4FE_MCFace.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_MCFace.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#pragma hdrstop
 
#include "CAD4FE_MCFace.h"
#include "CAD4FE_PolySurface.h"
#include "CAD4FE_MCEdge.h"
#include "CAD4FE_MCVertex.h"
#include "ot_algorithme_geometrique.h"
#pragma package(smart_init)
 
#ifdef __BORLANDC__
#pragma warn -8012
#pragma warn -8037
#endif
 
using namespace CAD4FE;
 
MCFace::MCFace(MG_FACE * __mgFace)
  : MG_FACE (std::string("MC")+std::string(__mgFace->get_idoriginal()), new PolySurface(__mgFace), 1)
{
        time = 0;
        transfert_ccf(*__mgFace);
}
 
MCFace::MCFace( MCFace & __src)  : MG_FACE(*this)
{
        time = 0;
}
 
 
MCFace::MCFace( std::string & __idOriginal, PolySurface * __polySurface)
: MG_FACE(std::string(__idOriginal), __polySurface, 1)
{                 
        time = 0;
}
 
 
MCFace::MCFace(MCFace & __a,  MCFace & __b)
: MG_FACE(std::string(__a.get_idoriginal())+std::string("+")+std::string(__b.get_idoriginal()), new PolySurface(), 1)
{                 
        time = 0;
 
        GetPolySurface()->Merge(*__a.GetPolySurface());
        GetPolySurface()->Merge(*__b.GetPolySurface());
        
        _CopyMeshLink (__a);
        _CopyMeshLink (__b);
        
        transfert_ccf(__a);
        transfert_ccf(__b);
}
 
void MCFace::_CopyMeshLink( MCFace & __mcFace)
{
    unsigned i,j,k;
 
    //this->get_lien_maillage()->ajouter(*(__mcFace.get_lien_maillage()));
    TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage  = __mcFace.get_lien_maillage();
    TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
    for (MG_ELEMENT_MAILLAGE* element = lien_maillage->get_premier(it); element != NULL; element = lien_maillage->get_suivant(it))
    {
            element->change_lien_topologie2(this);
            this->get_lien_maillage()->ajouter(element);
 
            MG_TRIANGLE * triangle = (MG_TRIANGLE *)element;
            MG_SEGMENT * segs[3]={0,0,0};
            segs[0] = triangle->get_segment1();                
            segs[1] = triangle->get_segment2();
            segs[2] = triangle->get_segment3();
            MG_NOEUD * nodes[3]={0,0,0};
            nodes[0] = triangle->get_noeud1();
            nodes[1] = triangle->get_noeud2();
            nodes[2] = triangle->get_noeud3();
            for (i=0; i<3; i++)
            {
                if (!segs[i]->get_lien_topologie() || segs[i]->get_lien_topologie()->get_dimension() >= 2)
                {
                    segs[i]->change_lien_topologie2(this);
                }
                if (!nodes[i]->get_lien_topologie() || nodes[i]->get_lien_topologie()->get_dimension() >= 2)
                {
                    nodes[i]->change_lien_topologie2(this);
                }
            }
    }
}
 
MCFace::~MCFace()
{
}
 
PolySurface * MCFace::GetPolySurface ()
{
        return (PolySurface*)get_surface();
}
 
void MCFace::enregistrer(std::ostream& o,double version)
{
   o << "%" << get_id() << "=CAD4FE_MCFACE("<< get_idoriginal() << ",$" << get_surface()->get_id() << ",(";
   for (unsigned int i=0;i<get_nb_mg_boucle();i++)
      {
         o << "$" << get_mg_boucle(i)->get_id();
         if (i!=get_nb_mg_boucle()-1) o << ","; else o << ")";
      }
   int nb=get_nb_ccf();
   o << "," << get_orientation() << "," << nb;
   if (nb!=0)
        {
        o << ",(";
        for (int i=0;i<nb;i++)
                {
                char nom[3];
                get_type_ccf(i,nom);
                o << "(" <<  nom << "," << get_valeur_ccf(i) << ")";
                if (i!=nb-1) o << "," ;
                }
        o << ")";
        }
   o <<   ");" << std::endl;
}
 
void MCFace::calcul_normale_unitaire(MG_SOMMET *v, double __n[3], int * __nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(v,__n,__nbRefFace);
}
 
void MCFace::calcul_normale_unitaire(MCVertex * __mcVertex, double __n[3], int *__nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(__mcVertex,__n,__nbRefFace);
}
 
void MCFace::calcul_normale_unitaire(const std::map<MG_FACE *, OT_VECTEUR_3D > & __tabRefFaceUV, double __n[3], int *__nbRefFace)
{
    GetPolySurface()->calcul_normale_unitaire(__tabRefFaceUV,__n,__nbRefFace);
}