vct_multi_modele.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       vct_multi_modele.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:54 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include "vct_multi_modele.h"
#include "vct.h"
 
 
#include "mg_geometrie.h"
 
 
 
 
VCT_MULTI_MODELE::VCT_MULTI_MODELE(class MG_GEOMETRIE* g):geo(g)
{
}
 
VCT_MULTI_MODELE::VCT_MULTI_MODELE(VCT_MULTI_MODELE& mdd):geo(mdd.geo)
{
}
 
VCT_MULTI_MODELE::~VCT_MULTI_MODELE()
{
}
 
 
void VCT_MULTI_MODELE::recherche_identite(void)
{
    fusionne_sommet();
    fusionne_arete();
    fusionne_face();
}
 
void VCT_MULTI_MODELE::fusionne_sommet(void)
{
    std::multimap<OT_VECTEUR_4DD,MG_SOMMET*,lessOT_VECTEUR_4DD > tabsom;
    int nbsom=geo->get_nb_mg_sommet();
    for (int i=0;i<nbsom;i++)
    {
        MG_SOMMET* som=geo->get_mg_sommet(i);
        OT_VECTEUR_4DD *bary=som->get_vectorisation().get_barycentre_4d();
        std::pair<OT_VECTEUR_4DD,MG_SOMMET*> tmp(*bary,som);
        tabsom.insert(tmp);
    }
    int nb=tabsom.size();
    std::multimap <OT_VECTEUR_4DD,MG_SOMMET*,lessOT_VECTEUR_4DD > :: iterator its;
    its=tabsom.begin();
    for ( int i=0;i<nb-1;i++)
    {
        MG_SOMMET* som1=(*its).second;
        std::multimap <OT_VECTEUR_4DD,MG_SOMMET*,lessOT_VECTEUR_4DD > :: iterator itstmp=its;
        itstmp++;
        MG_SOMMET* som2=(*itstmp).second;
        OT_VECTEUR_4DD *bary1=som1->get_vectorisation().get_barycentre_4d();
        OT_VECTEUR_4DD *bary2=som2->get_vectorisation().get_barycentre_4d();
        if (*bary1==*bary2)
        {
            int nbcosom=som2->get_nb_mg_cosommet();
            for (int j=nbcosom-1;j> -1;j--)
            {
                MG_COSOMMET* cosom=som2->get_mg_cosommet(j);
                cosom->change_sommet(som1);
                som2->supprimer_mg_cosommet(cosom);
                som1->ajouter_mg_cosommet(cosom);
            }
            geo->supprimer_mg_sommetid(som2->get_id());
            tabsom.erase(itstmp);
        }
        else its++;
    }
 
 
 
 
}
 
 
void VCT_MULTI_MODELE::fusionne_arete(void)
{
    std::multimap <OT_VECTEUR_4DD,MG_ARETE*,lessOT_VECTEUR_4DD > tabare;
    int nbarete=geo->get_nb_mg_arete();
    for (int i=0;i<nbarete;i++)
    {
        MG_ARETE* arete=geo->get_mg_arete(i);
        OT_VECTEUR_4DD *bary=arete->get_vectorisation().get_barycentre_4d();
        std::pair<OT_VECTEUR_4DD,MG_ARETE*> tmp(*bary,arete);
        tabare.insert(tmp);
    }
    int nb=tabare.size();
    std::multimap <OT_VECTEUR_4DD,MG_ARETE*,lessOT_VECTEUR_4DD > :: iterator ita;
    ita=tabare.begin();
    for ( int i=0;i<nb-1;i++)
    {
        MG_ARETE* are1=(*ita).second;
        std::multimap <OT_VECTEUR_4DD,MG_ARETE*,lessOT_VECTEUR_4DD > :: iterator itatmp=ita;
        itatmp++;
        MG_ARETE* are2=(*itatmp).second;
        OT_VECTEUR_4DD *bary1=are1->get_vectorisation().get_barycentre_4d();
        OT_VECTEUR_4DD *bary2=are2->get_vectorisation().get_barycentre_4d();
        int ident=0;
        if (*bary1==*bary2)
            if (are1->get_vectorisation().get_nb_points()==are2->get_vectorisation().get_nb_points())
                if (are1->get_courbe()->get_vectorisation().get_nb_points()==are2->get_courbe()->get_vectorisation().get_nb_points())
                {
                    OT_TENSEUR *tens=are2->get_vectorisation().get_tenseur_metrique();
                    if (are1->get_vectorisation().get_tenseur_metrique()->est_til_equivalent(*tens))
                    {
                        OT_TENSEUR *tens2=are2->get_courbe()->get_vectorisation().get_tenseur_metrique();
                        if (are1->get_courbe()->get_vectorisation().get_tenseur_metrique()->est_til_equivalent(*tens2))
                        {
                            ident=1;
                            int nbcoarete=are2->get_nb_mg_coarete();
                            double xyz[3],dxyz1[3],dxyz2[3],t;
                            are1->evaluer(are1->get_tmin(),xyz);
                            are2->inverser(t,xyz);
                            are1->deriver(are1->get_tmin(),dxyz1);
                            are2->deriver(t,dxyz2);
                            OT_VECTEUR_3D vec1(dxyz1[0],dxyz1[1],dxyz1[2]);
                            OT_VECTEUR_3D vec2(dxyz2[0],dxyz2[1],dxyz2[2]);
                            vec1.norme();
                            vec2.norme();
                            double ps=vec1*vec2;
                            int sens;
                            if (ps>0.) sens=1;
                            else sens=-1;
                            for (int j=nbcoarete-1;j> -1;j--)
                            {
                                MG_COARETE* coare=are2->get_mg_coarete(j);
                                coare->change_arete(are1,sens);
                                are2->supprimer_mg_coarete(coare);
                                are1->ajouter_mg_coarete(coare);
                            }
                            long id1=are2->get_cosommet1()->get_sommet()->get_id();
                            long id2=are2->get_cosommet2()->get_sommet()->get_id();
                            geo->supprimer_mg_areteid(are2->get_id());
                            geo->supprimer_mg_sommetid(id1);
                            geo->supprimer_mg_sommetid(id2);
                            tabare.erase(itatmp);
                        }
                    }
                }
 
        if (ident==0) ita++;
    }
}
 
void VCT_MULTI_MODELE::fusionne_face(void)
{
    std::multimap <OT_VECTEUR_4DD,MG_FACE*,lessOT_VECTEUR_4DD > tabface;
    int nbface=geo->get_nb_mg_face();
    for (int i=0;i<nbface;i++)
    {
        MG_FACE* face=geo->get_mg_face(i);
        OT_VECTEUR_4DD *bary=face->get_vectorisation().get_barycentre_4d();
        std::pair<OT_VECTEUR_4DD,MG_FACE*> tmp(*bary,face);
        tabface.insert(tmp);
    }
    int nb=tabface.size();
    std::multimap <OT_VECTEUR_4DD,MG_FACE*,lessOT_VECTEUR_4DD> :: iterator itf;
    itf=tabface.begin();
    for ( int i=0;i<nb-1;i++)
    {
        MG_FACE* face1=(*itf).second;
        std::multimap <OT_VECTEUR_4DD,MG_FACE*,lessOT_VECTEUR_4DD > :: iterator itftmp=itf;
        itftmp++;
        MG_FACE* face2=(*itftmp).second;
        OT_VECTEUR_4DD *bary1=face1->get_vectorisation().get_barycentre_4d();
        OT_VECTEUR_4DD *bary2=face2->get_vectorisation().get_barycentre_4d();
        int ident=0;
        if (*bary1==*bary2)
            if (face1->get_vectorisation().get_nb_points()==face2->get_vectorisation().get_nb_points())
                if (face1->get_surface()->get_vectorisation().get_nb_points()==face2->get_surface()->get_vectorisation().get_nb_points())
                {
                    OT_TENSEUR *tens=face2->get_vectorisation().get_tenseur_metrique();
                    if (face1->get_vectorisation().get_tenseur_metrique()->est_til_equivalent(*tens))
                    {
                        OT_TENSEUR *tens2=face2->get_surface()->get_vectorisation().get_tenseur_metrique();
                        if (face1->get_surface()->get_vectorisation().get_tenseur_metrique()->est_til_equivalent(*tens2))
                        {
                            ident=1;
                            double uv1[2]={0.,0.};
                            double uv2[2]={0.,0.};
                            double xyz[3];
                            double n2[3];
                            double n1[3];
                            face1->evaluer(uv1,xyz);
                            face2->inverser(uv2,xyz);
                            face1->calcul_normale_unitaire(uv1,n1);
                            face2->calcul_normale_unitaire(uv2,n2);
                            OT_VECTEUR_3D vec1(n1[0],n1[1],n1[2]);
                            OT_VECTEUR_3D vec2(n2[0],n2[1],n2[2]);
                            double ps=vec1*vec2;
                            int sens;
                            if (ps>0.) sens=1;
                            else sens=-1;
                            int nbcoface=face2->get_nb_mg_coface();
                            for (int j=nbcoface-1;j> -1;j--)
                            {
                                MG_COFACE* coface=face2->get_mg_coface(j);
                                coface->change(face1,sens);
                                face2->supprimer_mg_coface(coface);
                                face1->ajouter_mg_coface(coface);
                            }
                            int nbboucle=face2->get_nb_mg_boucle();
                            for (int i=0;i<nbboucle;i++)
                            {
                                MG_BOUCLE* bou=face2->get_mg_boucle(i);
                                geo->supprimer_mg_boucleid(bou->get_id());
                            }
                            geo->supprimer_mg_faceid(face2->get_id());
                            tabface.erase(itftmp);
                        }
                    }
                }
        if (ident==0) itf++;
    }
}