mailleur/src/mailleur3d_outil.cpp

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur3d_outil.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:56 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#include "gestionversion.h"


#include <math.h>
#include "mailleur3d.h"
#include "mailleur3d_front.h"
#include "ot_mathematique.h"
#include "ot_boite_3d.h"
#include "m3d_noeud.h"
#include "m3d_tetra.h"
#include "m3d_triangle.h"
#include "mg_geometrie_outils.h"
#include "tpl_fonctions_generiques.h"


double MAILLEUR3D::angle_front(MG_FRONT_3D* ft1,MG_FRONT_3D* ft2)
{
    MG_NOEUD* noeud1=ft1->get_noeud1();
    MG_NOEUD* noeud2=ft1->get_noeud2();
    MG_NOEUD* noeud3=ft1->get_noeud3();
    MG_NOEUD* noeud4=ft2->get_noeud1();
    MG_NOEUD* noeud5=ft2->get_noeud2();
    MG_NOEUD* noeud6=ft2->get_noeud3();
    return get_angle_par_noeud<MG_NOEUD*>(noeud1,noeud2,noeud3,noeud4,noeud5,noeud6);
}


double MAILLEUR3D::angle_front(MG_FRONT_3D* ft,MG_SEGMENT* seg)
{
    MG_NOEUD* noeud1;
    MG_NOEUD* noeud2;
    MG_NOEUD* noeud3;
    MG_NOEUD* noeud4;


    if (seg->get_noeud1()==ft->get_noeud1())
    {
        noeud1=ft->get_noeud1();
        noeud2=ft->get_noeud2();
        noeud3=ft->get_noeud3();
        noeud4=seg->get_noeud2();
    }
    if (seg->get_noeud1()==ft->get_noeud2())
    {
        noeud1=ft->get_noeud2();
        noeud2=ft->get_noeud3();
        noeud3=ft->get_noeud1();
        noeud4=seg->get_noeud2();
    }
    if (seg->get_noeud1()==ft->get_noeud3())
    {
        noeud1=ft->get_noeud3();
        noeud2=ft->get_noeud1();
        noeud3=ft->get_noeud2();
        noeud4=seg->get_noeud2();
    }
    if (seg->get_noeud2()==ft->get_noeud1())
    {
        noeud1=ft->get_noeud1();
        noeud2=ft->get_noeud2();
        noeud3=ft->get_noeud3();
        noeud4=seg->get_noeud1();
    }
    if (seg->get_noeud2()==ft->get_noeud2())
    {
        noeud1=ft->get_noeud2();
        noeud2=ft->get_noeud3();
        noeud3=ft->get_noeud1();
        noeud4=seg->get_noeud1();
    }
    if (seg->get_noeud2()==ft->get_noeud3())
    {
        noeud1=ft->get_noeud3();
        noeud2=ft->get_noeud1();
        noeud3=ft->get_noeud2();
        noeud4=seg->get_noeud1();
    }

    OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n4(noeud4->get_x()-noeud1->get_x(),noeud4->get_y()-noeud1->get_y(),noeud4->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n=n1n2&n1n3;
    OT_MATRICE_3D mat(n1n2,n1n3,n1n);
    OT_MATRICE_3D matx(n1n4,n1n3,n1n);
    OT_MATRICE_3D maty(n1n2,n1n4,n1n);
    OT_MATRICE_3D matz(n1n2,n1n3,n1n4);
    double det=mat.get_determinant();
    double xsi=matx.get_determinant()/det;
    double eta=maty.get_determinant()/det;
    double psi=matz.get_determinant()/det;

    double proj[3];
    proj[0]=(1.-xsi-eta)*noeud1->get_x()+xsi*noeud2->get_x()+eta*noeud3->get_x();
    proj[1]=(1.-xsi-eta)*noeud1->get_y()+xsi*noeud2->get_y()+eta*noeud3->get_y();
    proj[2]=(1.-xsi-eta)*noeud1->get_z()+xsi*noeud2->get_z()+eta*noeud3->get_z();
    OT_VECTEUR_3D n1nproj(noeud1->get_x()-proj[0],noeud1->get_y()-proj[1],noeud1->get_z()-proj[2]);
    //n1n4.norme();
    //n1nproj.norme();
    double ps=n1n4*n1nproj;
    if (!(OPERATEUR::egal(ps,0.0,0.0001))) ps=ps/n1n4.get_longueur()/n1nproj.get_longueur();
    else ps=0.;
    if (ps>1.) ps=1.;
    if (ps<-1.) ps=-1.;
    double angle=acos(ps);
    if ((xsi<0.) || (eta<0.) ) angle=angle+M_PI/2.;
    if (psi<0.) angle=2*M_PI-angle;
    return angle;

}


class MG_TETRA* MAILLEUR3D::insere_tetra(class MG_VOLUME* mgvol,class MG_FRONT_3D* ft,MG_NOEUD* noeud4,int type,TPL_MAP_ENTITE<class MG_TRIANGLE*>& liste_intersection)
{
    liste_intersection.vide();
    MG_NOEUD* noeud1=ft->get_noeud1();
    MG_NOEUD* noeud2=ft->get_noeud2();
    MG_NOEUD* noeud3=ft->get_noeud3();

    MG_NOEUD* noeud;
    MG_TETRA* tet=mg_maillage->get_mg_tetra(noeud1,noeud2,noeud3,noeud4);
    if (tet!=NULL)
        return NULL;
    TPL_MAP_ENTITE<MG_FRONT_3D*> liste;
    double x=0.25*(noeud1->get_x()+noeud2->get_x()+noeud3->get_x()+noeud4->get_x());
    double y=0.25*(noeud1->get_y()+noeud2->get_y()+noeud3->get_y()+noeud4->get_y());
    double z=0.25*(noeud1->get_z()+noeud2->get_z()+noeud3->get_z()+noeud4->get_z());
    double longueur=1.2*sqrt((x-noeud1->get_x())*(x-noeud1->get_x())+(y-noeud1->get_y())*(y-noeud1->get_y())+(z-noeud1->get_z())*(z-noeud1->get_z()));
    ntree_de_front->rechercher(x,y,z,longueur,liste);
    int nb_liste=liste.get_nb();
    for (int i=0;i<nb_liste;i++)
    {
        MG_FRONT_3D* fttmp=liste.get(i);
        /*if (passetmp>=256957)
        if (i==32)
            {
              double *xyz1=noeud1->get_coord();
              double *xyz2=noeud2->get_coord();
              double *xyz3=noeud3->get_coord();
              double *xyz4=noeud4->get_coord();
              double *xyz4bis=fttmp->get_noeud3()->get_coord();
              double xx=fttmp->get_noeud3()->get_x();
              double yy=fttmp->get_noeud3()->get_y();
              double zz=fttmp->get_noeud3()->get_z();
              double xx2=noeud4->get_x();
              double yy2=noeud4->get_y();
              double zz2=noeud4->get_z();
              int res=OPERATEUR::estdansletetra(xyz1,xyz2,xyz3,xyz4,xx,yy,zz);
              int res2=OPERATEUR::estdansletetra(xyz1,xyz2,xyz4bis,xyz3,xx2,yy2,zz2);
            }*/
        int inter=inter_tetra_triangle(noeud1,noeud2,noeud3,noeud4,fttmp->get_noeud1(),fttmp->get_noeud2(),fttmp->get_noeud3());
        
        if (inter==true)
            liste_intersection.ajouter(fttmp->get_triangle());
    }
    int nb_inter=liste_intersection.get_nb();
    if (nb_inter>0)
        return NULL;
    MG_TRIANGLE* triangle1=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud3->get_id(),noeud2->get_id());
    MG_TRIANGLE* triangle2=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud2->get_id(),noeud4->get_id());
    MG_TRIANGLE* triangle3=mg_maillage->get_mg_triangle(noeud2->get_id(),noeud3->get_id(),noeud4->get_id());
    MG_TRIANGLE* triangle4=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud4->get_id(),noeud3->get_id());
    double vol1=-1.;
    double vol2=-1.;
    double vol3=-1.;
    double vol4=-1.;
    if (type==MAGIC::MAILLEURFRONTALETAT::GENERATION_NOEUD)
    {
        if (triangle1!=NULL)
            if (triangle1->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
            {
                M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle1;
                MG_TETRA* tet=tri->get_voisin(0);
                if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
                {
                    M3D_TETRA* mtet=(M3D_TETRA*)tet;
                    vol1=mtet->get_volume();
                }
            }
        if (triangle2!=NULL)
            if (triangle2->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
            {
                M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle2;
                MG_TETRA* tet=tri->get_voisin(0);
                if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
                {
                    M3D_TETRA* mtet=(M3D_TETRA*)tet;
                    vol2=mtet->get_volume();
                }
            }
        if (triangle3!=NULL)
            if (triangle3->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
            {
                M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle3;
                MG_TETRA* tet=tri->get_voisin(0);
                if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
                {
                    M3D_TETRA* mtet=(M3D_TETRA*)tet;
                    vol3=mtet->get_volume();
                }
            }
        if (triangle4!=NULL)
            if (triangle4->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
            {
                M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle4;
                MG_TETRA* tet=tri->get_voisin(0);
                if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
                {
                    M3D_TETRA* mtet=(M3D_TETRA*)tet;
                    vol4=mtet->get_volume();
                }
            }
        double vol=calcule_volume(noeud1,noeud2,noeud3,noeud4);
        // calcul du vol du tetra ideal
        OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
        OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
        OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());
        OT_VECTEUR_3D vec=ab&ac;
        vec.norme();
        double lg_tet_ideal=fabs(vec*da*ft->get_ifail()*sqrt(3./2.));
        double vol_ideal=sqrt(2.)/12.*lg_tet_ideal*lg_tet_ideal*lg_tet_ideal;
        if (vol<0.1*vol_ideal)
        {
            if ((vol1>0.) && (vol1<0.1*vol_ideal)) 
                return NULL;
            if ((vol2>0.) && (vol2<0.1*vol_ideal)) 
                return NULL;
            if ((vol3>0.) && (vol3<0.1*vol_ideal)) 
                return NULL;
            if ((vol4>0.) && (vol4<0.1*vol_ideal)) 
                return NULL;
            
        }
    }


    if (triangle1==NULL) triangle1=insere_triangle(mgvol,noeud1,noeud3,noeud2,MAGIC::ORIGINE::MAILLEUR_AUTO);
    if (triangle2==NULL) triangle2=insere_triangle(mgvol,noeud1,noeud2,noeud4,MAGIC::ORIGINE::MAILLEUR_AUTO);
    if (triangle3==NULL) triangle3=insere_triangle(mgvol,noeud2,noeud3,noeud4,MAGIC::ORIGINE::MAILLEUR_AUTO);
    if (triangle4==NULL) triangle4=insere_triangle(mgvol,noeud1,noeud4,noeud3,MAGIC::ORIGINE::MAILLEUR_AUTO);
    MG_TETRA* tetra=cree_tetra(mgvol,noeud1,noeud2,noeud3,noeud4,triangle1,triangle2,triangle3,triangle4,MAGIC::ORIGINE::MAILLEUR_AUTO);
    mg_maillage->ajouter_mg_tetra(tetra);
    if (triangle1->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle1;
        tri->ajouter_voisin(tetra);
    }
    if (triangle2->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle2;
        tri->ajouter_voisin(tetra);
    }
    if (triangle3->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle3;
        tri->ajouter_voisin(tetra);
    }
    if (triangle4->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)triangle4;
        tri->ajouter_voisin(tetra);
    }
    
    return tetra;

}


class MG_TRIANGLE* MAILLEUR3D::insere_triangle(class MG_VOLUME* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,int origine)
{
   // existence du triangle
    MG_TRIANGLE* triangle=mg_maillage->get_mg_triangle(noeud1->get_id(),noeud3->get_id(),noeud2->get_id());
    if (triangle!=NULL) return NULL;
    MG_SEGMENT* segment1=mg_maillage->get_mg_segment(noeud1->get_id(),noeud2->get_id());
    MG_SEGMENT* segment2=mg_maillage->get_mg_segment(noeud1->get_id(),noeud3->get_id());
    MG_SEGMENT* segment3=mg_maillage->get_mg_segment(noeud2->get_id(),noeud3->get_id());
    if (segment1==NULL) segment1=cree_segment(mgvol,noeud1,noeud2,origine);
    if (segment2==NULL) segment2=cree_segment(mgvol,noeud1,noeud3,origine);
    if (segment3==NULL) segment3=cree_segment(mgvol,noeud2,noeud3,origine);
    MG_TRIANGLE* tri=cree_triangle(mgvol,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
    return tri;
}


class MG_SEGMENT* MAILLEUR3D::insere_segment(class MG_VOLUME* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,int origine)
{
   
    MG_SEGMENT* segment=mg_maillage->get_mg_segment(noeud1->get_id(),noeud2->get_id());
    if (segment!=NULL) return NULL;
    MG_SEGMENT* seg=cree_segment(mgvol,noeud1,noeud2,origine);
    return seg;
}


MG_TETRA* MAILLEUR3D::cree_tetra(class MG_VOLUME* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4,MG_TRIANGLE* triangle1,MG_TRIANGLE* triangle2,MG_TRIANGLE* triangle3,MG_TRIANGLE* triangle4,int origine)
{
    M3D_TETRA* tetra=new M3D_TETRA(mgvol,noeud1,noeud2,noeud3,noeud4,triangle1,triangle2,triangle3,triangle4,origine);
    mg_maillage->ajouter_mg_tetra(tetra);
    return tetra;
}


MG_TRIANGLE* MAILLEUR3D::cree_triangle(class MG_VOLUME* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_SEGMENT* segment1,MG_SEGMENT* segment2,MG_SEGMENT* segment3,int origine)
{
    M3D_TRIANGLE* tri=new M3D_TRIANGLE(mgvol,noeud1,noeud2,noeud3,segment1,segment2,segment3,origine);
    mg_maillage->ajouter_mg_triangle(tri);
    return tri;
}


MG_SEGMENT* MAILLEUR3D::cree_segment(class MG_VOLUME* mgvol,MG_NOEUD* noeud1,MG_NOEUD* noeud2,int origine)
{
    MG_SEGMENT* seg=mg_maillage->ajouter_mg_segment(mgvol,noeud1,noeud2,origine);
    return seg;
}


double MAILLEUR3D::calcule_volume(MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4)
{
    OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
    OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
    OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());

    OT_VECTEUR_3D pvec=ab&ac;
    double volume=pvec*da;
    volume=fabs(volume)/3.;
    return volume;
}


double MAILLEUR3D::calcule_longueur_caracteristique(MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_NOEUD* noeud4)
{

    OT_VECTEUR_3D ab(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
    double lg=ab.get_longueur();
    int nb=1;
    if (noeud3!=NULL)
    {
        OT_VECTEUR_3D ac(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
        OT_VECTEUR_3D bc(noeud3->get_x()-noeud2->get_x(),noeud3->get_y()-noeud2->get_y(),noeud3->get_z()-noeud2->get_z());
        lg=lg+ac.get_longueur()+bc.get_longueur();
        nb=3;
    }
    if (noeud4!=NULL)
    {
        OT_VECTEUR_3D da(noeud1->get_x()-noeud4->get_x(),noeud1->get_y()-noeud4->get_y(),noeud1->get_z()-noeud4->get_z());
        OT_VECTEUR_3D bd(noeud4->get_x()-noeud2->get_x(),noeud4->get_y()-noeud2->get_y(),noeud4->get_z()-noeud2->get_z());
        OT_VECTEUR_3D cd(noeud4->get_x()-noeud3->get_x(),noeud4->get_y()-noeud3->get_y(),noeud4->get_z()-noeud3->get_z());
        lg=lg+da.get_longueur()+bd.get_longueur()+cd.get_longueur();
        nb=6;
    }
    lg=lg*1./nb;
    return lg;

}

double MAILLEUR3D::calcul_distance_metrique_segment(MG_SEGMENT *seg,int pas)
{
double l;
bool res=seg->get_distance_metrique(&l);
if (res==false)
  {
  l=metrique->calcul_distance_metrique(seg,pas);  
  seg->change_distance_metrique(l);
  }
return l;
}


int MAILLEUR3D::genere_noeud(MG_VOLUME* mgvol,MG_FRONT_3D* ft,TPL_MAP_ENTITE<MG_NOEUD*> &liste_noeud,std::vector<CAS_FRONT*> &liste_cas)
{
    MG_NOEUD* noeud1=ft->get_noeud1();
    MG_NOEUD* noeud2=ft->get_noeud2();
    MG_NOEUD* noeud3=ft->get_noeud3();
    OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
    OT_VECTEUR_3D normalnonnorme=n1n2&n1n3;
    OT_VECTEUR_3D normal=normalnonnorme;
    normal.norme();
    double xyz1[3]={noeud1->get_x(),noeud1->get_y(),noeud1->get_z()};
    double xyz2[3]={noeud2->get_x(),noeud2->get_y(),noeud2->get_z()};
    double xyz3[3]={noeud3->get_x(),noeud3->get_y(),noeud3->get_z()};
    double hauteur=0.81649658*ft->get_triangle()->get_longueur();
    double xyzg[3]={0.333333333333*(xyz1[0]+xyz2[0]+xyz3[0]),0.333333333333*(xyz1[1]+xyz2[1]+xyz3[1]),0.333333333333*(xyz1[2]+xyz2[2]+xyz3[2])};
    double xyz4[3];
    do
    {
        xyz4[0]=xyzg[0]+hauteur*normal.get_x();
        xyz4[1]=xyzg[1]+hauteur*normal.get_y();
        xyz4[2]=xyzg[2]+hauteur*normal.get_z();
        hauteur=hauteur*0.9;
    }
    while (metrique->valide_parametre(xyz4)==0);
    double l1=calcul_distance_metrique_segment(ft->get_triangle()->get_segment1(),pas);
    double l2=calcul_distance_metrique_segment(ft->get_triangle()->get_segment2(),pas);
    double l3=calcul_distance_metrique_segment(ft->get_triangle()->get_segment3(),pas);
    double l=0.333333333333333*(l1+l2+l3);
    double longueur_desiree=0.81649658*(priorite_metrique+(1-priorite_metrique)*l);
    longueur_desiree=longueur_desiree/ft->get_ifail();
    int res=metrique->ajuste_distance_metrique(xyzg,xyz4,longueur_desiree,pas);
    if (res==0) return MAGIC::MAILLEURFRONTALETAT::PASTROUVE;
    OT_VECTEUR_3D hauteurajustee(xyzg[0]-xyz4[0],xyzg[1]-xyz4[1],xyzg[2]-xyz4[2]);
    hauteur=hauteurajustee.get_longueur();

    TPL_MAP_ENTITE<MG_FRONT_3D*> liste_front;
    TPL_MAP_ENTITE<MG_FRONT_3D*> liste_front_proche;
    ntree_de_front->rechercher(xyz4[0],xyz4[1],xyz4[2],hauteur*1.837117307,liste_front);
    int nb_liste=liste_front.get_nb();
    double disref=(priorite_metrique+(1-priorite_metrique)*l)/ft->get_ifail();
    MG_NOEUD* noeudref=NULL;
    for (int i=0;i<nb_liste;i++)
    {
        MG_FRONT_3D* ft2=liste_front.get(i);
        for (int j=0;j<3;j++)
        {
            MG_NOEUD* noeud_tmp;
            if (j==0) noeud_tmp=ft2->get_noeud1();
            if (j==1) noeud_tmp=ft2->get_noeud2();
            if (j==2) noeud_tmp=ft2->get_noeud3();
            double *xyz_tmp=noeud_tmp->get_coord();
            // ici il faut verifier que ;'on pogne un noeud du bon coté du front
            OT_VECTEUR_3D vec(xyz_tmp[0]-xyzg[0],xyz_tmp[1]-xyzg[1],xyz_tmp[2]-xyzg[2]);
            double eps=0.333333333333333*(vec.diff()+n1n2.diff()+n1n3.diff());
            eps=6.*eps*EPS_BASE_RELATIVE;
            if (vec*normalnonnorme<eps) continue;
            double dis=metrique->calcul_distance_metrique(xyz_tmp,xyz4,1);
            if (dis<disref)
            {
                disref=dis;
                noeudref=noeud_tmp;
            }
        }
        if (ft2!=ft)
        {
            double dismin=evaluer_distance_noeud_triangle(xyz4[0],xyz4[1],xyz4[2],ft2->get_triangle());
            if (dismin<hauteur) liste_front_proche.ajouter(ft2);
        }
    }
    if (noeudref!=NULL)
    {
        double dis2=metrique->calcul_distance_metrique(noeudref->get_coord(),xyzg,2);
        if (dis2<longueur_desiree*1.5)
            if (noeudref!=noeud1)
                if (noeudref!=noeud2)
                    if (noeudref!=noeud3)
                    {
                        liste_noeud.ajouter(noeudref);
                        return MAGIC::MAILLEURFRONTALETAT::EXISTE;
                    }
    }
    int nb_proche=liste_front_proche.get_nb();
    int nb_cas=liste_cas.size();
    if (nb_proche>0)
    {
        for (int i=0;i<nb_proche;i++)
        {
            MG_FRONT_3D* fttmp=liste_front_proche.get(i);
            int ok=0;
            for (int j=0;j<nb_cas;j++)
            {
                MG_NOEUD* casnoeud=liste_cas[j]->mgnoeud;
                if ((fttmp->get_noeud1()==casnoeud) || (fttmp->get_noeud2()==casnoeud) || (fttmp->get_noeud3()==casnoeud) )
                {
                    ok=1;
                    break;
                }
            }
            if (ok==1) continue;
            MG_NOEUD* noeudtmp=fttmp->get_noeud1();
            if (noeudtmp!=noeud1)
                if (noeudtmp!=noeud2)
                    if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);
            noeudtmp=fttmp->get_noeud2();
            if (noeudtmp!=noeud1)
                if (noeudtmp!=noeud2)
                    if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);
            noeudtmp=fttmp->get_noeud3();
            if (noeudtmp!=noeud1)
                if (noeudtmp!=noeud2)
                    if (noeudtmp!=noeud3) liste_noeud.ajouter(noeudtmp);

        }
        if (liste_noeud.get_nb()>0) return MAGIC::MAILLEURFRONTALETAT::MULTIEXISTE;
    }
    M3D_NOEUD* nouveau_noeud=new M3D_NOEUD(mgvol,xyz4[0],xyz4[1],xyz4[2],MAGIC::ORIGINE::MAILLEUR_AUTO);
    mg_maillage->ajouter_mg_noeud(nouveau_noeud);
    liste_noeud.ajouter(nouveau_noeud);
    return MAGIC::MAILLEURFRONTALETAT::CREATION;
}


double MAILLEUR3D::evaluer_distance_noeud_triangle(double x,double y,double z,MG_TRIANGLE* tri)
{
    double eps=0.0001;
    MG_NOEUD* noeud1=tri->get_noeud1();
    MG_NOEUD* noeud2=tri->get_noeud2();
    MG_NOEUD* noeud3=tri->get_noeud3();
    OT_VECTEUR_3D n1n2(noeud2->get_x()-noeud1->get_x(),noeud2->get_y()-noeud1->get_y(),noeud2->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n3(noeud3->get_x()-noeud1->get_x(),noeud3->get_y()-noeud1->get_y(),noeud3->get_z()-noeud1->get_z());
    OT_VECTEUR_3D n1n4(x-noeud1->get_x(),y-noeud1->get_y(),z-noeud1->get_z());
    OT_VECTEUR_3D n1n=n1n2&n1n3;
    OT_MATRICE_3D matbase(n1n2,n1n3,n1n);
    OT_MATRICE_3D matxsi(n1n4,n1n3,n1n);
    OT_MATRICE_3D mateta(n1n2,n1n4,n1n);
    double xsi=matxsi.get_determinant()/matbase.get_determinant();
    double eta=mateta.get_determinant()/matbase.get_determinant();
    double dis;
    if ((eta>-eps) && (xsi>-eps) && (eta+xsi<1.0+eps))
    {
        double xproj=(1-xsi-eta)*noeud1->get_x()+xsi*noeud2->get_x()+eta*noeud3->get_x();
        double yproj=(1-xsi-eta)*noeud1->get_y()+xsi*noeud2->get_y()+eta*noeud3->get_y();
        double zproj=(1-xsi-eta)*noeud1->get_z()+xsi*noeud2->get_z()+eta*noeud3->get_z();
        OT_VECTEUR_3D vec(x-xproj,y-yproj,z-zproj);
        dis=vec.get_longueur();
    }
    else
    {
        OT_VECTEUR_3D nn1(x-noeud1->get_x(),y-noeud1->get_y(),z-noeud1->get_z());
        OT_VECTEUR_3D nn2(x-noeud2->get_x(),y-noeud2->get_y(),z-noeud2->get_z());
        OT_VECTEUR_3D nn3(x-noeud3->get_x(),y-noeud3->get_y(),z-noeud3->get_z());
        dis=0.3333333333333*(nn1.get_longueur()+nn2.get_longueur()+nn3.get_longueur());
    }
    return dis;
}


void MAILLEUR3D::detruit_tetra(MG_TRIANGLE* tri)
{
    
    M3D_TRIANGLE* mtri;
    mtri=(M3D_TRIANGLE*)tri;

    M3D_TETRA* tet=(M3D_TETRA*)mtri->get_voisin(0);
    M3D_TRIANGLE* mtriangle1=(M3D_TRIANGLE*)tet->get_triangle1();
    M3D_TRIANGLE* mtriangle2=(M3D_TRIANGLE*)tet->get_triangle2();
    M3D_TRIANGLE* mtriangle3=(M3D_TRIANGLE*)tet->get_triangle3();
    M3D_TRIANGLE* mtriangle4=(M3D_TRIANGLE*)tet->get_triangle4();
     tet->etat_detruit();
    lsttet_a_detruire.ajouter(tet);
    TPL_MAP_ENTITE<MG_FRONT_3D*> liste_de_front;
    TPL_MAP_ENTITE<MG_FRONT_3D*> liste_de_front2;
    MG_FRONT_3D* fttet1=NULL;
    MG_FRONT_3D* fttet2=NULL;
    MG_FRONT_3D* fttet3=NULL;
    MG_FRONT_3D* fttet4=NULL;

    if (mtriangle1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
    {
        MG_FRONT_3D* fttmp=mtriangle1->get_mgfront();
        fttet1=fttmp;
        liste_de_front.ajouter(fttmp->get_front_voisin(0));
        liste_de_front.ajouter(fttmp->get_front_voisin(1));
        liste_de_front.ajouter(fttmp->get_front_voisin(2));
        //supprimer_front_en_reculant(fttmp);
        mtriangle1->supprimer_voisin(tet);
    }
    else
    {
        MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud2(),tet->get_noeud3(),mtriangle1);
        ftn1->incremente_ifail();
        mtriangle1->supprimer_voisin(tet);
        liste_de_front2.ajouter(ftn1);
    }
    if (mtriangle2->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
    {
        MG_FRONT_3D* fttmp=mtriangle2->get_mgfront();
        fttet2=fttmp;
        liste_de_front.ajouter(fttmp->get_front_voisin(0));
        liste_de_front.ajouter(fttmp->get_front_voisin(1));
        liste_de_front.ajouter(fttmp->get_front_voisin(2));
        //supprimer_front_en_reculant(fttmp);
        mtriangle2->supprimer_voisin(tet);
    }
    else
    {
        MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud4(),tet->get_noeud2(),mtriangle2);
        ftn1->incremente_ifail();
        mtriangle2->supprimer_voisin(tet);
        liste_de_front2.ajouter(ftn1);
    }
    if (mtriangle3->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
    {
        MG_FRONT_3D* fttmp=mtriangle3->get_mgfront();
        fttet3=fttmp;
        liste_de_front.ajouter(fttmp->get_front_voisin(0));
        liste_de_front.ajouter(fttmp->get_front_voisin(1));
        liste_de_front.ajouter(fttmp->get_front_voisin(2));
        //supprimer_front_en_reculant(fttmp);
        mtriangle3->supprimer_voisin(tet);
    }
    else
    {
        MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud2(),tet->get_noeud4(),tet->get_noeud3(),mtriangle3);
        ftn1->incremente_ifail();
        mtriangle3->supprimer_voisin(tet);
        liste_de_front2.ajouter(ftn1);
    }
    if (mtriangle4->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
    {
        MG_FRONT_3D* fttmp=mtriangle4->get_mgfront();
        fttet4=fttmp;
        liste_de_front.ajouter(fttmp->get_front_voisin(0));
        liste_de_front.ajouter(fttmp->get_front_voisin(1));
        liste_de_front.ajouter(fttmp->get_front_voisin(2));
        //supprimer_front_en_reculant(fttmp);
        mtriangle4->supprimer_voisin(tet);
    }
    else
    {
        MG_FRONT_3D* ftn1=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::PRIORITAIRE,tet->get_noeud1(),tet->get_noeud3(),tet->get_noeud4(),mtriangle4);
        ftn1->incremente_ifail();
        mtriangle4->supprimer_voisin(tet);
        liste_de_front2.ajouter(ftn1);
    }

    if (fttet1!=NULL)
    {
        liste_de_front.supprimer(fttet1);
        supprimer_front_en_reculant(fttet1);
    }
    if (fttet2!=NULL)
    {
        liste_de_front.supprimer(fttet2);
        supprimer_front_en_reculant(fttet2);
    }
    if (fttet3!=NULL)
    {
        liste_de_front.supprimer(fttet3);
        supprimer_front_en_reculant(fttet3);
    }
    if (fttet4!=NULL)
    {
        liste_de_front.supprimer(fttet4);
        supprimer_front_en_reculant(fttet4);
    }
    int nb_liste1=liste_de_front.get_nb();
    for (int i=0;i<nb_liste1;i++)
        if (liste_de_front.get(i)!=NULL)
            mise_a_jour_voisin_front(liste_de_front.get(i));
    int nb_liste2=liste_de_front2.get_nb();
    for (int i=0;i<nb_liste2;i++)
    {
        mise_a_jour_voisin_front(liste_de_front2.get(i));
        mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(0));
        mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(1));
        mise_a_jour_voisin_front(liste_de_front2.get(i)->get_front_voisin(2));
    }

    for (int k=0;k<4;k++)
    {
        MG_NOEUD* noeud;
        if (k==0) noeud=tet->get_noeud1();
        if (k==1) noeud=tet->get_noeud2();
        if (k==2) noeud=tet->get_noeud3();
        if (k==3) noeud=tet->get_noeud4();
        int nb_tet=noeud->get_lien_tetra()->get_nb();

        if (noeud->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_NOEUD)
        {
            int test=false;
            M3D_NOEUD* mnoeud=(M3D_NOEUD*)noeud;
            for (int i=0;i<nb_tet;i++)
            {
                MG_TETRA* tet=noeud->get_lien_tetra()->get(i);
                if (tet->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TETRA)
                {
                    M3D_TETRA* mtet=(M3D_TETRA*)tet;
                    if (mtet->get_etat()==MAGIC::MAILLEURFRONTALETAT::ACTIF) test=true;
                }
                else test=true;
            }
            if (test==false) 
                  {
                    mnoeud->etat_detruit();
                    lstnoeud_a_detruire.ajouter(mnoeud);
                   }
        }
    }
    
}


void MAILLEUR3D::detruit_element_inactif(void)
{
   /* LISTE_MG_TETRA::iterator it;

    for (MG_TETRA* tet=mg_maillage->get_premier_tetra(it);tet!=NULL;tet=mg_maillage->get_suivant_tetra(it))
    {
        M3D_TETRA* mtet=(M3D_TETRA*)tet;
        if (mtet->get_etat()==DETRUIT)
            lsttet.ajouter(tet);
    }
    LISTE_MG_NOEUD::iterator it2;
    for (MG_NOEUD* noeud=mg_maillage->get_premier_noeud(it2);noeud!=NULL;noeud=mg_maillage->get_suivant_noeud(it2))
    {
        if (noeud->get_type_entite()==IDM3D_NOEUD)
        {
            M3D_NOEUD* mnoeud=(M3D_NOEUD*)noeud;
            if (mnoeud->get_etat()==DETRUIT)
                lstnoeud.ajouter(noeud);
        }
    }*/
    TPL_MAP_ENTITE<MG_TETRA*>::ITERATEUR it3;
    for (MG_TETRA* tet=lsttet_a_detruire.get_premier(it3);tet!=NULL;tet=lsttet_a_detruire.get_suivant(it3))
        supprimer_mg_tetra(tet);
    TPL_MAP_ENTITE<MG_NOEUD*>::ITERATEUR it4;
    for (MG_NOEUD* noeud=lstnoeud_a_detruire.get_premier(it4);noeud!=NULL;noeud=lstnoeud_a_detruire.get_suivant(it4))
        mg_maillage->supprimer_mg_noeudid(noeud->get_id());
    lstnoeud_a_detruire.vide();
    lsttet_a_detruire.vide();
    
}


void MAILLEUR3D::analyse_maillage_obtenu(double &vol,int *tab,double borne1,double borne2,double borne3)
{
    vol=0.;tab[0]=0;tab[1]=0;tab[2]=0;tab[3]=0;
    LISTE_MG_TETRA::iterator it;
    for (MG_TETRA* tet=mg_maillage->get_premier_tetra(it);tet!=NULL;tet=mg_maillage->get_suivant_tetra(it))
    {
        vol=vol+metrique->calcul_volume_tetra_metrique(tet);
        double qual=OPERATEUR::qualite_tetra(tet->get_noeud1()->get_coord(),tet->get_noeud2()->get_coord(),tet->get_noeud3()->get_coord(),tet->get_noeud4()->get_coord());
        if (qual>=borne3) tab[3]++;
        else if (qual>=borne2) tab[2]++;
        else if (qual>=borne1) tab[1]++;
        else tab[0]++;
    }
}


void MAILLEUR3D::insere_contrainte_tetra(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TETRA*> *lsttet)
{
    std::map<long,long,std::less<long> > lstcorrespondancenoeud;
    int nbtet=lsttet->get_nb();
    for (int i=0;i<nbtet;i++)
    {
        M3D_TETRA* tet=(M3D_TETRA*)lsttet->get(i);
        double *xyz1=tet->get_noeud1()->get_coord();
        double *xyz2=tet->get_noeud2()->get_coord();
        double *xyz3=tet->get_noeud3()->get_coord();
        double *xyz4=tet->get_noeud4()->get_coord();
        double xyz[3];
        xyz[0]=(xyz1[0]+xyz2[0]+xyz3[0]+xyz4[0])*0.25;
        xyz[1]=(xyz1[1]+xyz2[1]+xyz3[1]+xyz4[1])*0.25;
        xyz[2]=(xyz1[2]+xyz2[2]+xyz3[2]+xyz4[2])*0.25;
        TPL_MAP_ENTITE<MG_FRONT_3D*> liste_trouvee;
        OT_VECTEUR_3D vec1(xyz,xyz1);
        OT_VECTEUR_3D vec2(xyz,xyz2);
        OT_VECTEUR_3D vec3(xyz,xyz3);
        OT_VECTEUR_3D vec4(xyz,xyz4);
        double rayonrecherche=vec1.get_longueur();
        if (vec2.get_longueur()>rayonrecherche) rayonrecherche=vec2.get_longueur();
        if (vec3.get_longueur()>rayonrecherche) rayonrecherche=vec3.get_longueur();
        if (vec4.get_longueur()>rayonrecherche) rayonrecherche=vec4.get_longueur();
        rayonrecherche=rayonrecherche*1.1;
        ntree_de_front->rechercher(xyz[0],xyz[1],xyz[2],rayonrecherche,liste_trouvee);
        MG_NOEUD* noeudref1=NULL;
        if (lstcorrespondancenoeud.find(tet->get_noeud1()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
            noeudref1=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud1()->get_nouveau_numero()]);
        MG_NOEUD* noeudref2=NULL;
        if (lstcorrespondancenoeud.find(tet->get_noeud2()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
            noeudref2=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud2()->get_nouveau_numero()]);
        MG_NOEUD* noeudref3=NULL;
        if (lstcorrespondancenoeud.find(tet->get_noeud3()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
            noeudref3=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud3()->get_nouveau_numero()]);
        MG_NOEUD* noeudref4=NULL;
        if (lstcorrespondancenoeud.find(tet->get_noeud4()->get_nouveau_numero())!=lstcorrespondancenoeud.end())
            noeudref4=mg_maillage->get_mg_noeudid(lstcorrespondancenoeud[tet->get_noeud4()->get_nouveau_numero()]);
        int nbtrouve=liste_trouvee.get_nb();
        for (int j=0;j<nbtrouve;j++)
        {
            if ((noeudref1!=NULL) && (noeudref2!=NULL) && (noeudref3!=NULL) && (noeudref4!=NULL) ) break;
            MG_FRONT_3D* ft=liste_trouvee.get(j);
            TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
            lstnoeud.ajouter(ft->get_noeud1());
            lstnoeud.ajouter(ft->get_noeud2());
            lstnoeud.ajouter(ft->get_noeud3());
            if (noeudref1==NULL)
            {
                int nb=lstnoeud.get_nb();
                for (int k=0;k<nb;k++)
                {
                    double *xyztmp=lstnoeud.get(k)->get_coord();
                    OT_VECTEUR_3D vec(xyztmp,xyz1);
                    double longueur=vec.get_longueur();
                    if (longueur<1e-6*rayonrecherche)
                    {
                        noeudref1=lstnoeud.get(k);
                        lstnoeud.supprimer(lstnoeud.get(k));
                        break;
                    }
                }
            }
            if (noeudref2==NULL)
            {
                int nb=lstnoeud.get_nb();
                for (int k=0;k<nb;k++)
                {
                    double *xyztmp=lstnoeud.get(k)->get_coord();
                    OT_VECTEUR_3D vec(xyztmp,xyz2);
                    double longueur=vec.get_longueur();
                    if (longueur<1e-6*rayonrecherche)
                    {
                        noeudref2=lstnoeud.get(k);
                        lstnoeud.supprimer(lstnoeud.get(k));
                        break;
                    }
                }
            }
            if (noeudref3==NULL)
            {
                int nb=lstnoeud.get_nb();
                for (int k=0;k<nb;k++)
                {
                    double *xyztmp=lstnoeud.get(k)->get_coord();
                    OT_VECTEUR_3D vec(xyztmp,xyz3);
                    double longueur=vec.get_longueur();
                    if (longueur<1e-6*rayonrecherche)
                    {
                        noeudref3=lstnoeud.get(k);
                        lstnoeud.supprimer(lstnoeud.get(k));
                        break;
                    }
                }
            }
            if (noeudref4==NULL)
            {
                int nb=lstnoeud.get_nb();
                for (int k=0;k<nb;k++)
                {
                    double *xyztmp=lstnoeud.get(k)->get_coord();
                    OT_VECTEUR_3D vec(xyztmp,xyz4);
                    double longueur=vec.get_longueur();
                    if (longueur<1e-6*rayonrecherche)
                    {
                        noeudref4=lstnoeud.get(k);
                        lstnoeud.supprimer(lstnoeud.get(k));
                        break;
                    }
                }
            }
        }
        if (noeudref1==NULL)
        {
            noeudref1=mg_maillage->ajouter_mg_noeud(mgvol,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
            if (tet->get_noeud1()->get_nouveau_numero()!=(-1))
            {
                noeudref1->change_nouveau_numero(tet->get_noeud1()->get_nouveau_numero());
                std::pair<long,long> tmp(noeudref1->get_nouveau_numero(),noeudref1->get_id());
                lstcorrespondancenoeud.insert(tmp);
            }
        }
        if (noeudref2==NULL)
        {
            noeudref2=mg_maillage->ajouter_mg_noeud(mgvol,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
            if (tet->get_noeud2()->get_nouveau_numero()!=(-1))
            {
                noeudref2->change_nouveau_numero(tet->get_noeud2()->get_nouveau_numero());
                std::pair<long,long> tmp(noeudref2->get_nouveau_numero(),noeudref2->get_id());
                lstcorrespondancenoeud.insert(tmp);
            }
        }
        if (noeudref3==NULL)
        {
            noeudref3=mg_maillage->ajouter_mg_noeud(mgvol,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
            if (tet->get_noeud3()->get_nouveau_numero()!=(-1))
            {
                noeudref3->change_nouveau_numero(tet->get_noeud3()->get_nouveau_numero());
                std::pair<long,long> tmp(noeudref3->get_nouveau_numero(),noeudref3->get_id());
                lstcorrespondancenoeud.insert(tmp);
            }
        }
        if (noeudref4==NULL)
        {
            noeudref4=mg_maillage->ajouter_mg_noeud(mgvol,xyz4[0],xyz4[1],xyz4[2],MAGIC::ORIGINE::IMPOSE);
            if (tet->get_noeud4()->get_nouveau_numero()!=(-1))
            {
                noeudref4->change_nouveau_numero(tet->get_noeud4()->get_nouveau_numero());
                std::pair<long,long> tmp(noeudref4->get_nouveau_numero(),noeudref4->get_id());
                lstcorrespondancenoeud.insert(tmp);
            }
        }
        M3D_TRIANGLE* triangle1=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref3->get_id(),noeudref2->get_id());
        M3D_TRIANGLE* triangle2=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref2->get_id(),noeudref4->get_id());
        M3D_TRIANGLE* triangle3=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref2->get_id(),noeudref3->get_id(),noeudref4->get_id());
        M3D_TRIANGLE* triangle4=(M3D_TRIANGLE*)mg_maillage->get_mg_triangle(noeudref1->get_id(),noeudref4->get_id(),noeudref3->get_id());
        if (triangle1==NULL) triangle1=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref3,noeudref2,MAGIC::ORIGINE::IMPOSE);
        if (triangle2==NULL) triangle2=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref2,noeudref4,MAGIC::ORIGINE::IMPOSE);
        if (triangle3==NULL) triangle3=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref2,noeudref3,noeudref4,MAGIC::ORIGINE::IMPOSE);
        if (triangle4==NULL) triangle4=(M3D_TRIANGLE*)insere_triangle(mgvol,noeudref1,noeudref4,noeudref3,MAGIC::ORIGINE::IMPOSE);
        MG_TETRA* tetra=cree_tetra(mgvol,noeudref1,noeudref2,noeudref3,noeudref4,triangle1,triangle2,triangle3,triangle4,MAGIC::ORIGINE::IMPOSE);
        tetra->change_nouveau_numero(tet->get_nouveau_numero());
        mg_maillage->ajouter_mg_tetra(tetra);
        triangle1->ajouter_voisin(tetra);
        triangle2->ajouter_voisin(tetra);
        triangle3->ajouter_voisin(tetra);
        triangle4->ajouter_voisin(tetra);
        MG_FRONT_3D *ftref1=NULL;
        MG_FRONT_3D *ftref2=NULL;
        MG_FRONT_3D *ftref3=NULL;
        MG_FRONT_3D *ftref4=NULL;
        if (triangle1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref1=triangle1->get_mgfront();
        if (triangle2->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref2=triangle2->get_mgfront();
        if (triangle3->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref3=triangle3->get_mgfront();
        if (triangle4->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF) ftref4=triangle4->get_mgfront();
        TPL_MAP_ENTITE<MG_FRONT_3D*> lstfront;
        MG_FRONT_3D *ft1=NULL;
        MG_FRONT_3D *ft2=NULL;
        MG_FRONT_3D *ft3=NULL;
        MG_FRONT_3D *ft4=NULL;
        if (ftref1==NULL)  ft1=mise_a_jour_front(tetra,0,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
        else
        {
            lstfront.ajouter(ftref1->get_front_voisin(0));
            lstfront.ajouter(ftref1->get_front_voisin(1));
            lstfront.ajouter(ftref1->get_front_voisin(2));
            supprimer_front_en_avancant_sans_delete(ftref1);
        }
        if (ftref2==NULL)  ft2=mise_a_jour_front(tetra,1,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
        else
        {
            lstfront.ajouter(ftref2->get_front_voisin(0));
            lstfront.ajouter(ftref2->get_front_voisin(1));
            lstfront.ajouter(ftref2->get_front_voisin(2));
            supprimer_front_en_avancant_sans_delete(ftref2);
        }
        if (ftref3==NULL)  ft3=mise_a_jour_front(tetra,2,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
        else
        {
            lstfront.ajouter(ftref3->get_front_voisin(0));
            lstfront.ajouter(ftref3->get_front_voisin(1));
            lstfront.ajouter(ftref3->get_front_voisin(2));
            supprimer_front_en_avancant_sans_delete(ftref3);
        }
        if (ftref4==NULL)  ft4=mise_a_jour_front(tetra,3,MAGIC::MAILLEURFRONTALETAT::NONFORCE);
        else
        {
            lstfront.ajouter(ftref4->get_front_voisin(0));
            lstfront.ajouter(ftref4->get_front_voisin(1));
            lstfront.ajouter(ftref4->get_front_voisin(2));
            supprimer_front_en_avancant_sans_delete(ftref4);
        }
        if (ftref1!=NULL) {
            lstfront.supprimer(ftref1);
            delete ftref1;
        }
        if (ftref2!=NULL) {
            lstfront.supprimer(ftref2);
            delete ftref2;
        }
        if (ftref3!=NULL) {
            lstfront.supprimer(ftref3);
            delete ftref3;
        }
        if (ftref4!=NULL) {
            lstfront.supprimer(ftref4);
            delete ftref4;
        }
        if (ft1!=NULL)
        {
            mise_a_jour_voisin_front(ft1);
            lstfront.ajouter(ft1->get_front_voisin(0));
            lstfront.ajouter(ft1->get_front_voisin(1));
            lstfront.ajouter(ft1->get_front_voisin(2));
        }
        if (ft2!=NULL)
        {
            mise_a_jour_voisin_front(ft2);
            lstfront.ajouter(ft2->get_front_voisin(0));
            lstfront.ajouter(ft2->get_front_voisin(1));
            lstfront.ajouter(ft2->get_front_voisin(2));
        }
        if (ft3!=NULL)
        {
            mise_a_jour_voisin_front(ft3);
            lstfront.ajouter(ft3->get_front_voisin(0));
            lstfront.ajouter(ft3->get_front_voisin(1));
            lstfront.ajouter(ft3->get_front_voisin(2));
        }
        if (ft4!=NULL)
        {
            mise_a_jour_voisin_front(ft4);
            lstfront.ajouter(ft4->get_front_voisin(0));
            lstfront.ajouter(ft4->get_front_voisin(1));
            lstfront.ajouter(ft4->get_front_voisin(2));
        }

        for (int l=0;l<lstfront.get_nb();l++) mise_a_jour_voisin_front(lstfront.get(l));

    }
}

void MAILLEUR3D::insere_contrainte_triangle(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TRIANGLE*> *lsttri)
{
    int nbtri=lsttri->get_nb();
    for (int i=0;i<nbtri;i++)
    {
        M3D_TRIANGLE* tri=(M3D_TRIANGLE*)lsttri->get(i);
        double *xyz1=tri->get_noeud1()->get_coord();
        double *xyz2=tri->get_noeud2()->get_coord();
        double *xyz3=tri->get_noeud3()->get_coord();
        double xyz[3];
        xyz[0]=(xyz1[0]+xyz2[0]+xyz3[0])/3.;
        xyz[1]=(xyz1[1]+xyz2[1]+xyz3[1])/3.;
        xyz[2]=(xyz1[2]+xyz2[2]+xyz3[2])/3.;
        TPL_MAP_ENTITE<MG_FRONT_3D*> liste_trouvee;
        OT_VECTEUR_3D vec1(xyz,xyz1);
        OT_VECTEUR_3D vec2(xyz,xyz2);
        OT_VECTEUR_3D vec3(xyz,xyz3);
        double rayonrecherche=vec1.get_longueur();
        if (vec2.get_longueur()>rayonrecherche) rayonrecherche=vec2.get_longueur();
        if (vec3.get_longueur()>rayonrecherche) rayonrecherche=vec3.get_longueur();
        rayonrecherche=rayonrecherche*1.1;
        ntree_de_front->rechercher(xyz[0],xyz[2],xyz[2],rayonrecherche,liste_trouvee);
        MG_NOEUD* noeudref1=NULL;
        MG_NOEUD* noeudref2=NULL;
        MG_NOEUD* noeudref3=NULL;
        int nbtrouve=liste_trouvee.get_nb();
        for (int j=0;j<nbtrouve;j++)
        {
            MG_FRONT_3D* ft=liste_trouvee.get(j);
            TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
            lstnoeud.ajouter(ft->get_noeud1());
            lstnoeud.ajouter(ft->get_noeud2());
            lstnoeud.ajouter(ft->get_noeud3());
            int nb=lstnoeud.get_nb();
            for (int k=0;k<nb;k++)
            {
                double *xyztmp=lstnoeud.get(k)->get_coord();
                OT_VECTEUR_3D vec(xyztmp,xyz1);
                double longueur=vec.get_longueur();
                if (longueur<1e-10*rayonrecherche)
                {
                    noeudref1=lstnoeud.get(k);
                    lstnoeud.supprimer(lstnoeud.get(k));
                    break;
                }
            }
            nb=lstnoeud.get_nb();
            for (int k=0;k<nb;k++)
            {
                double *xyztmp=lstnoeud.get(k)->get_coord();
                OT_VECTEUR_3D vec(xyztmp,xyz2);
                double longueur=vec.get_longueur();
                if (longueur<1e-10*rayonrecherche)
                {
                    noeudref2=lstnoeud.get(k);
                    lstnoeud.supprimer(lstnoeud.get(k));
                    break;
                }
            }
            nb=lstnoeud.get_nb();
            for (int k=0;k<nb;k++)
            {
                double *xyztmp=lstnoeud.get(k)->get_coord();
                OT_VECTEUR_3D vec(xyztmp,xyz3);
                double longueur=vec.get_longueur();
                if (longueur<1e-10*rayonrecherche)
                {
                    noeudref3=lstnoeud.get(k);
                    lstnoeud.supprimer(lstnoeud.get(k));
                    break;
                }
            }

        }
        if (noeudref1==NULL)
        {
            noeudref1=mg_maillage->ajouter_mg_noeud(mgvol,xyz1[0],xyz1[1],xyz1[2],MAGIC::ORIGINE::IMPOSE);
            noeudref1->change_nouveau_numero(tri->get_noeud1()->get_nouveau_numero());
        }
        if (noeudref2==NULL)
        {
            noeudref2=mg_maillage->ajouter_mg_noeud(mgvol,xyz2[0],xyz2[1],xyz2[2],MAGIC::ORIGINE::IMPOSE);
            noeudref2->change_nouveau_numero(tri->get_noeud2()->get_nouveau_numero());
        }
        if (noeudref3==NULL)
        {
            noeudref3=mg_maillage->ajouter_mg_noeud(mgvol,xyz3[0],xyz3[1],xyz3[2],MAGIC::ORIGINE::IMPOSE);
            noeudref3->change_nouveau_numero(tri->get_noeud3()->get_nouveau_numero());
        }

        MG_SEGMENT* segment1=mg_maillage->get_mg_segment(noeudref1->get_id(),noeudref2->get_id());
        MG_SEGMENT* segment2=mg_maillage->get_mg_segment(noeudref1->get_id(),noeudref3->get_id());
        MG_SEGMENT* segment3=mg_maillage->get_mg_segment(noeudref2->get_id(),noeudref3->get_id());
        if (segment1==NULL) segment1=cree_segment(mgvol,noeudref1,noeudref2,MAGIC::ORIGINE::IMPOSE);
        if (segment2==NULL) segment2=cree_segment(mgvol,noeudref1,noeudref3,MAGIC::ORIGINE::IMPOSE);
        if (segment3==NULL) segment3=cree_segment(mgvol,noeudref2,noeudref3,MAGIC::ORIGINE::IMPOSE);
        MG_TRIANGLE* nvtri=cree_triangle(mgvol,noeudref1,noeudref2,noeudref3,segment1,segment2,segment3,MAGIC::ORIGINE::IMPOSE);
        MG_TRIANGLE* nvtri2=cree_triangle(mgvol,noeudref1,noeudref3,noeudref2,segment1,segment2,segment3,MAGIC::ORIGINE::IMPOSE);
        //MG_TRIANGLE* nvtri=insere_triangle(mgvol,noeudref1,noeudref2,noeudref3,IMPOSE);
        //MG_TRIANGLE* nvtri2=insere_triangle(mgvol,noeudref1,noeudref3,noeudref2,IMPOSE);
        MG_FRONT_3D *ft=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,noeudref1,noeudref2,noeudref3,nvtri);
        MG_FRONT_3D *ft2=ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,noeudref1,noeudref3,noeudref2,nvtri2);
        mise_a_jour_voisin_front(ft);
        mise_a_jour_voisin_front(ft2);
        mise_a_jour_voisin_front(ft->get_front_voisin(0));
        mise_a_jour_voisin_front(ft->get_front_voisin(1));
        mise_a_jour_voisin_front(ft->get_front_voisin(2));
        mise_a_jour_voisin_front(ft2->get_front_voisin(0));
        mise_a_jour_voisin_front(ft2->get_front_voisin(1));
        mise_a_jour_voisin_front(ft2->get_front_voisin(2));

    }
}   
    
int MAILLEUR3D::supprimer_mg_tetra(MG_TETRA* mgtetra)
{
    //MG_TETRA* mgtetra=mg_maillage->get_mg_tetra(num);
    if (mgtetra==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgtetra;
    LISTE_ENTITE::iterator i=mg_maillage->lst_entite.find(id);
    mg_maillage->lst_entite.erase(i);
    LISTE_MG_TETRA::iterator j=mg_maillage->lst_mg_tetra.find(id->get_id());
    mg_maillage->lst_mg_tetra.erase(j);
    M3D_TRIANGLE* triangle1=(M3D_TRIANGLE*)mgtetra->get_triangle1();
    M3D_TRIANGLE* triangle2=(M3D_TRIANGLE*)mgtetra->get_triangle2();
    M3D_TRIANGLE* triangle3=(M3D_TRIANGLE*)mgtetra->get_triangle3();
    M3D_TRIANGLE* triangle4=(M3D_TRIANGLE*)mgtetra->get_triangle4();
    delete mgtetra;
    if (triangle1->get_nb_reference()==0)
        if (triangle1->get_lien_topologie()!=NULL)
        {
            if (triangle1->get_lien_topologie()->get_dimension()>2)  mg_maillage->supprimer_mg_triangleid(triangle1->get_id());
        }
        else if (triangle1->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle1->get_id());
    if (triangle2->get_nb_reference()==0)
        if (triangle2->get_lien_topologie()!=NULL)
        {
            if (triangle2->get_lien_topologie()->get_dimension()>2)  mg_maillage->supprimer_mg_triangleid(triangle2->get_id());
        }
        else if (triangle2->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle2->get_id());
    if (triangle3->get_nb_reference()==0)
        if (triangle3->get_lien_topologie()!=NULL)
        {
            if (triangle3->get_lien_topologie()->get_dimension()>2)  mg_maillage->supprimer_mg_triangleid(triangle3->get_id());
        }
        else if (triangle3->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle3->get_id());
    if (triangle4->get_nb_reference()==0)
        if (triangle4->get_lien_topologie()!=NULL)
        {
            if (triangle4->get_lien_topologie()->get_dimension()>2)  mg_maillage->supprimer_mg_triangleid(triangle4->get_id());
        }
        else if (triangle4->get_frontiere()==0) mg_maillage->supprimer_mg_triangleid(triangle4->get_id());
    return OK;
}


Revision:	1158
Committed:	Thu Jun 13 22:18:49 2024 UTC (10 months, 4 weeks ago) by francois
Original Path:	*magic/lib/mailleur_auto/src/mailleur3d_outil.cpp*
File size:	50153 byte(s)
Log Message:	compatibilité Ubuntu 22.04 Suppression des refeences à Windows Ajout d'une banière