mailleur_bloc.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mailleur_bloc.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
#include "gestionversion.h"
#include <math.h>
#include "mailleur_bloc.h"
#include "mg_gestionnaire.h"
#include "mailleur3d.h"
#include "mailleur0d.h"
#include "mailleur1d.h"
#include "mailleur2d.h"
#include "ot_mathematique.h"
#include "mg_geometrie_outils.h"
 
 
 
#pragma package(smart_init)
 
 
 
 
 
MAILLEUR_BLOC::MAILLEUR_BLOC(class MG_GESTIONNAIRE* gentier,MG_GESTIONNAIRE* gbloc,int numgeoentier,int numgeobloc,class FCT_TAILLE* fct_taille,bool save):MAILLEUR(save),gestentier(gentier),gestbloc(gbloc),carte(fct_taille)
{
if (numgeoentier==0) geoentier=gestentier->get_mg_geometrie(numgeoentier);
else geoentier=gestentier->get_mg_geometrieid(numgeoentier);
if (numgeobloc==0) geobloc=gestbloc->get_mg_geometrie(numgeobloc);
else geobloc=gestbloc->get_mg_geometrieid(numgeobloc);
}
 
MAILLEUR_BLOC::~MAILLEUR_BLOC()
{
delete octreeentier;
delete octreebloc;
/*int nbface=maientier->get_mg_geometrie()->get_nb_mg_face();
for (int i=0;i<nbface;i++) delete quadentier[i];
delete [] quadentier;
nbface=maibloc->get_mg_geometrie()->get_nb_mg_face();
for (int i=0;i<nbface;i++) delete quadbloc[i];
delete [] quadbloc;
int nbseg=lstsegfrontentier.get_nb();
for (int i=0;i<nbseg;i++) delete lstsegfrontentier.get(i);
nbseg=lstsegfrontbloc.get_nb();
for (int i=0;i<nbseg;i++) delete lstsegfrontbloc.get(i);*/
 
}
 
 
int MAILLEUR_BLOC::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
{
if(maille(20)==FAIL) return FAIL;
return OK;
}
 
int MAILLEUR_BLOC::maille(int etape)
{
maibloc=new MG_MAILLAGE(geobloc);
maientier=new MG_MAILLAGE(geoentier);
gestbloc->ajouter_mg_maillage(maibloc);
gestentier->ajouter_mg_maillage(maientier);
affiche((char*)"   MAILLAGE 0D du modele entier");
MAILLEUR0D m0d_entier(maientier,geoentier);
m0d_entier.maille();
if (etape<2) return OK;
int nbnoeudentier=maientier->get_nb_mg_noeud();
for (int i=0;i<nbnoeudentier;i++)
        {
        MG_NOEUD* noeud=maientier->get_mg_noeud(i);
        double *xyz=noeud->get_coord();
        MG_SOMMET* som=verif_noeud_sur_sommet(xyz, geobloc);
        if (som!=NULL)
                {
                MG_NOEUD *nvnoeud=new MG_NOEUD(som, xyz[0],xyz[1],xyz[2], MAGIC::ORIGINE::IMPOSE);
                maibloc->ajouter_mg_noeud(nvnoeud);
                //octreebloc->inserer(nvnoeud);
                }
  /*      else
                {
                int num;
                double t;
                MG_ARETE* are=verif_noeud_sur_arete(xyz, geobloc, &num,&t);
                if (are!=NULL)
                        {
                        MG_NOEUD_ADDITIONNEL_ARETE noeud_add;
                        noeud_add.noeud=noeud;
                        noeud_add.t=t;
                        std::pair<double,MG_NOEUD_ADDITIONNEL_ARETE> tmp(t,noeud_add);
                        lst_noeuds_bloc[num].insert(tmp);
                        }
                }*/
 
 
        }
if (etape<3) return OK;
affiche((char*)"   MAILLAGE 0D du modele bloc");
int nbnoeudblocavantm0d=maibloc->get_nb_mg_noeud();
MAILLEUR0D m0d_bloc(maibloc,geobloc);
m0d_bloc.adapte();
if (etape<4) return OK;
int nbnouveaunoeudbloc=maibloc->get_nb_mg_noeud()-nbnoeudblocavantm0d;
int nbareteentier=geoentier->get_nb_mg_arete();
LISTE_NOEUD_ADD_ARETE *lst_noeuds_entier=new LISTE_NOEUD_ADD_ARETE[nbareteentier];
for (int i=0;i<nbnouveaunoeudbloc;i++)
        {
        MG_NOEUD *noeud=maibloc->get_mg_noeud(i+nbnoeudblocavantm0d);
        double *xyz=noeud->get_coord();
        int num;double t;
        MG_ARETE* are=verif_noeud_sur_arete(xyz, geoentier, &num,&t);
        if (are!=NULL)
                 {
                 MG_NOEUD_ADDITIONNEL_ARETE noeud_add;
                 noeud_add.noeud=noeud;
                 noeud_add.t=t;
                 std::pair<double,MG_NOEUD_ADDITIONNEL_ARETE > tmp(t,noeud_add);
                 lst_noeuds_entier[num].insert(tmp);
                 }
         }
if (etape<5) return OK;
affiche((char*)"   MAILLAGE 1D du modele entier");
for (int i=0;i<nbareteentier;i++)
        {
        MG_ARETE* are=geoentier->get_mg_arete(i);
        int nbnoeudcontraint=lst_noeuds_entier[i].size();
        MG_NOEUD* noeuddepart;
        int numsom=are->get_cosommet1()->get_sommet()->get_lien_maillage()->get_nb();
        for (int j=0;j<numsom;j++)
                if (maientier->get_mg_noeudid(are->get_cosommet1()->get_sommet()->get_lien_maillage()->get(j)->get_id())!=NULL) noeuddepart=(MG_NOEUD*)are->get_cosommet1()->get_sommet()->get_lien_maillage()->get(j);
        MG_NOEUD* noeudarrivee;
        numsom=are->get_cosommet2()->get_sommet()->get_lien_maillage()->get_nb();
        for (int j=0;j<numsom;j++)
                if (maientier->get_mg_noeudid(are->get_cosommet2()->get_sommet()->get_lien_maillage()->get(j)->get_id())!=NULL) noeudarrivee=(MG_NOEUD*)are->get_cosommet2()->get_sommet()->get_lien_maillage()->get(j);
        MG_NOEUD* navant;
        double tavant;
        IT_LISTE_NOEUD_ADD_ARETE it=lst_noeuds_entier[i].begin();
        for (int j=0;j<nbnoeudcontraint+1;j++)
                {
                MG_NOEUD* n1,*n2;
                double t1,t2;
                if (j==0) {n1=noeuddepart;t1=are->get_tmin();} else {n1=navant;t1=tavant;}
                if (j==nbnoeudcontraint) {n2=noeudarrivee;t2=are->get_tmax();}
                else
                        {
                        double *xyz=(*it).second.noeud->get_coord();
                        n2=new MG_NOEUD(are, xyz[0],xyz[1],xyz[2], MAGIC::ORIGINE::IMPOSE);
                        maientier->ajouter_mg_noeud(n2);
                        t2=(*it).second.t;
                        it++;
                        }
                MAILLEUR1D m1d(maientier, geoentier, carte,are);
                m1d.change_pas_integration(pas);
                m1d.maille(are,t1,n1,t2,n2);
                tavant=t2;
                navant=n2;
                }
        }
delete [] lst_noeuds_entier;
cree_octree(maientier,&octreeentier);
cree_octree(octreeentier,&octreebloc);
int nbnoeudtmp=maientier->get_nb_mg_noeud();
for (int i=0;i<nbnoeudtmp;i++)
        octreeentier->inserer(maientier->get_mg_noeud(i));
nbnoeudtmp=maibloc->get_nb_mg_noeud();
for (int i=0;i<nbnoeudtmp;i++)
        octreebloc->inserer(maibloc->get_mg_noeud(i));
if (etape<6) return OK;
int nbsegment=maientier->get_nb_mg_segment();
for (int i=0;i<nbsegment;i++)
        {
        MG_SEGMENT* seg=maientier->get_mg_segment(i);
        MG_NOEUD* noeud1=seg->get_noeud1();
        MG_NOEUD* noeud2=seg->get_noeud2();
        int dim1;
        int dim2;
        MG_NOEUD* n1=chercher(noeud1->get_coord(),*octreebloc);
        MG_NOEUD* n2=chercher(noeud2->get_coord(),*octreebloc);
        MG_ARETE* are1ref;
        MG_FACE* face1ref;
        MG_ARETE* are2ref;
        MG_FACE* face2ref;
        int num1,num2;
        double t1,t2;
        if (n1==NULL)
                {
                are1ref=verif_noeud_sur_arete(noeud1->get_coord(),geobloc,&num1,&t1);
                if (are1ref==NULL) dim1=2; else dim1=1;
                }
        else
                {
                dim1=n1->get_lien_topologie()->get_dimension();
                if (dim1==1) are1ref=(MG_ARETE*)n1->get_lien_topologie();
                }
        if (n2==NULL)
                {
                are2ref=verif_noeud_sur_arete(noeud2->get_coord(),geobloc,&num2,&t2);
                if (are2ref==NULL) dim2=2; else dim2=1;
                }
        else
                {
                dim2=n2->get_lien_topologie()->get_dimension();
                if (dim2==1) are2ref=(MG_ARETE*)n2->get_lien_topologie();
                }
        if ((dim1==1) || (dim2==1)) 
                {
                if (dim1>1) continue;
                if (dim2>1) continue;
                MG_ARETE* ref;
                if (dim1==1) ref=are1ref; else ref=are2ref;
                if (n1==NULL)
                        {
                        n1=new MG_NOEUD(ref,noeud1->get_coord()[0],noeud1->get_coord()[1],noeud1->get_coord()[2], MAGIC::ORIGINE::IMPOSE);
                        maibloc->ajouter_mg_noeud(n1);
                        octreebloc->inserer(n1);
                        }
                if (n2==NULL)
                        {
                        n2=new MG_NOEUD(ref,noeud2->get_coord()[0],noeud2->get_coord()[1],noeud2->get_coord()[2], MAGIC::ORIGINE::IMPOSE);
                        maibloc->ajouter_mg_noeud(n2);
                        octreebloc->inserer(n2);
                        }
                double *xyz1=n1->get_coord();
                double *xyz2=n2->get_coord();
                OT_VECTEUR_3D vec1(xyz1,xyz2);
                double t;
                ref->inverser(t,xyz1);
                double dxyz[3];
                ref->deriver(t,dxyz);
                OT_VECTEUR_3D vec2(dxyz[0],dxyz[1],dxyz[2]);
                vec1.norme();
                vec2.norme();
                double ps=vec1*vec2;
                MG_SEGMENT *nvsegment;
                if (ps>0) nvsegment=new MG_SEGMENT(ref,n1,n2,MAGIC::ORIGINE::IMPOSE);
                else nvsegment=new MG_SEGMENT(ref,n2,n1,MAGIC::ORIGINE::IMPOSE);
                maibloc->ajouter_mg_segment(nvsegment);
                }
        else if ((dim1==0) && (dim2==0))
                {
                MG_ARETE* ref=NULL;
                MG_SOMMET* som1=(MG_SOMMET*)n1->get_lien_topologie();
                MG_SOMMET* som2=(MG_SOMMET*)n2->get_lien_topologie();
                int nb_are=geobloc->get_nb_mg_arete();
                for ( int i=0 ; i < nb_are ; i++)
                    {
                    MG_ARETE *arete=geobloc->get_mg_arete(i);
                    if ((arete->get_cosommet1()->get_sommet()==som1) && (arete->get_cosommet2()->get_sommet()==som2)) ref=arete;
                    if ((arete->get_cosommet1()->get_sommet()==som2) && (arete->get_cosommet2()->get_sommet()==som1)) ref=arete;
                    }
                 if (ref!=NULL)
                  {
                   double *xyz1=n1->get_coord();
                double *xyz2=n2->get_coord();
                OT_VECTEUR_3D vec1(xyz1,xyz2);
                double t;
                ref->inverser(t,xyz1);
                double dxyz[3];
                ref->deriver(t,dxyz);
                OT_VECTEUR_3D vec2(dxyz[0],dxyz[1],dxyz[2]);
                vec1.norme();
                vec2.norme();
                double ps=vec1*vec2;
                MG_SEGMENT *nvsegment;
                if (ps>0) nvsegment=new MG_SEGMENT(ref,n1,n2,MAGIC::ORIGINE::IMPOSE);
                else nvsegment=new MG_SEGMENT(ref,n2,n1,MAGIC::ORIGINE::IMPOSE);
                  maibloc->ajouter_mg_segment(nvsegment);  
                  }
                }
        }
if (etape<7) return OK;
affiche((char*)"   MAILLAGE 1D du modele bloc");
int nbaretebloc=geobloc->get_nb_mg_arete();
int nbsegmentblocavant=maibloc->get_nb_mg_segment();
for (int i=0;i<nbaretebloc;i++)
        {
        MAILLEUR1D m1d_bloc(maibloc,geobloc,carte,geobloc->get_mg_arete(i));
        m1d_bloc.change_pas_integration(pas);
        m1d_bloc.adapte();
        }
if (etape<8) return OK;
int nbfaceentier=geoentier->get_nb_mg_face();
TPL_LISTE_ENTITE<MG_SEGMENT*> *lstsegcontraint=new  TPL_LISTE_ENTITE<MG_SEGMENT*>[nbfaceentier];
int nbsegmentbloc=maibloc->get_nb_mg_segment();
for (int i=nbsegmentblocavant;i<nbsegmentbloc;i++)
        {
        MG_SEGMENT* seg=maibloc->get_mg_segment(i);
        int num;
        MG_FACE* face=seg_sur_face(seg,geoentier,&num);
        if (face!=NULL)
                lstsegcontraint[num].ajouter(seg);
        /*MG_NOEUD* noeud1=seg->get_noeud1();
        MG_NOEUD* noeud2=seg->get_noeud2();
        int dim1;
        int dim2;
        MG_NOEUD* n1=chercher(noeud1->get_coord(),*octreeentier);
        MG_NOEUD* n2=chercher(noeud2->get_coord(),*octreeentier);
        MG_FACE* face1ref;
        MG_FACE* face2ref;
        int num1,num2;
        if (n1==NULL)
                {
                face1ref=verif_noeud_sur_face(noeud1->get_coord(),geoentier,&num1,octreeentierseg);
                if (face1ref==NULL) dim1=3; else dim1=2;
                }
        else
                dim1=n1->get_lien_topologie()->get_dimension();
        if (n2==NULL)
                {
                face2ref=verif_noeud_sur_face(noeud2->get_coord(),geoentier,&num2,octreeentierseg);
                if (face2ref==NULL) dim2=3; else dim2=2;
                }
        else
                dim2=n2->get_lien_topologie()->get_dimension();
        if ((dim1==3) || (dim2==3)) continue;
        if ((dim1==2) || (dim2==2))
                {
                int num;
                if (dim1==2) num=num1;
                else if (dim2==2) num=num2;
                lstsegcontraint[num].ajouter(seg);
                }                                   */
        }
if (etape<9) return OK;
affiche((char*)"   MAILLAGE 2D du modele entier");
for (int i=0;i<nbfaceentier;i++)
        {
        MG_FACE* face=geoentier->get_mg_face(i);
        MAILLEUR2D m2d(maientier,geoentier,carte,face);
        char mess[50];
        m2d.change_pas_integration(pas);
        sprintf(mess,"      Face %i identificateur %lu",i,face->get_id());
        affiche(mess);
        m2d.maille(face,&(lstsegcontraint[i]));
        }
delete  [] lstsegcontraint;
if (etape<10) return OK;
int nbfacebloc=geobloc->get_nb_mg_face();
TPL_LISTE_ENTITE<MG_TRIANGLE*> *lsttricontraint=new  TPL_LISTE_ENTITE<MG_TRIANGLE*>[nbfacebloc];
int nbtrientier=maientier->get_nb_mg_triangle();
for (int i=0;i<nbtrientier;i++)
        {
        MG_TRIANGLE* tri=maientier->get_mg_triangle(i);
        int num;
        MG_FACE* face=tri_sur_face(tri,geobloc,&num);
        if (face!=NULL)
                lsttricontraint[num].ajouter(tri);
        }
if (etape<11) return OK;
affiche((char*)"   MAILLAGE 2D du modele bloc");
for (int i=0;i<nbfacebloc;i++)
        {
        MG_FACE* face=geobloc->get_mg_face(i);
        MAILLEUR2D m2d(maibloc,geobloc,carte,face);
        char mess[50];
        m2d.change_pas_integration(pas);
        sprintf(mess,"      Face %i identificateur %lu",i,face->get_id());
        affiche(mess);
        m2d.maille(face,NULL,&(lsttricontraint[i]));
        }
delete  [] lsttricontraint;
if (etape<12) return OK;
affiche((char*)"   MAILLAGE 3D du modele bloc");
int nbvolumebloc=geobloc->get_nb_mg_volume();
for (int i=0;i<nbvolumebloc;i++)
{
  MG_VOLUME *vol=geobloc->get_mg_volume(i);
  MAILLEUR3D m3d(maibloc,geobloc,carte,false,vol);
  if (affichageactif==1)  m3d.active_affichage(affiche2);
  m3d.change_pas_integration(pas);
  m3d.maille(vol);
}
if (etape<13) return OK;
TPL_LISTE_ENTITE<MG_TETRA*> lsttetra;
LISTE_MG_TETRA::iterator  it;
for (MG_TETRA* tet=maibloc->get_premier_tetra(it);tet!=NULL;tet=maibloc->get_suivant_tetra(it))
        lsttetra.ajouter(tet);
if (etape<14) return OK;
affiche((char*)"   MAILLAGE 3D du modele entier");
MG_VOLUME *vol=geoentier->get_mg_volume(0);
MAILLEUR3D m3d(maientier,geoentier,carte,savedbg,vol,MAGIC::MAILLEURFRONTALETAT::LIMITEDETRUIRE);
m3d.change_pas_integration(pas);
if (savedbg) m3d.change_nom_fichierdbg(nomfichierdbg);
if (affichageactif==1)  m3d.active_affichage(affiche2);
  m3d.maille(vol,NULL,&lsttetra);
return OK;
}
 
MG_NOEUD* MAILLEUR_BLOC::chercher(double *xyz,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> &octree)
{
TPL_MAP_ENTITE<MG_NOEUD*> lst;
octree.rechercher(xyz[0],xyz[1],xyz[2],1e-5,lst);
int nb=lst.get_nb();
for (int i=0;i<nb;i++)
        {
        OT_VECTEUR_3D vec(xyz,lst.get(i)->get_coord());
        double metrique[9];
        carte->evaluer(xyz,metrique);
        double eps=(1./sqrt(metrique[0])*1e-10);
        if (vec.get_longueur()<eps) return lst.get(i);
        }
return NULL;
}
 
 
MG_SOMMET* MAILLEUR_BLOC::verif_noeud_sur_sommet(double *xyz, MG_GEOMETRIE *geo)
{
  int nbsom=geo->get_nb_mg_sommet();
  for (int i=0;i<nbsom;i++)
        {
        MG_SOMMET *sommet=geo->get_mg_sommet(i);
        double xyzsom[3];
        sommet->get_point()->evaluer(xyzsom);
        double metrique[9];
        carte->evaluer(xyz,metrique);
        double eps=(1./sqrt(metrique[0])*1e-6);
        OT_VECTEUR_3D vec(xyz,xyzsom);
        if (vec.get_longueur()<eps) return sommet;
        }
return NULL;
}
 
 
MG_ARETE* MAILLEUR_BLOC::verif_noeud_sur_arete(double *xyz, MG_GEOMETRIE *geo,int *num, double *t)
{
  int nb_are=geo->get_nb_mg_arete();
  for ( int i=0 ; i < nb_are ; i++)
        {
        MG_ARETE *arete=geo->get_mg_arete(i);
        arete->inverser((*t),xyz);
        if (arete->get_courbe()->est_periodique())
            if (*t< arete->get_tmin()) *t=*t+arete->get_courbe()->get_periode();
        double xyztmp[3];
        arete->evaluer( *t,xyztmp );
        double metrique[9];
        carte->evaluer(xyz,metrique);
        double eps=(1./sqrt(metrique[0])*1e-6);
        OT_VECTEUR_3D vec(xyz,xyztmp);
        if (vec.get_longueur()<eps)
                if ((*t>arete->get_tmin()) && (*t<arete->get_tmax()))
                        {
                        *num=i;
                        return arete;
                        }
        }
   return NULL;
}
 
MG_FACE* MAILLEUR_BLOC::seg_sur_face(MG_SEGMENT* seg,MG_GEOMETRIE* geo,int *num)
{
double *xyz1=seg->get_noeud1()->get_coord();
double *xyz2=seg->get_noeud2()->get_coord();
int nbface=geo->get_nb_mg_face();
for (int i=0;i<nbface;i++)
        {
        MG_FACE *face=geo->get_mg_face(i);
        double metrique[9];
        carte->evaluer(xyz1,metrique);
        double eps=(1./sqrt(metrique[0])*1e-6);
        double uv1[2],xyz1bis[3];
        face->inverser(uv1,xyz1);
        face->evaluer(uv1,xyz1bis);
        OT_VECTEUR_3D vec1(xyz1,xyz1bis);
        if (vec1.get_longueur()<eps)
                {
                double uv2[2],xyz2bis[3];
                face->inverser(uv2,xyz2);
                face->evaluer(uv2,xyz2bis);
                OT_VECTEUR_3D vec2(xyz2,xyz2bis);
                if (vec2.get_longueur()<eps)
                        {
                        double xyz[3];
                        xyz[0]=0.5*(xyz1[0]+xyz2[0]);
                        xyz[1]=0.5*(xyz1[1]+xyz2[1]);
                        xyz[2]=0.5*(xyz1[2]+xyz2[2]);
                        double uv[2];
                        face->inverser(uv,xyz);
                        double dist=otentier.calcule_distance_contour_face_uv(uv,face);
                        if (dist>0.) {*num=i;return face;}
                        }
                }
        }
return NULL;
}
 
MG_FACE* MAILLEUR_BLOC::tri_sur_face(MG_TRIANGLE* tri,MG_GEOMETRIE* geo,int *num)
{
double *xyz1=tri->get_noeud1()->get_coord();
double *xyz2=tri->get_noeud2()->get_coord();
double *xyz3=tri->get_noeud3()->get_coord();
int nbface=geo->get_nb_mg_face();
for (int i=0;i<nbface;i++)
        {
        MG_FACE *face=geo->get_mg_face(i);
        double metrique[9];
        carte->evaluer(xyz1,metrique);
        double eps=(1./sqrt(metrique[0])*1e-6);
        double uv1[2],xyz1bis[3];
        face->inverser(uv1,xyz1);
        face->evaluer(uv1,xyz1bis);
        OT_VECTEUR_3D vec1(xyz1,xyz1bis);
        if (vec1.get_longueur()<eps)
                {
                double uv2[2],xyz2bis[3];
                face->inverser(uv2,xyz2);
                face->evaluer(uv2,xyz2bis);
                OT_VECTEUR_3D vec2(xyz2,xyz2bis);
                if (vec2.get_longueur()<eps)
                        {
                        double uv3[2],xyz3bis[3];
                        face->inverser(uv3,xyz3);
                        face->evaluer(uv3,xyz3bis);
                        OT_VECTEUR_3D vec3(xyz3,xyz3bis);
                        if (vec3.get_longueur()<eps)
                                {
                                double xyz[3];
                                double uv[2];
                                OT_DECALAGE_PARAMETRE deca(face->get_surface()->get_periode_u(),face->get_surface()->get_periode_v());
                                double du=deca.calcul_decalage_parametre_u(uv1[0]);
                                double dv=deca.calcul_decalage_parametre_v(uv1[1]);
 
                                uv[0]=0.333333333333333333*(deca.decalage_parametre_u(uv1[0],du)+deca.decalage_parametre_u(uv2[0],du)+deca.decalage_parametre_u(uv3[0],du));
                                uv[1]=0.333333333333333333*(deca.decalage_parametre_v(uv1[1],dv)+deca.decalage_parametre_v(uv2[1],dv)+deca.decalage_parametre_v(uv3[1],dv));
                                uv[0]=deca.decalage_parametre_u(uv[0],-du);
                                uv[1]=deca.decalage_parametre_v(uv[1],-dv);
                                double dist=otbloc.calcule_distance_contour_face_uv(uv,face);
                                if (dist>0.) {*num=i;return face;}
                                }
                        }
                }
        }
return NULL;
}
 
 
void MAILLEUR_BLOC::cree_octree(MG_MAILLAGE* mai,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> **octree)
{
double xmin=1e300,ymin=1e300,zmin=1e300;
double xmax=-1e300,ymax=-1e300,zmax=-1e300;
TPL_MAP_ENTITE<MG_NOEUD*> lstnoeud;
int nb_noeud=mai->get_nb_mg_noeud();
for (int i=0;i<nb_noeud;i++)
        {
        MG_NOEUD* mgnoeud=mai->get_mg_noeud(i);
        lstnoeud.ajouter(mgnoeud);
        xmin=std::min(xmin,mgnoeud->get_x());
        ymin=std::min(ymin,mgnoeud->get_y());
        zmin=std::min(zmin,mgnoeud->get_z());
        xmax=std::max(xmax,mgnoeud->get_x());
        ymax=std::max(ymax,mgnoeud->get_y());
        zmax=std::max(zmax,mgnoeud->get_z());
        }
double xdiff=xmax-xmin;
double ydiff=ymax-ymin;
double zdiff=zmax-zmin;
xmin=xmin-0.125*xdiff;
xmax=xmax+0.125*xdiff;
ymin=ymin-0.125*ydiff;
ymax=ymax+0.125*ydiff;
zmin=zmin-0.125*zdiff;
zmax=zmax+0.125*zdiff;
(*octree)=new TPL_OCTREE<MG_NOEUD*,MG_NOEUD*>;
(*octree)->initialiser(&lstnoeud,1,xmin,ymin,zmin,xmax,ymax,zmax);
}
 
void MAILLEUR_BLOC::cree_octree(TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> *octree1,TPL_OCTREE<MG_NOEUD*,MG_NOEUD*> **octree2)
{
(*octree2)=new TPL_OCTREE<MG_NOEUD*,MG_NOEUD*>;
(*octree2)->initialiser(octree1);
}