mailleur/src/mailleur3d.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.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------


#include "gestionversion.h"


#include "tpl_set.h"
#include "mailleur3d.h"
#include "m3d_triangle.h"
#include "mg_gestionnaire.h"
#include "mailleur3d_optimisation.h"


MAILLEUR3D::MAILLEUR3D(MG_MAILLAGE* mgmai,MG_GEOMETRIE *mggeo,FCT_TAILLE* fct_taille,bool save,MG_VOLUME* mgvol,int destruction):MAILLEUR(save),mg_maillage(mgmai),mg_geometrie(mggeo),mg_volume(mgvol),metrique(fct_taille),activelog(0),niveau_optimisation(2),type_mailleur(MAGIC::MAILLEURFRONTALETAT::FRONTAL),typedestruction(destruction)
{
strcpy(nomfichierdbg,"mailleurautomatique.magicdbg");
}


MAILLEUR3D::MAILLEUR3D(FCT_TAILLE *metri,MG_MAILLAGE* mgmai,OT_CPU* comp,int destruction):MAILLEUR(false,comp),metrique(metri),type_mailleur(MAGIC::MAILLEURFRONTALETAT::OCTAL),mg_maillage(mgmai),coef(2.),typedestruction(destruction)
{
strcpy(nomfichierdbg,"mailleurautomatique.magicdbg");
}


MAILLEUR3D::~MAILLEUR3D()
{
}


int MAILLEUR3D::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
{
    if (type_mailleur==MAGIC::MAILLEURFRONTALETAT::FRONTAL)
    {
        if (mg_volume!=NULL)
        {
          if(maille(mg_volume)==FAIL) return FAIL;            
        }
        else
        {
            TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
            if (mggt!=NULL)
            {
              std::map<MG_ELEMENT_TOPOLOGIQUE*,MG_ELEMENT_TOPOLOGIQUE*>::iterator it;
              for(MG_ELEMENT_TOPOLOGIQUE* ele=mggt->get_premier(it);ele!=NULL;ele=mggt->get_suivant(it))
              {
                lst.ajouter(ele);
                ele->get_topologie_sousjacente(&lst);
              }
            }
            int nb_vol=mg_geometrie->get_nb_mg_volume();
            for (int i=0;i<nb_vol;i++)
            {
                MG_VOLUME* mgvol=mg_geometrie->get_mg_volume(i);
                if (mggt!=NULL)
                    if (lst.existe(mgvol)==0) continue;
                if(maille(mgvol)==FAIL) return FAIL;
            }
        }
    } 
    if (type_mailleur==MAGIC::MAILLEURFRONTALETAT::OCTAL)
    {
        if(maille(metrique)==FAIL) return FAIL;
    }
return OK;
}


int MAILLEUR3D::maille(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TRIANGLE*>  *lsttri,TPL_LISTE_ENTITE<MG_TETRA*>  *lsttet)
{
    cree_ntree();
    distance_maximale=metrique->get_valeur_maximale(0);
    affiche((char*)"  Construction du front");
    initialise_front(mgvol);
    if (lsttri!=NULL) insere_contrainte_triangle(mgvol,lsttri);
    if (lsttet!=NULL) insere_contrainte_tetra(mgvol,lsttet);
    affiche((char*)"  Progression du front");
    if(progresse_front(mgvol)==FAIL)
    {
      delete ntree_de_front;
      return FAIL;
    }
    affiche((char*)"  Construction du maillage final");
    detruit_element_inactif();
    affiche((char*)"  Optimisation du maillage final");
    MAILLEUR3D_OPTIMISATION opt(mg_maillage,niveau_optimisation);
    if (affichageactif==1)   opt.active_affichage(affiche2);
    opt.optimise(mgvol);
    delete ntree_de_front;
    return OK;
}


void MAILLEUR3D::cree_ntree(void)
{
    BOITE_3D boite=metrique->get_boite_3D();
    double xmin=boite.get_xmin();
    double ymin=boite.get_ymin();
    double zmin=boite.get_zmin();
    double xmax=boite.get_xmax();
    double ymax=boite.get_ymax();
    double zmax=boite.get_zmax();
    ntree_de_front=new TPL_NTREE_FCT<MG_FRONT_3D*,FCT_TAILLE >;
    ntree_de_front->initialiser(*metrique,xmin,ymin,zmin,xmax,ymax,zmax);
}

void MAILLEUR3D::initialise_front(MG_VOLUME* mgvol)
{
cree_front(mgvol);
recherche_voisin_front();
}

void MAILLEUR3D::cree_front(MG_VOLUME* mgvol)
{
    int nbcoq=mgvol->get_nb_mg_coquille();
    for (int i=0;i<nbcoq;i++)
    {
        MG_COQUILLE* mgcoq=mgvol->get_mg_coquille(i);
        int nbcoface=mgcoq->get_nb_mg_coface();
        for (int j=0;j<nbcoface;j++)
        {
            MG_COFACE* coface=mgcoq->get_mg_coface(j);
            MG_FACE* mgface=coface->get_face();

            TPL_SET<MG_ELEMENT_MAILLAGE*> * lien_maillage = mgface->get_lien_maillage();
            TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
            MG_ELEMENT_MAILLAGE* element;
            for (element = lien_maillage->get_premier(it); element; element = lien_maillage->get_suivant(it) )
            {
                MG_TRIANGLE* mgtri=(MG_TRIANGLE*)element;
                MG_TRIANGLE* tritemp=mg_maillage->get_mg_triangleid(mgtri->get_id());
                if (tritemp==NULL) continue;
                if (coface->get_orientation()==1) ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,mgtri->get_noeud1(),mgtri->get_noeud2(),mgtri->get_noeud3(),mgtri);
                else ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,mgtri->get_noeud1(),mgtri->get_noeud3(),mgtri->get_noeud2(),mgtri);
            }
        }
    }
}
void MAILLEUR3D::recherche_voisin_front(void)
{
    for (int l=0;l<11;l++)
    {
        int nb_front=get_nb_front(front_courant[l]);
        FRONT::iterator it;
        for (MG_FRONT_3D *ft=get_premier_front(front_courant[l],it);ft!=NULL;ft=get_suivant_front(front_courant[l],it))
        {
            //MG_FRONT_3D* ft=get_front(front_courant[l],i);
            MG_NOEUD* mgnoeud1=ft->get_noeud1();
            MG_NOEUD* mgnoeud2=ft->get_noeud2();
            MG_NOEUD* mgnoeud3=ft->get_noeud3();
            ft->changer_front_voisin(NULL,0);
            ft->changer_front_voisin(NULL,1);
            ft->changer_front_voisin(NULL,2);
            for (int j=0;j<mgnoeud1->get_lien_triangle()->get_nb();j++)
                for (int k=0;k<mgnoeud2->get_lien_triangle()->get_nb();k++)
                {
                    M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud1->get_lien_triangle()->get(j);
                    M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud2->get_lien_triangle()->get(k);
                    if (tri1==tri2)
                        if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
                            if (tri1->get_mgfront()!=ft)
                            {
                                MG_FRONT_3D* ft2=tri1->get_mgfront();
                                if (ft->get_front_voisin(0)==NULL)
                                {
                                    ft->changer_front_voisin(ft2,0);
                                    ft->changer_angle_voisin(angle_front(ft,ft2),0);
                                }
                                else
                                {
                                    double angle=angle_front(ft,ft2);
                                    if (angle<ft->get_angle_voisin(0))
                                    {
                                        ft->changer_front_voisin(ft2,0);
                                        ft->changer_angle_voisin(angle,0);
                                    }
                                }
                            }
                }
            for (int j=0;j<mgnoeud1->get_lien_triangle()->get_nb();j++)
                for (int k=0;k<mgnoeud3->get_lien_triangle()->get_nb();k++)
                {
                    M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud1->get_lien_triangle()->get(j);
                    M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud3->get_lien_triangle()->get(k);
                    if (tri1==tri2)
                        if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
                            if (tri1->get_mgfront()!=ft)
                            {
                                MG_FRONT_3D* ft2=tri1->get_mgfront();
                                if (ft->get_front_voisin(1)==NULL)
                                {
                                    ft->changer_front_voisin(ft2,1);
                                    ft->changer_angle_voisin(angle_front(ft,ft2),1);
                                }
                                else
                                {
                                    double angle=angle_front(ft,ft2);
                                    if (angle<ft->get_angle_voisin(1))
                                    {
                                        ft->changer_front_voisin(ft2,1);
                                        ft->changer_angle_voisin(angle,1);
                                    }
                                }
                            }
                }
            for (int j=0;j<mgnoeud2->get_lien_triangle()->get_nb();j++)
                for (int k=0;k<mgnoeud3->get_lien_triangle()->get_nb();k++)
                {
                    M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud2->get_lien_triangle()->get(j);
                    M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud3->get_lien_triangle()->get(k);
                    if (tri1==tri2)
                        if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
                            if (tri1->get_mgfront()!=ft)
                            {
                                MG_FRONT_3D* ft2=tri1->get_mgfront();
                                if (ft->get_front_voisin(2)==NULL)
                                {
                                    ft->changer_front_voisin(ft2,2);
                                    ft->changer_angle_voisin(angle_front(ft,ft2),2);
                                }
                                else
                                {
                                    double angle=angle_front(ft,ft2);
                                    if (angle<ft->get_angle_voisin(2))
                                    {
                                        ft->changer_front_voisin(ft2,2);
                                        ft->changer_angle_voisin(angle,2);
                                    }
                                }
                            }
                }
            if  ( (ft->get_front_voisin(0)==NULL) || (ft->get_front_voisin(1)==NULL)|| (ft->get_front_voisin(2)==NULL))
                refresh();
        }

    }
   
}


MG_FRONT_3D* MAILLEUR3D::ajouter_front_courant(int numero_front,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_TRIANGLE* triangle)
{
    int numfront;
    if (numero_front==MAGIC::MAILLEURFRONTALETAT::NONFORCE)
    {
        numfront=(int)(triangle->get_longueur()/distance_maximale*10.);
        if (numfront>10) numfront=10;
    }
    else numfront=numero_front;
    MG_FRONT_3D* mgfront;
    if (numfront>11) mgfront=ajouter_front(front_attente,noeud1,noeud2,noeud3,triangle);
    else mgfront=ajouter_front(front_courant[numfront],noeud1,noeud2,noeud3,triangle);
    mgfront->changer_numero_front(numfront);
    if (triangle->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)triangle;
        mtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF);
        mtri->change_mgfront(mgfront);
    }
    return mgfront;
}

MG_FRONT_3D* MAILLEUR3D::ajouter_front(FRONT& front,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_TRIANGLE* triangle)
{
    MG_FRONT_3D* ft=new MG_FRONT_3D(noeud1,noeud2,noeud3,triangle);
    ajouter_front(front,ft);
    ntree_de_front->inserer(ft);
    return ft;
}

void MAILLEUR3D::ajouter_front(FRONT& front,MG_FRONT_3D *ft)
{
    std::pair<const double,MG_FRONT_3D*> tmp(ft->get_triangle()->get_longueur(),ft);
    front.insert(tmp);
}

MG_FRONT_3D* MAILLEUR3D::get_premier_front(FRONT& front)
{
  if (front.size()==0) return NULL;
  FRONT::iterator it=front.begin(); 
  return (*it).second;
}

MG_FRONT_3D* MAILLEUR3D::get_premier_front(FRONT& front,FRONT::iterator &it)
{
  if (front.size()==0) return NULL;
  it=front.begin(); 
  return (*it).second;
}

MG_FRONT_3D* MAILLEUR3D::get_suivant_front(FRONT& front,FRONT::iterator &it)
{
  it++;
  if (it==front.end()) return NULL;
  return (*it).second;
}


unsigned int MAILLEUR3D::get_nb_front(FRONT& front)
{
    return front.size();
}

unsigned int MAILLEUR3D::get_nb_front_courant(void)
{

    return front_courant[0].size()+front_courant[1].size()+front_courant[2].size()+front_courant[3].size()+front_courant[4].size()+front_courant[5].size()+front_courant[6].size()+front_courant[7].size()+front_courant[8].size()+front_courant[9].size()+front_courant[10].size();
}

void MAILLEUR3D::supprimer_front_en_avancant(MG_FRONT_3D* ft)
{
    supprimer_front_en_avancant_sans_delete(ft);
    delete ft;
}

void MAILLEUR3D::supprimer_front_en_avancant_sans_delete(MG_FRONT_3D* ft)
{
    ntree_de_front->supprimer(ft);
    int numfront=ft->get_numero_front();
    FRONT* front_original;
    if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
        front_original=&front_attente;
    else
        front_original=front_courant+numfront;
    FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
    while (ft!=(*j).second) j++;
    front_original->erase(j);
    MG_TRIANGLE* mgtri=ft->get_triangle();
    if (mgtri->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* m3dtri=(M3D_TRIANGLE*)mgtri;
        m3dtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_PASSE);
        m3dtri->change_mgfront(NULL);
    }
}

void MAILLEUR3D::supprimer_front_en_reculant(MG_FRONT_3D* ft)
{
    ntree_de_front->supprimer(ft);
    int numfront=ft->get_numero_front();
    FRONT* front_original;
    if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
        front_original=&front_attente;
    else
        front_original=front_courant+numfront;
    FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
    while (ft!=(*j).second) j++;
    front_original->erase(j);
    MG_TRIANGLE* mgtri=ft->get_triangle();
    if (mgtri->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
    {
        M3D_TRIANGLE* m3dtri=(M3D_TRIANGLE*)mgtri;
        m3dtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_NONACTIF);
        m3dtri->change_mgfront(NULL);
    }
    delete ft;
}

void MAILLEUR3D::echange_de_front(FRONT& front_original,FRONT& front_destination,MG_FRONT_3D* ft)
{
    FRONT::iterator j=front_original.lower_bound(ft->get_triangle()->get_longueur());
    while (ft!=(*j).second) j++;
    front_original.erase(j);
    ajouter_front(front_destination,ft);
}

void MAILLEUR3D::echange_de_front(MG_FRONT_3D* ft,int num)
{
    int numfront;
    if (num==MAGIC::MAILLEURFRONTALETAT::NONFORCE)
    {
        numfront=(int)(ft->get_triangle()->get_longueur()/distance_maximale*10.);
        if (numfront>10) numfront=10;
    }
    else if (num==MAGIC::MAILLEURFRONTALETAT::ATTENTE) numfront=MAGIC::MAILLEURFRONTALETAT::ATTENTE;
    else numfront=num;
    if (numfront>10) numfront=MAGIC::MAILLEURFRONTALETAT::ATTENTE;
    FRONT* front_original;
    int num_front_original=ft->get_numero_front();
    if (num_front_original==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
        front_original=&front_attente;
    else
        front_original=front_courant+num_front_original;
    FRONT* front_destination;
    if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
        front_destination=&front_attente;
    else
        front_destination=front_courant+numfront;


    FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
    while (ft!=(*j).second) j++;
    front_original->erase(j);
    ft->changer_numero_front(numfront);
    ajouter_front(*front_destination,ft);

}


void MAILLEUR3D::swap_front(FRONT& front_original,FRONT& front_destination)
{
    front_original.swap(front_destination);
}


int MAILLEUR3D::premier_front_courant(void)
{
    int num=-1;
    if (front_courant[0].size()>0) num=0;
    else if (front_courant[1].size()>0) num=1;
    else if (front_courant[2].size()>0) num=2;
    else if (front_courant[3].size()>0) num=3;
    else if (front_courant[4].size()>0) num=4;
    else if (front_courant[5].size()>0) num=5;
    else if (front_courant[6].size()>0) num=6;
    else if (front_courant[7].size()>0) num=7;
    else if (front_courant[8].size()>0) num=8;
    else if (front_courant[9].size()>0) num=9;
    else if (front_courant[10].size()>0) num=10;
    return num;
}


void MAILLEUR3D::active_log(char* nomfile)
{
    activelog=1;
    nomlog=nomfile;
}

void MAILLEUR3D::desactive_log(void)
{
    activelog=0;
}

void MAILLEUR3D::change_niveau_optimisation(int num)
{
    niveau_optimisation=num;
}

int MAILLEUR3D::get_niveau_optimisation(void)
{
    return niveau_optimisation;
}


Revision:	1189
Committed:	Tue Feb 4 17:26:49 2025 UTC (3 months ago) by francois
File size:	17222 byte(s)
Log Message:	Version 5.0 de MAGIC. Integration de ALGLIB pour faire de l'optimisation. ALGLIB se download automatiquement en executant un script dans le repertoire config update_magic.bash
#	User	Rev	Content
1	francois	1158	//####//------------------------------------------------------------
2			//####//------------------------------------------------------------
3			//####// MAGiC
4			//####// Jean Christophe Cuilliere et Vincent FRANCOIS
5			//####// Departement de Genie Mecanique - UQTR
6			//####//------------------------------------------------------------
7			//####// MAGIC est un projet de recherche de l equipe ERICCA
8			//####// du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
9			//####// http://www.uqtr.ca/ericca
10			//####// http://www.uqtr.ca/
11			//####//------------------------------------------------------------
12			//####//------------------------------------------------------------
13			//####//
14			//####// mailleur3d.cpp
15			//####//
16			//####//------------------------------------------------------------
17			//####//------------------------------------------------------------
18			//####// COPYRIGHT 2000-2024
19			//####// jeu 13 jun 2024 11:58:55 EDT
20			//####//------------------------------------------------------------
21			//####//------------------------------------------------------------
22	francois	283
23
24			#include "gestionversion.h"
25
26
27			#include "tpl_set.h"
28			#include "mailleur3d.h"
29			#include "m3d_triangle.h"
30			#include "mg_gestionnaire.h"
31	francois	287	#include "mailleur3d_optimisation.h"
32	francois	283
33
34
35
36	francois	1150	MAILLEUR3D::MAILLEUR3D(MG_MAILLAGE* mgmai,MG_GEOMETRIE mggeo,FCT_TAILLE fct_taille,bool save,MG_VOLUME* mgvol,int destruction):MAILLEUR(save),mg_maillage(mgmai),mg_geometrie(mggeo),mg_volume(mgvol),metrique(fct_taille),activelog(0),niveau_optimisation(2),type_mailleur(MAGIC::MAILLEURFRONTALETAT::FRONTAL),typedestruction(destruction)
37	francois	283	{
38	francois	494	strcpy(nomfichierdbg,"mailleurautomatique.magicdbg");
39	francois	283	}
40
41
42	francois	1150	MAILLEUR3D::MAILLEUR3D(FCT_TAILLE metri,MG_MAILLAGE mgmai,OT_CPU* comp,int destruction):MAILLEUR(false,comp),metrique(metri),type_mailleur(MAGIC::MAILLEURFRONTALETAT::OCTAL),mg_maillage(mgmai),coef(2.),typedestruction(destruction)
43	francois	283	{
44	francois	494	strcpy(nomfichierdbg,"mailleurautomatique.magicdbg");
45	francois	283	}
46
47
48			MAILLEUR3D::~MAILLEUR3D()
49			{
50			}
51
52
53
54
55	couturad	966	int MAILLEUR3D::maille(MG_GROUPE_TOPOLOGIQUE* mggt)
56	francois	283	{
57	francois	1150	if (type_mailleur==MAGIC::MAILLEURFRONTALETAT::FRONTAL)
58	francois	283	{
59	couturad	966	if (mg_volume!=NULL)
60			{
61			if(maille(mg_volume)==FAIL) return FAIL;
62			}
63	francois	283	else
64			{
65			TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> lst;
66			if (mggt!=NULL)
67			{
68	couturad	906	std::map<MG_ELEMENT_TOPOLOGIQUE,MG_ELEMENT_TOPOLOGIQUE>::iterator it;
69			for(MG_ELEMENT_TOPOLOGIQUE* ele=mggt->get_premier(it);ele!=NULL;ele=mggt->get_suivant(it))
70			{
71			lst.ajouter(ele);
72			ele->get_topologie_sousjacente(&lst);
73			}
74	francois	283	}
75			int nb_vol=mg_geometrie->get_nb_mg_volume();
76			for (int i=0;i<nb_vol;i++)
77			{
78			MG_VOLUME* mgvol=mg_geometrie->get_mg_volume(i);
79			if (mggt!=NULL)
80			if (lst.existe(mgvol)==0) continue;
81	couturad	967	if(maille(mgvol)==FAIL) return FAIL;
82	francois	283	}
83			}
84	francois	287	}
85	francois	1150	if (type_mailleur==MAGIC::MAILLEURFRONTALETAT::OCTAL)
86	francois	283	{
87	couturad	966	if(maille(metrique)==FAIL) return FAIL;
88	francois	283	}
89	couturad	966	return OK;
90	francois	283	}
91
92
93
94	couturad	966	int MAILLEUR3D::maille(MG_VOLUME* mgvol,TPL_LISTE_ENTITE<MG_TRIANGLE> lsttri,TPL_LISTE_ENTITE<MG_TETRA> lsttet)
95	francois	283	{
96	francois	632	cree_ntree();
97	francois	419	distance_maximale=metrique->get_valeur_maximale(0);
98	francois	445	affiche((char*)" Construction du front");
99	francois	283	initialise_front(mgvol);
100			if (lsttri!=NULL) insere_contrainte_triangle(mgvol,lsttri);
101			if (lsttet!=NULL) insere_contrainte_tetra(mgvol,lsttet);
102	francois	445	affiche((char*)" Progression du front");
103	couturad	966	if(progresse_front(mgvol)==FAIL)
104			{
105			delete ntree_de_front;
106			return FAIL;
107			}
108	francois	445	affiche((char*)" Construction du maillage final");
109	francois	283	detruit_element_inactif();
110	francois	445	affiche((char*)" Optimisation du maillage final");
111	francois	287	MAILLEUR3D_OPTIMISATION opt(mg_maillage,niveau_optimisation);
112	francois	445	if (affichageactif==1) opt.active_affichage(affiche2);
113	francois	288	opt.optimise(mgvol);
114	francois	632	delete ntree_de_front;
115	couturad	966	return OK;
116	francois	283	}
117
118
119	francois	632	void MAILLEUR3D::cree_ntree(void)
120	francois	283	{
121	francois	467	BOITE_3D boite=metrique->get_boite_3D();
122			double xmin=boite.get_xmin();
123			double ymin=boite.get_ymin();
124			double zmin=boite.get_zmin();
125			double xmax=boite.get_xmax();
126			double ymax=boite.get_ymax();
127			double zmax=boite.get_zmax();
128	francois	632	ntree_de_front=new TPL_NTREE_FCT<MG_FRONT_3D*,FCT_TAILLE >;
129			ntree_de_front->initialiser(*metrique,xmin,ymin,zmin,xmax,ymax,zmax);
130	francois	283	}
131
132			void MAILLEUR3D::initialise_front(MG_VOLUME* mgvol)
133			{
134	francois	420	cree_front(mgvol);
135			recherche_voisin_front();
136			}
137
138			void MAILLEUR3D::cree_front(MG_VOLUME* mgvol)
139			{
140	francois	283	int nbcoq=mgvol->get_nb_mg_coquille();
141			for (int i=0;i<nbcoq;i++)
142			{
143			MG_COQUILLE* mgcoq=mgvol->get_mg_coquille(i);
144			int nbcoface=mgcoq->get_nb_mg_coface();
145			for (int j=0;j<nbcoface;j++)
146			{
147			MG_COFACE* coface=mgcoq->get_mg_coface(j);
148			MG_FACE* mgface=coface->get_face();
149
150			TPL_SET<MG_ELEMENT_MAILLAGE> lien_maillage = mgface->get_lien_maillage();
151			TPL_SET<MG_ELEMENT_MAILLAGE*>::ITERATEUR it;
152			MG_ELEMENT_MAILLAGE* element;
153			for (element = lien_maillage->get_premier(it); element; element = lien_maillage->get_suivant(it) )
154			{
155			MG_TRIANGLE* mgtri=(MG_TRIANGLE*)element;
156			MG_TRIANGLE* tritemp=mg_maillage->get_mg_triangleid(mgtri->get_id());
157			if (tritemp==NULL) continue;
158	francois	1150	if (coface->get_orientation()==1) ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,mgtri->get_noeud1(),mgtri->get_noeud2(),mgtri->get_noeud3(),mgtri);
159			else ajouter_front_courant(MAGIC::MAILLEURFRONTALETAT::NONFORCE,mgtri->get_noeud1(),mgtri->get_noeud3(),mgtri->get_noeud2(),mgtri);
160	francois	283	}
161			}
162			}
163	francois	420	}
164			void MAILLEUR3D::recherche_voisin_front(void)
165			{
166	francois	283	for (int l=0;l<11;l++)
167			{
168			int nb_front=get_nb_front(front_courant[l]);
169	francois	551	FRONT::iterator it;
170			for (MG_FRONT_3D *ft=get_premier_front(front_courant[l],it);ft!=NULL;ft=get_suivant_front(front_courant[l],it))
171			{
172			//MG_FRONT_3D* ft=get_front(front_courant[l],i);
173	francois	283	MG_NOEUD* mgnoeud1=ft->get_noeud1();
174			MG_NOEUD* mgnoeud2=ft->get_noeud2();
175			MG_NOEUD* mgnoeud3=ft->get_noeud3();
176			ft->changer_front_voisin(NULL,0);
177			ft->changer_front_voisin(NULL,1);
178			ft->changer_front_voisin(NULL,2);
179			for (int j=0;j<mgnoeud1->get_lien_triangle()->get_nb();j++)
180			for (int k=0;k<mgnoeud2->get_lien_triangle()->get_nb();k++)
181			{
182			M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud1->get_lien_triangle()->get(j);
183			M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud2->get_lien_triangle()->get(k);
184			if (tri1==tri2)
185	francois	1150	if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
186	francois	283	if (tri1->get_mgfront()!=ft)
187			{
188			MG_FRONT_3D* ft2=tri1->get_mgfront();
189			if (ft->get_front_voisin(0)==NULL)
190			{
191			ft->changer_front_voisin(ft2,0);
192			ft->changer_angle_voisin(angle_front(ft,ft2),0);
193			}
194			else
195			{
196			double angle=angle_front(ft,ft2);
197			if (angle<ft->get_angle_voisin(0))
198			{
199			ft->changer_front_voisin(ft2,0);
200			ft->changer_angle_voisin(angle,0);
201			}
202			}
203			}
204			}
205			for (int j=0;j<mgnoeud1->get_lien_triangle()->get_nb();j++)
206			for (int k=0;k<mgnoeud3->get_lien_triangle()->get_nb();k++)
207			{
208			M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud1->get_lien_triangle()->get(j);
209			M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud3->get_lien_triangle()->get(k);
210			if (tri1==tri2)
211	francois	1150	if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
212	francois	283	if (tri1->get_mgfront()!=ft)
213			{
214			MG_FRONT_3D* ft2=tri1->get_mgfront();
215			if (ft->get_front_voisin(1)==NULL)
216			{
217			ft->changer_front_voisin(ft2,1);
218			ft->changer_angle_voisin(angle_front(ft,ft2),1);
219			}
220			else
221			{
222			double angle=angle_front(ft,ft2);
223			if (angle<ft->get_angle_voisin(1))
224			{
225			ft->changer_front_voisin(ft2,1);
226			ft->changer_angle_voisin(angle,1);
227			}
228			}
229			}
230			}
231			for (int j=0;j<mgnoeud2->get_lien_triangle()->get_nb();j++)
232			for (int k=0;k<mgnoeud3->get_lien_triangle()->get_nb();k++)
233			{
234			M3D_TRIANGLE* tri1=(M3D_TRIANGLE*)mgnoeud2->get_lien_triangle()->get(j);
235			M3D_TRIANGLE* tri2=(M3D_TRIANGLE*)mgnoeud3->get_lien_triangle()->get(k);
236			if (tri1==tri2)
237	francois	1150	if (tri1->get_etat_front()==MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF)
238	francois	283	if (tri1->get_mgfront()!=ft)
239			{
240			MG_FRONT_3D* ft2=tri1->get_mgfront();
241			if (ft->get_front_voisin(2)==NULL)
242			{
243			ft->changer_front_voisin(ft2,2);
244			ft->changer_angle_voisin(angle_front(ft,ft2),2);
245			}
246			else
247			{
248			double angle=angle_front(ft,ft2);
249			if (angle<ft->get_angle_voisin(2))
250			{
251			ft->changer_front_voisin(ft2,2);
252			ft->changer_angle_voisin(angle,2);
253			}
254			}
255			}
256			}
257			if ( (ft->get_front_voisin(0)==NULL) \|\| (ft->get_front_voisin(1)==NULL)\|\| (ft->get_front_voisin(2)==NULL))
258			refresh();
259			}
260
261			}
262	francois	419
263	francois	283	}
264
265
266
267			MG_FRONT_3D* MAILLEUR3D::ajouter_front_courant(int numero_front,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_TRIANGLE* triangle)
268			{
269			int numfront;
270	francois	1150	if (numero_front==MAGIC::MAILLEURFRONTALETAT::NONFORCE)
271	francois	283	{
272			numfront=(int)(triangle->get_longueur()/distance_maximale*10.);
273			if (numfront>10) numfront=10;
274			}
275			else numfront=numero_front;
276			MG_FRONT_3D* mgfront;
277			if (numfront>11) mgfront=ajouter_front(front_attente,noeud1,noeud2,noeud3,triangle);
278			else mgfront=ajouter_front(front_courant[numfront],noeud1,noeud2,noeud3,triangle);
279			mgfront->changer_numero_front(numfront);
280	francois	1150	if (triangle->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
281	francois	283	{
282			M3D_TRIANGLE* mtri=(M3D_TRIANGLE*)triangle;
283	francois	1150	mtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_ACTIF);
284	francois	283	mtri->change_mgfront(mgfront);
285			}
286			return mgfront;
287			}
288
289			MG_FRONT_3D* MAILLEUR3D::ajouter_front(FRONT& front,MG_NOEUD* noeud1,MG_NOEUD* noeud2,MG_NOEUD* noeud3,MG_TRIANGLE* triangle)
290			{
291			MG_FRONT_3D* ft=new MG_FRONT_3D(noeud1,noeud2,noeud3,triangle);
292			ajouter_front(front,ft);
293	francois	632	ntree_de_front->inserer(ft);
294	francois	283	return ft;
295			}
296
297			void MAILLEUR3D::ajouter_front(FRONT& front,MG_FRONT_3D *ft)
298			{
299			std::pair<const double,MG_FRONT_3D*> tmp(ft->get_triangle()->get_longueur(),ft);
300			front.insert(tmp);
301			}
302
303	francois	551	MG_FRONT_3D* MAILLEUR3D::get_premier_front(FRONT& front)
304	francois	283	{
305	francois	551	if (front.size()==0) return NULL;
306			FRONT::iterator it=front.begin();
307			return (*it).second;
308	francois	283	}
309
310	francois	551	MG_FRONT_3D* MAILLEUR3D::get_premier_front(FRONT& front,FRONT::iterator &it)
311			{
312			if (front.size()==0) return NULL;
313			it=front.begin();
314			return (*it).second;
315			}
316	francois	283
317	francois	551	MG_FRONT_3D* MAILLEUR3D::get_suivant_front(FRONT& front,FRONT::iterator &it)
318			{
319			it++;
320			if (it==front.end()) return NULL;
321			return (*it).second;
322			}
323
324
325	francois	283	unsigned int MAILLEUR3D::get_nb_front(FRONT& front)
326			{
327			return front.size();
328			}
329
330			unsigned int MAILLEUR3D::get_nb_front_courant(void)
331			{
332
333			return front_courant[0].size()+front_courant[1].size()+front_courant[2].size()+front_courant[3].size()+front_courant[4].size()+front_courant[5].size()+front_courant[6].size()+front_courant[7].size()+front_courant[8].size()+front_courant[9].size()+front_courant[10].size();
334			}
335
336			void MAILLEUR3D::supprimer_front_en_avancant(MG_FRONT_3D* ft)
337			{
338			supprimer_front_en_avancant_sans_delete(ft);
339			delete ft;
340			}
341
342			void MAILLEUR3D::supprimer_front_en_avancant_sans_delete(MG_FRONT_3D* ft)
343			{
344	francois	632	ntree_de_front->supprimer(ft);
345	francois	283	int numfront=ft->get_numero_front();
346			FRONT* front_original;
347	francois	1150	if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
348	francois	283	front_original=&front_attente;
349			else
350			front_original=front_courant+numfront;
351			FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
352			while (ft!=(*j).second) j++;
353			front_original->erase(j);
354			MG_TRIANGLE* mgtri=ft->get_triangle();
355	francois	1150	if (mgtri->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
356	francois	283	{
357			M3D_TRIANGLE* m3dtri=(M3D_TRIANGLE*)mgtri;
358	francois	1150	m3dtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_PASSE);
359	francois	283	m3dtri->change_mgfront(NULL);
360			}
361			}
362
363			void MAILLEUR3D::supprimer_front_en_reculant(MG_FRONT_3D* ft)
364			{
365	francois	632	ntree_de_front->supprimer(ft);
366	francois	283	int numfront=ft->get_numero_front();
367			FRONT* front_original;
368	francois	1150	if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
369	francois	283	front_original=&front_attente;
370			else
371			front_original=front_courant+numfront;
372			FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
373			while (ft!=(*j).second) j++;
374			front_original->erase(j);
375			MG_TRIANGLE* mgtri=ft->get_triangle();
376	francois	1150	if (mgtri->get_type_entite()==MAGIC::TYPE_ENTITE::IDM3D_TRIANGLE)
377	francois	283	{
378			M3D_TRIANGLE* m3dtri=(M3D_TRIANGLE*)mgtri;
379	francois	1150	m3dtri->change_etat_front(MAGIC::MAILLEURFRONTALETAT::FRONT_NONACTIF);
380	francois	283	m3dtri->change_mgfront(NULL);
381			}
382			delete ft;
383			}
384
385			void MAILLEUR3D::echange_de_front(FRONT& front_original,FRONT& front_destination,MG_FRONT_3D* ft)
386			{
387			FRONT::iterator j=front_original.lower_bound(ft->get_triangle()->get_longueur());
388			while (ft!=(*j).second) j++;
389			front_original.erase(j);
390			ajouter_front(front_destination,ft);
391			}
392
393			void MAILLEUR3D::echange_de_front(MG_FRONT_3D* ft,int num)
394			{
395			int numfront;
396	francois	1150	if (num==MAGIC::MAILLEURFRONTALETAT::NONFORCE)
397	francois	283	{
398			numfront=(int)(ft->get_triangle()->get_longueur()/distance_maximale*10.);
399			if (numfront>10) numfront=10;
400			}
401	francois	1150	else if (num==MAGIC::MAILLEURFRONTALETAT::ATTENTE) numfront=MAGIC::MAILLEURFRONTALETAT::ATTENTE;
402	francois	283	else numfront=num;
403	francois	1150	if (numfront>10) numfront=MAGIC::MAILLEURFRONTALETAT::ATTENTE;
404	francois	283	FRONT* front_original;
405			int num_front_original=ft->get_numero_front();
406	francois	1150	if (num_front_original==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
407	francois	283	front_original=&front_attente;
408			else
409			front_original=front_courant+num_front_original;
410			FRONT* front_destination;
411	francois	1150	if (numfront==MAGIC::MAILLEURFRONTALETAT::ATTENTE)
412	francois	283	front_destination=&front_attente;
413			else
414			front_destination=front_courant+numfront;
415
416
417
418			FRONT::iterator j=front_original->lower_bound(ft->get_triangle()->get_longueur());
419			while (ft!=(*j).second) j++;
420			front_original->erase(j);
421			ft->changer_numero_front(numfront);
422			ajouter_front(*front_destination,ft);
423
424			}
425
426
427			void MAILLEUR3D::swap_front(FRONT& front_original,FRONT& front_destination)
428			{
429			front_original.swap(front_destination);
430			}
431
432
433
434			int MAILLEUR3D::premier_front_courant(void)
435			{
436			int num=-1;
437			if (front_courant[0].size()>0) num=0;
438			else if (front_courant[1].size()>0) num=1;
439			else if (front_courant[2].size()>0) num=2;
440			else if (front_courant[3].size()>0) num=3;
441			else if (front_courant[4].size()>0) num=4;
442			else if (front_courant[5].size()>0) num=5;
443			else if (front_courant[6].size()>0) num=6;
444			else if (front_courant[7].size()>0) num=7;
445			else if (front_courant[8].size()>0) num=8;
446			else if (front_courant[9].size()>0) num=9;
447			else if (front_courant[10].size()>0) num=10;
448			return num;
449			}
450
451
452
453			void MAILLEUR3D::active_log(char* nomfile)
454			{
455			activelog=1;
456			nomlog=nomfile;
457			}
458
459			void MAILLEUR3D::desactive_log(void)
460			{
461			activelog=0;
462			}
463
464	francois	287	void MAILLEUR3D::change_niveau_optimisation(int num)
465			{
466			niveau_optimisation=num;
467			}
468	francois	283
469	francois	287	int MAILLEUR3D::get_niveau_optimisation(void)
470			{
471			return niveau_optimisation;
472			}
473	francois	283
474	francois	494