mstruct_generateur.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mstruct_generateur.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:57 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mstruct_generateur.h"
#include "mstruct_definition.h"
#include "mg_cg_modele.h"
#include "mg_gestionnaire.h"
#include "mg_cg.h"
#include "ot_geometrie.h"
#include "mg_cg_forme_volume.h"
#include "mg_cg_forme_multi_volume.h"
#include "mg_cg_op_inclusion_matrice.h"
#include "mg_cg_op_bool_difference.h"
#include "mg_cg_op_bool_intersection.h"
#include "mg_cg_op_transf_decallage.h"
#include <stack>
 
 
MSTRUCT_GENERATEUR::MSTRUCT_GENERATEUR(MG_GESTIONNAIRE* mg_gestionnaire,char* nom_mgcg_modele)
{
  m_mg_gestionnaire=mg_gestionnaire;
  m_mgcg_modele=MG_CG::creer_MG_CG_MODELE(m_mg_gestionnaire,nom_mgcg_modele);
  mg_gestionnaire->ajouter_mgcg_modele(m_mgcg_modele);
  m_mgcg_modele->change_importer_triangulation(true);
  m_mgcg_modele->change_fusionner_entite_similaire(false);
  m_mgcg_modele->change_epsilon_triangulation(0.01);
  m_grille_init=false;
}
 
MSTRUCT_GENERATEUR::MSTRUCT_GENERATEUR(MSTRUCT_GENERATEUR& mcpy)
{
  m_mg_gestionnaire=mcpy.m_mg_gestionnaire;
  m_mgcg_modele=mcpy.m_mgcg_modele;
  m_boite3d_ves=mcpy.m_boite3d_ves;
  m_boite3d_distribution=mcpy.m_boite3d_distribution;
  m_intersection_bords_ves=mcpy.m_intersection_bords_ves;
  m_angle_min=mcpy.m_angle_min;
  m_longueur_min=mcpy.m_longueur_min;
  m_aire_min=mcpy.m_aire_min;
  m_volume_min=mcpy.m_volume_min;
  m_distance_min=mcpy.m_distance_min;
  m_nb_pas_grille=mcpy.m_nb_pas_grille;
  m_nb_pas_echantillonnage=mcpy.m_nb_pas_echantillonnage;
  m_precision=mcpy.m_precision;
  m_grille_init=mcpy.m_grille_init;
  if(m_grille_init)
  m_grille_volume_inclusion.initialiser(m_boite3d_distribution.get_xmin(),m_boite3d_distribution.get_ymin(),m_boite3d_distribution.get_zmin(),
                                        m_boite3d_distribution.get_xmax(),m_boite3d_distribution.get_ymax(),m_boite3d_distribution.get_zmax(),
                                        m_nb_pas_echantillonnage,m_nb_pas_echantillonnage,m_nb_pas_echantillonnage);
  m_vector_mgcg_groupe_forme_inclusion=mcpy.m_vector_mgcg_groupe_forme_inclusion;
  std::vector<MG_CG_GROUPE_FORME*>::iterator it_gr_forme;
  for(it_gr_forme=m_vector_mgcg_groupe_forme_inclusion.begin();it_gr_forme!=m_vector_mgcg_groupe_forme_inclusion.end();it_gr_forme++)
  {
    MG_CG_GROUPE_FORME* groupe_forme=*it_gr_forme;
    TPL_MAP_ENTITE<MG_VOLUME*> tpl_map_volume=groupe_forme->get_tpl_map_volume();
    TPL_MAP_ENTITE<MG_VOLUME*>::ITERATEUR it_volume;
    for(MG_VOLUME* vol=tpl_map_volume.get_premier(it_volume);vol!=NULL;vol=tpl_map_volume.get_suivant(it_volume))
    {
      m_grille_volume_inclusion.inserer(vol);
    }
  }
  m_matrice=mcpy.m_matrice;
  m_cube_initial=mcpy.m_cube_initial;
  m_nb_pas_x=mcpy.m_nb_pas_x;
  m_nb_pas_y=mcpy.m_nb_pas_y;
  m_nb_pas_z=mcpy.m_nb_pas_z;
  affichageactif=mcpy.affichageactif;
  fonc_affiche=mcpy.fonc_affiche;
}
 
MSTRUCT_GENERATEUR::~MSTRUCT_GENERATEUR(void)
{
}
 
MG_GESTIONNAIRE* MSTRUCT_GENERATEUR::get_mg_gestionnaire(void)
{
  return m_mg_gestionnaire;
}
 
MG_CG_MODELE* MSTRUCT_GENERATEUR::get_mgcg_modele(void)
{
  return m_mgcg_modele;
}
 
void MSTRUCT_GENERATEUR::change_mgcg_modele(MG_CG_MODELE* mgcg_modele)
{
  m_mgcg_modele=mgcg_modele;
}
 
void MSTRUCT_GENERATEUR::change_boite3d_ves(BOITE_3D boite3d_ves)
{
  m_boite3d_ves=boite3d_ves;
}
 
void MSTRUCT_GENERATEUR::change_boite3d_distribution(BOITE_3D boite3d_distribution)
{
  m_boite3d_distribution=boite3d_distribution;
}
 
void MSTRUCT_GENERATEUR::change_intersection_bords_ves(bool intersection_bords_ves)
{
  m_intersection_bords_ves=intersection_bords_ves;
}
 
void MSTRUCT_GENERATEUR::change_angle_min(double angle_min)
{
  m_angle_min=angle_min;
}
 
void MSTRUCT_GENERATEUR::change_longueur_min(double longueur_min)
{
  m_longueur_min=longueur_min;
}
 
void MSTRUCT_GENERATEUR::change_aire_min(double aire_min)
{
  m_aire_min=aire_min;
}
 
void MSTRUCT_GENERATEUR::change_volume_min(double volume_min)
{
  m_volume_min=volume_min;
}
 
void MSTRUCT_GENERATEUR::change_distance_inter_volume_min(double distance_min)
{
  m_distance_min=distance_min;
}
 
void MSTRUCT_GENERATEUR::change_nb_pas_grille(int nb_pas_grille)
{
  m_nb_pas_grille=nb_pas_grille;
}
 
void MSTRUCT_GENERATEUR::change_nb_pas_echantillonage(int nb_pas_echantillonnage)
{
  m_nb_pas_echantillonnage=nb_pas_echantillonnage;
}
 
void MSTRUCT_GENERATEUR::change_precision(double precision)
{
  m_precision=precision;
}
 
double MSTRUCT_GENERATEUR::get_fraction_volumique_groupe_forme(std::string nom)
{
  std::vector<MG_CG_GROUPE_FORME*>::iterator it_gr_forme=m_vector_mgcg_groupe_forme_inclusion.begin();
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  while(groupe_forme==NULL && it_gr_forme!=m_vector_mgcg_groupe_forme_inclusion.end())
  {
    if((*it_gr_forme)->get_nom()==nom) groupe_forme=*it_gr_forme;
    it_gr_forme++;
  }
  if(groupe_forme==NULL) return 0.0;
  double fraction_volumique=0.0;
  TPL_MAP_ENTITE<MG_VOLUME*> tpl_map_volume=groupe_forme->get_tpl_map_volume();
  TPL_MAP_ENTITE<MG_VOLUME*>::ITERATEUR it_volume;
  for(MG_VOLUME* vol=tpl_map_volume.get_premier(it_volume);vol!=NULL;vol=tpl_map_volume.get_suivant(it_volume))
  {
    fraction_volumique+=OT_GEOMETRIE::get_volume(vol,m_precision);
  }
  fraction_volumique=fraction_volumique/m_boite3d_ves.get_volume();
  return fraction_volumique;
}
 
 
void MSTRUCT_GENERATEUR::initialiser_grille(void)
{
  if(!m_grille_init)
  {
    m_grille_volume_inclusion.initialiser(m_boite3d_distribution.get_xmin(),m_boite3d_distribution.get_ymin(),m_boite3d_distribution.get_zmin(),
                        m_boite3d_distribution.get_xmax(),m_boite3d_distribution.get_ymax(),m_boite3d_distribution.get_zmax(),
                        m_nb_pas_echantillonnage,m_nb_pas_echantillonnage,m_nb_pas_echantillonnage);
    m_grille_init=true;
  }
}
 
int MSTRUCT_GENERATEUR::position_relative_inclusion_ves(MG_VOLUME* inclusion,bool &plan_x0yz,bool &plan_x1yz,bool &plan_xy0z,bool &plan_xy1z,bool &plan_xyz0,bool &plan_xyz1)
{
  plan_x0yz=false;plan_x1yz=false;plan_xy0z=false;plan_xy1z=false;plan_xyz0=false;plan_xyz1=false;
  MG_ELEMENT_TOPOLOGIQUE::change_pas_echantillon(m_nb_pas_echantillonnage);
  BOITE_3D boite_inclusion=inclusion->get_boite_3D();
  MG_ELEMENT_TOPOLOGIQUE::restaure_pas_echantillon();
  if(m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymin(),boite_inclusion.get_zmin()))
    if(m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymin(),boite_inclusion.get_zmax()))
      if(m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymax(),boite_inclusion.get_zmin()))
        if(m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymax(),boite_inclusion.get_zmax()))
          if(m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymin(),boite_inclusion.get_zmin()))
            if(m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymin(),boite_inclusion.get_zmax()))
              if(m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymax(),boite_inclusion.get_zmin()))
                if(m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymax(),boite_inclusion.get_zmax())) return MSTRUCT::POSITION_RELATIVE::INTERIEUR;
                
  if(!m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymin(),boite_inclusion.get_zmin()))
    if(!m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymin(),boite_inclusion.get_zmax()))
      if(!m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymax(),boite_inclusion.get_zmin()))
        if(!m_boite3d_ves.contient(boite_inclusion.get_xmin(),boite_inclusion.get_ymax(),boite_inclusion.get_zmax()))
          if(!m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymin(),boite_inclusion.get_zmin()))
            if(!m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymin(),boite_inclusion.get_zmax()))
              if(!m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymax(),boite_inclusion.get_zmin()))
                if(!m_boite3d_ves.contient(boite_inclusion.get_xmax(),boite_inclusion.get_ymax(),boite_inclusion.get_zmax())) return MSTRUCT::POSITION_RELATIVE::EXTERIEUR;
  
  if(boite_inclusion.get_xmin()<m_boite3d_ves.get_xmin()) plan_x0yz=true;
  if(boite_inclusion.get_xmax()>m_boite3d_ves.get_xmax()) plan_x1yz=true;
  if(boite_inclusion.get_ymin()<m_boite3d_ves.get_ymin()) plan_xy0z=true;
  if(boite_inclusion.get_ymax()>m_boite3d_ves.get_ymax()) plan_xy0z=true;
  if(boite_inclusion.get_zmin()<m_boite3d_ves.get_zmin()) plan_xyz0=true;
  if(boite_inclusion.get_zmax()>m_boite3d_ves.get_zmax()) plan_xyz1=true;
  return MSTRUCT::POSITION_RELATIVE::AU_BORD;
}
 
bool MSTRUCT_GENERATEUR::angle_entre_face_acceptable(MG_ARETE* mgarete)
{
  long nb_mg_coarete = mgarete->get_nb_mg_coarete();
  for(int i=0;i<nb_mg_coarete-1;i++)
  {
    MG_FACE* face1 = mgarete->get_mg_coarete(i)->get_boucle()->get_mg_face();
    for(int j=i+1;j<nb_mg_coarete;j++)
    {
      MG_FACE* face2 = mgarete->get_mg_coarete(j)->get_boucle()->get_mg_face();
      double tmin = mgarete->get_tmin();
      double tmax = mgarete->get_tmax();
      if(mgarete->get_courbe()->est_periodique())
      {
        tmin=0;
        tmax=mgarete->get_courbe()->get_periode();
      }
      double pas_t = (tmin-tmax)/m_nb_pas_echantillonnage;
      bool planaire=true;
      for(int k=0;k<m_nb_pas_echantillonnage;k++)
      {
        double t = tmin+k*pas_t;
        double xyz[3];
        mgarete->evaluer(t,xyz);
        double uv1[2];
        face1->inverser(uv1,xyz);
        double uv2[2];
        face2->inverser(uv2,xyz);
        double normale1[3];
        face1->calcul_normale_unitaire(uv1,normale1);
        double normale2[3];
        face2->calcul_normale_unitaire(uv2,normale2);
        OT_VECTEUR_3D vect_normale1(normale1);
        OT_VECTEUR_3D vect_normale2(normale2);
        double angle = fabs(acos((vect_normale1*vect_normale2)/(vect_normale1.get_longueur()*vect_normale2.get_longueur())));
        if(planaire)
          if(angle<m_angle_min)
            if(!OPERATEUR::egal(angle,0.0,m_precision))planaire=false;
        if(!planaire)
        {
          if(angle<m_angle_min) return false;
        }
      }
    }
  }
  return true;
}
 
bool MSTRUCT_GENERATEUR::longueur_acceptable(MG_ARETE* mgarete)
{
  if(OT_GEOMETRIE::get_longueur(mgarete)<m_longueur_min) return false;
  return true;
}
 
bool MSTRUCT_GENERATEUR::aire_acceptable(MG_FACE* mgface)
{
  if(OT_GEOMETRIE::get_aire(mgface,m_precision)<m_aire_min) return false;
  return true;
}
 
bool MSTRUCT_GENERATEUR::volume_acceptable(MG_VOLUME* mgvolume)
{
  if(OT_GEOMETRIE::get_volume(mgvolume,m_precision)<m_volume_min) return false;
  return true;
}
 
bool MSTRUCT_GENERATEUR::volume_intersection_ves_acceptable(MG_VOLUME* mgvolume)
{
  if(m_matrice->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
  {
    MG_CG_FORME_VOLUME* forme_volume_matrice = (MG_CG_FORME_VOLUME*)m_matrice;
    double volume_inclusion = OT_GEOMETRIE::get_volume_intersection(mgvolume,forme_volume_matrice->get_mg_volume());
    if(volume_inclusion>m_volume_min) return true;
    return false;
  }
  else if(m_matrice->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
  {
    MG_CG_FORME_MULTI_VOLUME* forme_multi_volume_matrice = (MG_CG_FORME_MULTI_VOLUME*)m_matrice;
    double volume_inclusion=0;
    std::map<long,MG_VOLUME*>::iterator it_volume;
    for(MG_VOLUME* volume_matrice=forme_multi_volume_matrice->get_premier_mg_volume(it_volume);volume_matrice!=NULL;volume_matrice=forme_multi_volume_matrice->get_suivant_mg_volume(it_volume))
    {
      volume_inclusion+=OT_GEOMETRIE::get_volume_intersection(mgvolume,volume_matrice);
    }
    if(volume_inclusion>m_volume_min) return true;
    return false;    
  }
return true;
}
 
bool MSTRUCT_GENERATEUR::distance_acceptable_bord_ves(MG_VOLUME* mgvolume)
{
  BOITE_3D boite_volume=OT_GEOMETRIE::get_boite_3D(mgvolume);
  if(boite_volume.get_xmin()<(m_boite3d_ves.get_xmin()+m_distance_min)) return false;
  if(boite_volume.get_ymin()<(m_boite3d_ves.get_ymin()+m_distance_min)) return false;
  if(boite_volume.get_zmin()<(m_boite3d_ves.get_zmin()+m_distance_min)) return false;  
  if(boite_volume.get_xmax()>(m_boite3d_ves.get_xmax()-m_distance_min)) return false; 
  if(boite_volume.get_ymax()>(m_boite3d_ves.get_ymax()-m_distance_min)) return false; 
  if(boite_volume.get_zmax()>(m_boite3d_ves.get_zmax()-m_distance_min)) return false;
  return true;
}
 
 
bool MSTRUCT_GENERATEUR::configuration_acceptable(MG_CG_FORME_VOLUME* forme_volume_inclusion,MG_CG_FORME* forme_matrice)
{
  TPL_MAP_ENTITE<MG_FACE*> tpl_map_face;
  TPL_MAP_ENTITE<MG_ARETE*> tpl_map_arete;
  TPL_MAP_ENTITE<MG_SOMMET*> tpl_map_sommet;
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> tpl_map_ele_topo_matrice;
  TPL_GRILLE<MG_ELEMENT_TOPOLOGIQUE*> tpl_grille_ele_topo;
  tpl_grille_ele_topo.initialiser(m_boite3d_ves.get_xmin()-0.1,m_boite3d_ves.get_ymin()-0.1,m_boite3d_ves.get_zmin()-0.1,
                                  m_boite3d_ves.get_xmax()+0.1,m_boite3d_ves.get_ymax()+0.1,m_boite3d_ves.get_zmax()+0.1,
                                  m_nb_pas_grille,m_nb_pas_grille,m_nb_pas_grille);  
  if(OT_GEOMETRIE::get_volume(forme_volume_inclusion->get_mg_volume())<m_volume_min) return FAIL;
  OT_GEOMETRIE::get_map_mg_ele_topo_sous_jacent(forme_volume_inclusion->get_mg_volume(),tpl_map_sommet,tpl_map_arete,tpl_map_face);
  if(forme_matrice!=NULL)
  {
    if(forme_matrice->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      MG_CG_FORME_VOLUME* forme_volume_matrice=(MG_CG_FORME_VOLUME*)forme_matrice;
      OT_GEOMETRIE::get_map_mg_ele_topo_sous_jacent(forme_volume_matrice->get_mg_volume(),tpl_map_sommet,tpl_map_arete,tpl_map_face);
    }
    else if(forme_matrice->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
    {
      MG_CG_FORME_MULTI_VOLUME* forme_multi_volume_matrice=(MG_CG_FORME_MULTI_VOLUME*)forme_matrice;
      std::map<long,MG_VOLUME*>::iterator it_volume;
      for(MG_VOLUME* volume=forme_multi_volume_matrice->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume_matrice->get_suivant_mg_volume(it_volume))
      {
        OT_GEOMETRIE::get_map_mg_ele_topo_sous_jacent(volume,tpl_map_sommet,tpl_map_arete,tpl_map_face);
      }
    }
  }
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face;
  for(MG_FACE* face=tpl_map_face.get_premier(it_face);face!=NULL;face=tpl_map_face.get_suivant(it_face))
  {
    if(OT_GEOMETRIE::get_aire(face)<m_aire_min) return FAIL;
    tpl_map_ele_topo_matrice.ajouter(face);
    tpl_grille_ele_topo.inserer(face);
  }
  tpl_map_face.vide();
  TPL_MAP_ENTITE<MG_ARETE*>::ITERATEUR it_arete;
  for(MG_ARETE* arete=tpl_map_arete.get_premier(it_arete);arete!=NULL;arete=tpl_map_arete.get_suivant(it_arete))
  {
    if(OT_GEOMETRIE::get_longueur(arete)<m_longueur_min) return FAIL;
    if(!angle_entre_face_acceptable(arete)) return FAIL;
    tpl_map_ele_topo_matrice.ajouter(arete);
    tpl_grille_ele_topo.inserer(arete);
  }
  tpl_map_arete.vide();
  TPL_MAP_ENTITE<MG_SOMMET*>::ITERATEUR it_sommet;
  for(MG_SOMMET* sommet=tpl_map_sommet.get_premier(it_sommet);sommet!=NULL;sommet=tpl_map_sommet.get_suivant(it_sommet))
  {
    tpl_map_ele_topo_matrice.ajouter(sommet);
    tpl_grille_ele_topo.inserer(sommet);
  }
  tpl_map_sommet.vide(); 
  
  OT_GEOMETRIE::get_map_mg_ele_topo_sous_jacent(forme_volume_inclusion->get_mg_volume(),tpl_map_sommet,tpl_map_arete,tpl_map_face);
  std::stack<MG_ELEMENT_TOPOLOGIQUE*> stack_ele_topo;
  for(MG_FACE* face=tpl_map_face.get_premier(it_face);face!=NULL;face=tpl_map_face.get_suivant(it_face))
  {
    if(OT_GEOMETRIE::get_aire(face)<m_aire_min) return FAIL;
    tpl_grille_ele_topo.inserer(face);
    stack_ele_topo.push(face);    
  }
  for(MG_ARETE* arete=tpl_map_arete.get_premier(it_arete);arete!=NULL;arete=tpl_map_arete.get_suivant(it_arete))
  {
    if(OT_GEOMETRIE::get_longueur(arete)<m_longueur_min) return FAIL;
    if(!angle_entre_face_acceptable(arete)) return FAIL;
 
      tpl_grille_ele_topo.inserer(arete);
      stack_ele_topo.push(arete);
    
  }
  for(MG_SOMMET* sommet=tpl_map_sommet.get_premier(it_sommet);sommet!=NULL;sommet=tpl_map_sommet.get_suivant(it_sommet))
  {
    tpl_grille_ele_topo.inserer(sommet);
    stack_ele_topo.push(sommet);
  } 
  while(!stack_ele_topo.empty())
  {
    MG_ELEMENT_TOPOLOGIQUE* ele_topo=stack_ele_topo.top(); stack_ele_topo.pop();
    TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> tpl_map_topo_trouve;
    BOITE_3D boite_recherche(ele_topo->get_boite_3D().get_xmin()-m_distance_min,
                             ele_topo->get_boite_3D().get_ymin()-m_distance_min,
                             ele_topo->get_boite_3D().get_zmin()-m_distance_min,
                             ele_topo->get_boite_3D().get_xmax()+m_distance_min,
                             ele_topo->get_boite_3D().get_ymax()+m_distance_min,
                             ele_topo->get_boite_3D().get_zmax()+m_distance_min);
    tpl_grille_ele_topo.rechercher(boite_recherche,tpl_map_topo_trouve);
    TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_trouve;
    for(MG_ELEMENT_TOPOLOGIQUE* ele_top_trouve=tpl_map_topo_trouve.get_premier(it_trouve);ele_top_trouve!=NULL;ele_top_trouve=tpl_map_topo_trouve.get_suivant(it_trouve))
    {
      if(ele_topo==ele_top_trouve) continue;
      if(OT_GEOMETRIE::get_lien_topologique(ele_topo,ele_top_trouve)==OT_GEOMETRIE::TYPE_LIEN_TOPOLOGIQUE::AUCUN)
      {
        double distance;
        if(OT_GEOMETRIE::get_distance_min_mg_eletopo_mg_eletopo(ele_topo,ele_top_trouve,distance)==FAIL) return FAIL;
        if(distance<m_distance_min) return FAIL;
      }
    }
    tpl_grille_ele_topo.supprimer(ele_topo);
  }
  return OK;
}
 
 
 
void MSTRUCT_GENERATEUR::echec_insertion_inclusion(std::vector< MG_CG_FORME* >& vector_forme, std::vector< MG_CG_OPERATEUR* >& vector_operateur)
{
  std::vector<MG_CG_FORME*>::iterator it_forme;
  for(it_forme=vector_forme.begin();it_forme!=vector_forme.end();it_forme++) m_mgcg_modele->supprimer_mgcg_formeid((*it_forme)->get_id());
  std::vector<MG_CG_OPERATEUR*>::iterator it_operateur;
  for(it_operateur=vector_operateur.begin();it_operateur!=vector_operateur.end();it_operateur++) m_mgcg_modele->supprimer_mgcg_operateurid((*it_operateur)->get_id());
}
 
int MSTRUCT_GENERATEUR::faces_correspondantes(MG_VOLUME* volume1, MG_VOLUME* volume2,double decallage,int nb_pas,double precision)
{
  TPL_MAP_ENTITE<MG_FACE*> tpl_map_face_volume1;
  TPL_MAP_ENTITE<MG_FACE*> tpl_map_face_volume2;
  OT_GEOMETRIE::get_map_mg_face_sous_jacent(volume1,tpl_map_face_volume1);
  OT_GEOMETRIE::get_map_mg_face_sous_jacent(volume2,tpl_map_face_volume2);
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face1;
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face2;
  while(tpl_map_face_volume1.get_nb()>0 && tpl_map_face_volume2.get_nb()>0)
  {
    bool trouve=false;
    MG_FACE* face1=tpl_map_face_volume1.get_premier(it_face1);
    MG_FACE* face2=tpl_map_face_volume2.get_premier(it_face2);
    while(trouve==false && face2!=NULL)
    {
      double distance_moyenne;
      double ecart_type_distance;
      if(OT_GEOMETRIE::declage_mg_face_mg_face(face1,face2,distance_moyenne,ecart_type_distance,nb_pas,precision)!=FAIL)
      {
        if(OPERATEUR::egal(distance_moyenne,decallage,precision) && ecart_type_distance<precision)
        {
          trouve=true;
          tpl_map_face_volume1.supprimer(face1);
          tpl_map_face_volume2.supprimer(face2);
        }
        else if(OPERATEUR::egal(distance_moyenne,0.0,precision) && ecart_type_distance<precision)
        {
          trouve=true;
          tpl_map_face_volume1.supprimer(face1);
          tpl_map_face_volume2.supprimer(face2);
        }
      }
      face2=tpl_map_face_volume2.get_suivant(it_face2);
    }
    if(trouve==false) return FAIL;
  }
  return OK;  
}
 
 
bool MSTRUCT_GENERATEUR::insertion_inclusion(MG_CG_FORME* forme_inclusion,
                                         double fraction_volumique_cible,
                                         double eps_fra_vol,
                                         double &fraction_volumique_actuelle, 
                                         std::vector<MG_CG_FORME*> &vector_inclusion_genere,
                                         int &position_relative,
                                         std::vector< double > *vector_epaisseur_couche,
                                         bool porosite)
{
  
  MG_CG_FORME_VOLUME* boite_frac_vol=MG_CG::creer_MG_CG_FORME_VOLUME_BOITE(m_mgcg_modele,
                                                    m_boite3d_ves.get_xmin(),m_boite3d_ves.get_ymin(),m_boite3d_ves.get_zmin(),
                                                    m_boite3d_ves.get_xmax(),m_boite3d_ves.get_ymax(),m_boite3d_ves.get_zmax());
  boite_frac_vol->construire();  
  double volume_particule;
  MG_CG_FORME* matrice=m_matrice;
  std::vector<MG_CG_FORME*> vector_forme_genere;
  std::vector<MG_CG_OPERATEUR*> vector_operateur_genere;
  vector_forme_genere.push_back(forme_inclusion);
  //vector_forme_genere.push_back(boite_frac_vol);
  if(forme_inclusion->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
  MG_CG_FORME_VOLUME* forme_volume_inclusion = (MG_CG_FORME_VOLUME*)forme_inclusion;
  MG_CG_FORME_VOLUME* forme_volume_verif_grille=NULL;
  bool multicouche=false;
  if(vector_epaisseur_couche!=NULL) multicouche=true;
  if(multicouche)
  {
    // Creation de l'enveloppe externe
    double decallage_max=0;
    std::vector<double>::iterator it_epaisseur;
    for(it_epaisseur=vector_epaisseur_couche->begin();it_epaisseur!=vector_epaisseur_couche->end();it_epaisseur++) decallage_max+=*it_epaisseur;
    MG_CG_OP_TRANSF_DECALLAGE* op_decallage_couche_externe=MG_CG::creer_MG_CG_OP_TRANSF_DECALLAGE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::DECALLAGE,forme_volume_inclusion);
    vector_operateur_genere.push_back(op_decallage_couche_externe);
    op_decallage_couche_externe->change_decallage(decallage_max);
    if(op_decallage_couche_externe->construire()==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    vector_forme_genere.push_back(op_decallage_couche_externe->get_mgcg_forme_sortie());
    if(op_decallage_couche_externe->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    MG_CG_FORME_VOLUME* forme_volume_couche_externe=(MG_CG_FORME_VOLUME*)op_decallage_couche_externe->get_mgcg_forme_sortie();
    forme_volume_verif_grille=forme_volume_couche_externe;
    MG_VOLUME* volume_inclusion=forme_volume_inclusion->get_mg_volume();
    MG_VOLUME* volume_inclusion_couche_externe=forme_volume_couche_externe->get_mg_volume();
    // Verification du positionnement 
    if(positionnement_acceptable(forme_volume_couche_externe->get_mg_volume())==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }  
    // Verification de la fraction volumique
    volume_particule=OT_GEOMETRIE::get_volume_intersection(volume_inclusion_couche_externe,boite_frac_vol->get_mg_volume(),m_precision);
    m_mgcg_modele->supprimer_mgcg_formeid(boite_frac_vol->get_id());
    if((volume_particule+fraction_volumique_actuelle)>fraction_volumique_cible+eps_fra_vol)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }     
    // Verification des plans de coupe (coeur VS enveloppe)
    bool plan_x0yz_inc;bool plan_x1yz_inc;bool plan_xy0z_inc;bool plan_xy1z_inc;bool plan_xyz0_inc;bool plan_xyz1_inc;
    bool plan_x0yz_ext;bool plan_x1yz_ext;bool plan_xy0z_ext;bool plan_xy1z_ext;bool plan_xyz0_ext;bool plan_xyz1_ext;
    int position_relative_inc=position_relative_inclusion_ves(volume_inclusion,plan_x0yz_inc,plan_x1yz_inc,plan_xy0z_inc,plan_xy1z_inc,plan_xyz0_inc,plan_xyz1_inc);
    int position_relative_ext=position_relative_inclusion_ves(volume_inclusion_couche_externe,plan_x0yz_ext,plan_x1yz_ext,plan_xy0z_ext,plan_xy1z_ext,plan_xyz0_ext,plan_xyz1_ext);
    if(position_relative_inc!=position_relative_ext || position_relative_ext==MSTRUCT::POSITION_RELATIVE::EXTERIEUR)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    if(!m_intersection_bords_ves && position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD)
    {
      bool ok_plan=false;
      if(plan_x0yz_inc==plan_x0yz_ext)
        if(plan_x1yz_inc==plan_x1yz_ext)
          if(plan_xy0z_inc==plan_xy0z_ext)
            if(plan_xy1z_inc==plan_xy1z_ext)
              if(plan_xyz0_inc==plan_xyz0_ext)
                if(plan_xyz1_inc==plan_xyz1_ext) ok_plan=true;
      if(!ok_plan)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
    }    
    // Creation de l'intersection couche externe / matrice
    MG_CG_OP_BOOL_INTERSECTION* op_inter_ext=MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(m_mgcg_modele,MAGIC::SEMANTIQUECSG::INTERSECTION,forme_volume_couche_externe,matrice);
    vector_operateur_genere.push_back(op_inter_ext);
    if(op_inter_ext->construire()==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    vector_forme_genere.push_back(op_inter_ext->get_mgcg_forme_sortie());
    if(op_inter_ext->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    MG_CG_FORME_VOLUME* couche_externe_inter = (MG_CG_FORME_VOLUME*)op_inter_ext->get_mgcg_forme_sortie();
    // Fragmentation de l'inclusion / matrice
    MG_CG_OP_INCLUSION_MATRICE* op_inc_matrice_ext=MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::FRAGMENT,couche_externe_inter,matrice);
    vector_operateur_genere.push_back(op_inc_matrice_ext);
    if(op_inc_matrice_ext->construire()==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    vector_forme_genere.push_back(op_inc_matrice_ext->get_mgcg_forme_matrice_sortie());
    vector_forme_genere.push_back(op_inc_matrice_ext->get_mgcg_forme_inclusion_sortie());
    if(op_inc_matrice_ext->get_mgcg_forme_inclusion_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    matrice=op_inc_matrice_ext->get_mgcg_forme_matrice_sortie();
    MG_CG_FORME_VOLUME* couche_externe_matrice=(MG_CG_FORME_VOLUME*)op_inc_matrice_ext->get_mgcg_forme_inclusion_sortie();
    if(configuration_acceptable(couche_externe_matrice,matrice)==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    // OK POUR GENERER     
    MG_CG_FORME_VOLUME* matrice_couche_partielle;
    if(porosite)
    {
      MG_CG_OP_BOOL_DIFFERENCE* op_diff_porosite=MG_CG::creer_MG_CG_OP_BOOL_DIFFERENCE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::SOUSTRACTION,couche_externe_matrice,forme_volume_inclusion);
      vector_operateur_genere.push_back(op_diff_porosite);
      if(op_diff_porosite->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_diff_porosite->get_mgcg_forme_sortie());
      if(op_diff_porosite->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      matrice_couche_partielle=(MG_CG_FORME_VOLUME*)op_diff_porosite->get_mgcg_forme_sortie();
    }
    else
    {
      MG_CG_OP_BOOL_INTERSECTION* op_inter_couche=MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(m_mgcg_modele,MAGIC::SEMANTIQUECSG::INTERSECTION,forme_volume_inclusion,couche_externe_matrice);
      vector_operateur_genere.push_back(op_inter_couche);
      if(op_inter_couche->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_inter_couche->get_mgcg_forme_sortie());
      if(op_inter_couche->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }     
      MG_CG_OP_INCLUSION_MATRICE* op_inc_matrice_coeur=MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::FRAGMENT,op_inter_couche->get_mgcg_forme_sortie(),couche_externe_matrice);
      vector_operateur_genere.push_back(op_inc_matrice_coeur);
      if(op_inc_matrice_coeur->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_inc_matrice_coeur->get_mgcg_forme_inclusion_sortie());
      vector_forme_genere.push_back(op_inc_matrice_coeur->get_mgcg_forme_matrice_sortie());
      if(op_inc_matrice_coeur->get_mgcg_forme_inclusion_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME || 
          op_inc_matrice_coeur->get_mgcg_forme_matrice_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }    
      
      MG_CG_FORME_VOLUME* inclusion_coeur=(MG_CG_FORME_VOLUME*)op_inc_matrice_coeur->get_mgcg_forme_inclusion_sortie();
      matrice_couche_partielle=(MG_CG_FORME_VOLUME*)op_inc_matrice_coeur->get_mgcg_forme_matrice_sortie();
      if(configuration_acceptable(inclusion_coeur,NULL)==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }      
      // Verification des faces correspondantes
      if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD)
        if(faces_correspondantes(inclusion_coeur->get_mg_volume(),couche_externe_matrice->get_mg_volume(),decallage_max,m_nb_pas_echantillonnage,m_precision)==FAIL)
        {
          echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
          return FAIL;
        }      
      if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::INTERIEUR) MG_CG::creer_MG_CG_INFO_STRING(op_inc_matrice_coeur->get_mgcg_forme_inclusion_sortie(),(char*)"POSITION_RELATIVE",(char*)"INTERIEUR");      
      if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD) MG_CG::creer_MG_CG_INFO_STRING(op_inc_matrice_coeur->get_mgcg_forme_inclusion_sortie(),(char*)"POSITION_RELATIVE",(char*)"AU_BORD");
      vector_inclusion_genere.push_back(inclusion_coeur);
    }    
    double decallage=0;
    double epaisseur;
    for(it_epaisseur=vector_epaisseur_couche->begin();it_epaisseur!=vector_epaisseur_couche->end()-1;it_epaisseur++)
    {  
      epaisseur=*it_epaisseur;
      decallage+=*it_epaisseur;
      MG_CG_OP_TRANSF_DECALLAGE* op_decallage_couche=MG_CG::creer_MG_CG_OP_TRANSF_DECALLAGE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::DECALLAGE,forme_volume_inclusion);
      vector_operateur_genere.push_back(op_decallage_couche);
      op_decallage_couche->change_decallage(decallage);
      if(op_decallage_couche->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_decallage_couche->get_mgcg_forme_sortie());
      if(op_decallage_couche->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      MG_CG_OP_BOOL_INTERSECTION* op_inter_couche=MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(m_mgcg_modele,MAGIC::SEMANTIQUECSG::INTERSECTION,op_decallage_couche->get_mgcg_forme_sortie(),matrice_couche_partielle);
      vector_operateur_genere.push_back(op_inter_couche);
      if(op_inter_couche->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_inter_couche->get_mgcg_forme_sortie());
      if(op_inter_couche->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }      
      MG_CG_OP_INCLUSION_MATRICE* op_inc_matrice_couche=MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::FRAGMENT,op_inter_couche->get_mgcg_forme_sortie(),matrice_couche_partielle);
      vector_operateur_genere.push_back(op_inc_matrice_couche);
      if(op_inc_matrice_couche->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_inc_matrice_couche->get_mgcg_forme_inclusion_sortie());
      vector_forme_genere.push_back(op_inc_matrice_couche->get_mgcg_forme_matrice_sortie());
      if(op_inc_matrice_couche->get_mgcg_forme_inclusion_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME ||
         op_inc_matrice_couche->get_mgcg_forme_matrice_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      MG_CG_FORME_VOLUME* inclusion_couche = (MG_CG_FORME_VOLUME*)op_inc_matrice_couche->get_mgcg_forme_inclusion_sortie();
      vector_inclusion_genere.push_back(inclusion_couche);      
      if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::INTERIEUR) MG_CG::creer_MG_CG_INFO_STRING(inclusion_couche,(char*)"POSITION_RELATIVE",(char*)"INTERIEUR");      
      if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD) MG_CG::creer_MG_CG_INFO_STRING(inclusion_couche,(char*)"POSITION_RELATIVE",(char*)"AU_BORD");
      MG_CG::creer_MG_CG_INFO_DOUBLE(inclusion_couche,(char*)"EPAISSEUR",epaisseur);
      matrice_couche_partielle=(MG_CG_FORME_VOLUME*)op_inc_matrice_couche->get_mgcg_forme_matrice_sortie();
      configurer_volume_mince(inclusion_couche->get_mg_volume(),epaisseur);
    }
    epaisseur=*it_epaisseur;
    if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::INTERIEUR) MG_CG::creer_MG_CG_INFO_STRING(matrice_couche_partielle,(char*)"POSITION_RELATIVE",(char*)"INTERIEUR");      
    if(position_relative_ext==MSTRUCT::POSITION_RELATIVE::AU_BORD) MG_CG::creer_MG_CG_INFO_STRING(matrice_couche_partielle,(char*)"POSITION_RELATIVE",(char*)"AU_BORD");
    MG_CG::creer_MG_CG_INFO_DOUBLE(matrice_couche_partielle,(char*)"EPAISSEUR",epaisseur);
    vector_inclusion_genere.push_back(matrice_couche_partielle);
    configurer_volume_mince(matrice_couche_partielle->get_mg_volume(),epaisseur);
    position_relative=position_relative_ext;
  }
  else
  {
    // Verification du positionnement
    if(positionnement_acceptable(forme_volume_inclusion->get_mg_volume())==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      m_mgcg_modele->supprimer_mgcg_formeid(boite_frac_vol->get_id());
      return FAIL;
    }
    // Verification de la fraction volumique
    volume_particule=OT_GEOMETRIE::get_volume_intersection(forme_volume_inclusion->get_mg_volume(),boite_frac_vol->get_mg_volume(),m_precision);
    m_mgcg_modele->supprimer_mgcg_formeid(boite_frac_vol->get_id());
    if(((volume_particule/m_boite3d_ves.get_volume())+fraction_volumique_actuelle)>fraction_volumique_cible+eps_fra_vol)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }    
    // Verification de la position relative
    bool plan_x0yz;bool plan_x1yz;bool plan_xy0z;bool plan_xy1z;bool plan_xyz0;bool plan_xyz1;
    position_relative=position_relative_inclusion_ves(forme_volume_inclusion->get_mg_volume(),plan_x0yz,plan_x1yz,plan_xy0z,plan_xy1z,plan_xyz0,plan_xyz1);
    if(position_relative==MSTRUCT::POSITION_RELATIVE::EXTERIEUR)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    if(!m_intersection_bords_ves && position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    if(position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD)
    {
      MG_CG_OP_BOOL_INTERSECTION* op_inter=MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(m_mgcg_modele,MAGIC::SEMANTIQUECSG::INTERSECTION,forme_volume_inclusion,m_matrice);
      vector_operateur_genere.push_back(op_inter);
      if(op_inter->construire()==FAIL)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      vector_forme_genere.push_back(op_inter->get_mgcg_forme_sortie());
      if(op_inter->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
      {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
        return FAIL;
      }
      forme_volume_inclusion=(MG_CG_FORME_VOLUME*)op_inter->get_mgcg_forme_sortie();
    }
    MG_CG_OP_INCLUSION_MATRICE* op_inc_matrice=MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::FRAGMENT,forme_volume_inclusion,m_matrice);
    vector_operateur_genere.push_back(op_inc_matrice);
    if(op_inc_matrice->construire()==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    matrice=op_inc_matrice->get_mgcg_forme_matrice_sortie();
    vector_forme_genere.push_back(matrice);
    vector_forme_genere.push_back(op_inc_matrice->get_mgcg_forme_inclusion_sortie());
    if(op_inc_matrice->get_mgcg_forme_inclusion_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    forme_volume_inclusion=(MG_CG_FORME_VOLUME*)op_inc_matrice->get_mgcg_forme_inclusion_sortie();
    if(configuration_acceptable(forme_volume_inclusion,matrice)==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    if(position_relative==MSTRUCT::POSITION_RELATIVE::INTERIEUR) MG_CG::creer_MG_CG_INFO_STRING(forme_volume_inclusion,(char*)"POSITION_RELATIVE",(char*)"INTERIEUR");      
    if(position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD) MG_CG::creer_MG_CG_INFO_STRING(forme_volume_inclusion,(char*)"POSITION_RELATIVE",(char*)"AU_BORD");
    vector_inclusion_genere.push_back(forme_volume_inclusion);
    forme_volume_verif_grille=forme_volume_inclusion;
  }
  fraction_volumique_actuelle+=volume_particule/m_boite3d_ves.get_volume();
  m_grille_volume_inclusion.inserer(forme_volume_verif_grille->get_mg_volume());
  m_matrice=matrice;
  return OK;
}
 
bool MSTRUCT_GENERATEUR::insertion_inclusion(MG_CG_FORME* forme_inclusion,
                                             double& fraction_volumique_actuelle,
                                             std::vector< MG_CG_FORME* >& vector_inclusion_genere,
                                             int& position_relative
                                            )
{
 
  double volume_particule;
  MG_CG_FORME* matrice=m_matrice;
  std::vector<MG_CG_FORME*> vector_forme_genere;
  std::vector<MG_CG_OPERATEUR*> vector_operateur_genere;
  vector_forme_genere.push_back(forme_inclusion);
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
  if(forme_inclusion->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
 
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
  MG_CG_FORME_VOLUME* forme_volume_inclusion = (MG_CG_FORME_VOLUME*)forme_inclusion;
  MG_CG_FORME_VOLUME* forme_volume_verif_grille=NULL;
 
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
  // Verification du positionnement
      if(positionnement_acceptable(forme_volume_inclusion->get_mg_volume())==FAIL)
  {
 
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
  // Verification de la position relative
  bool plan_x0yz;bool plan_x1yz;bool plan_xy0z;bool plan_xy1z;bool plan_xyz0;bool plan_xyz1;
  position_relative=position_relative_inclusion_ves(forme_volume_inclusion->get_mg_volume(),plan_x0yz,plan_x1yz,plan_xy0z,plan_xy1z,plan_xyz0,plan_xyz1);
 
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
 
  if(position_relative==MSTRUCT::POSITION_RELATIVE::EXTERIEUR)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
  if(!m_intersection_bords_ves && position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
  //---------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------------------
  if(position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD)
  {
    MG_CG_OP_BOOL_INTERSECTION* op_inter=MG_CG::creer_MG_CG_OP_BOOL_INTERSECTION(m_mgcg_modele,MAGIC::SEMANTIQUECSG::INTERSECTION,forme_volume_inclusion,m_matrice);
    vector_operateur_genere.push_back(op_inter);
    if(op_inter->construire()==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    vector_forme_genere.push_back(op_inter->get_mgcg_forme_sortie());
    if(op_inter->get_mgcg_forme_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
    forme_volume_inclusion=(MG_CG_FORME_VOLUME*)op_inter->get_mgcg_forme_sortie();
  }
  //-----------------------------------------------------------------------------------------------------------------------------
  //-----------------------------------------------------------------------------------------------------------------------------
  MG_CG_OP_INCLUSION_MATRICE* op_inc_matrice=MG_CG::creer_MG_CG_OP_INCLUSION_MATRICE(m_mgcg_modele,MAGIC::SEMANTIQUECSG::FRAGMENT,forme_volume_inclusion,m_matrice);
  vector_operateur_genere.push_back(op_inc_matrice);
 
  if(op_inc_matrice->construire()==FAIL)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
 
  matrice=op_inc_matrice->get_mgcg_forme_matrice_sortie();
  vector_forme_genere.push_back(matrice);
  vector_forme_genere.push_back(op_inc_matrice->get_mgcg_forme_inclusion_sortie());
 
 
  if(op_inc_matrice->get_mgcg_forme_inclusion_sortie()->get_type_forme()!=MG_CG_FORME::TYPE_FORME::VOLUME)
  {
    echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
    return FAIL;
  }
 
 
  forme_volume_inclusion=(MG_CG_FORME_VOLUME*)op_inc_matrice->get_mgcg_forme_inclusion_sortie();
  //-------------------------------------------------------------------------------------------------------------
  //-----------------------------------------------------------------------------------------------------------------------------
 
  if(position_relative==MSTRUCT::POSITION_RELATIVE::INTERIEUR)
  {
 
      if(distance_acceptable_bord_ves(forme_volume_inclusion->get_mg_volume())==FAIL)
    {
        echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
 
    }
  }
  //-----------------------------------------------------------------------------------------------------------------------------
  //---------------------------------------------------------------------------------------------------
  if(m_intersection_bords_ves)
      if(configuration_acceptable(forme_volume_inclusion,matrice)==FAIL)
    {
      echec_insertion_inclusion(vector_forme_genere,vector_operateur_genere);
      return FAIL;
    }
 
    //-------------------------------------------------------------------------------------------------------------
    //----------------------------------------------------------------------------------------------------------------------------
 
  if(position_relative==MSTRUCT::POSITION_RELATIVE::INTERIEUR) MG_CG::creer_MG_CG_INFO_STRING(forme_volume_inclusion,(char*)"POSITION_RELATIVE",(char*)"INTERIEUR");
  if(position_relative==MSTRUCT::POSITION_RELATIVE::AU_BORD) MG_CG::creer_MG_CG_INFO_STRING(forme_volume_inclusion,(char*)"POSITION_RELATIVE",(char*)"AU_BORD");
  vector_inclusion_genere.push_back(forme_volume_inclusion);
  forme_volume_verif_grille=forme_volume_inclusion;
  volume_particule=OT_GEOMETRIE::get_volume(forme_volume_inclusion->get_mg_volume());
  fraction_volumique_actuelle+=volume_particule;
  m_grille_volume_inclusion.inserer(forme_volume_verif_grille->get_mg_volume());
  m_matrice=matrice;
  return OK;
}
 
 
//=========================================================================================
//==========================================================================================
 
bool MSTRUCT_GENERATEUR::positionnement_acceptable(MG_VOLUME* inclusion)
{
  TPL_MAP_ENTITE<MG_VOLUME*> map_volume_recherche;
  BOITE_3D boite_recherche = inclusion->get_boite_3D();
  boite_recherche.change_grosseur(1.1);
  m_grille_volume_inclusion.rechercher(boite_recherche,map_volume_recherche);
  TPL_MAP_ENTITE<MG_VOLUME*>::ITERATEUR it_volume;
  MG_VOLUME* volume_recherche=map_volume_recherche.get_premier(it_volume);    
  double distance;
  while(volume_recherche!=NULL)
  {
    if(OT_GEOMETRIE::get_distance_min_mg_volume_mg_volume(inclusion,volume_recherche,distance)==FAIL) return FAIL;
    else
    {
      if(distance<=m_distance_min+m_precision) return FAIL;
      else volume_recherche=map_volume_recherche.get_suivant(it_volume);
    }
  }
  return OK;
}
 
bool MSTRUCT_GENERATEUR::lien_topologique_entre(MG_ELEMENT_TOPOLOGIQUE* mg_ele_topo1, MG_ELEMENT_TOPOLOGIQUE* mg_ele_topo2)
{
  TPL_MAP_ENTITE<MG_SOMMET*> map_sommet_volume1;
  OT_GEOMETRIE::get_map_mg_sommet_sous_jacent(mg_ele_topo1,map_sommet_volume1);
  TPL_MAP_ENTITE<MG_SOMMET*> map_sommet_volume2;
  OT_GEOMETRIE::get_map_mg_sommet_sous_jacent(mg_ele_topo2,map_sommet_volume2);
  TPL_MAP_ENTITE<MG_SOMMET*>::ITERATEUR it_sommet;
  for(MG_SOMMET* sommet=map_sommet_volume1.get_premier(it_sommet);sommet!=NULL;sommet=map_sommet_volume1.get_suivant(it_sommet))
  {
    if(map_sommet_volume2.existe(sommet)) return true;
  }
  return false;
}
 
void MSTRUCT_GENERATEUR::cree_vector_groupe_forme(std::string nom, std::vector< MG_CG_GROUPE_FORME* >& vector_groupe_forme, std::vector< double >* vector_epaisseur_couches)
{
  if(vector_epaisseur_couches==NULL)
  {
    MG_CG_GROUPE_FORME* groupe_forme;
    groupe_forme=MG_CG::creer_MG_CG_GROUPE_FORME(m_mgcg_modele,nom);
    m_vector_mgcg_groupe_forme_inclusion.push_back(groupe_forme);
    vector_groupe_forme.push_back(groupe_forme);
  }
  else
  {
    MG_CG_GROUPE_FORME* groupe_forme;
    groupe_forme=MG_CG::creer_MG_CG_GROUPE_FORME(m_mgcg_modele,nom);
    m_vector_mgcg_groupe_forme_inclusion.push_back(groupe_forme);
    vector_groupe_forme.push_back(groupe_forme);    
    for(int i=0;i<vector_epaisseur_couches->size();i++)
    {
        char nom_couche[500];
        sprintf(nom_couche,"%s_%i",nom.c_str(),i);
        groupe_forme=MG_CG::creer_MG_CG_GROUPE_FORME(m_mgcg_modele,nom_couche);
        m_vector_mgcg_groupe_forme_inclusion.push_back(groupe_forme);
        vector_groupe_forme.push_back(groupe_forme);            
    }    
  }
}
 
int MSTRUCT_GENERATEUR::configurer_volume_mince(MG_CG_FORME* forme,double epaisseur)
{
  if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
  {
    MG_VOLUME* volume = ((MG_CG_FORME_VOLUME*)forme)->get_mg_volume();
    configurer_volume_mince(volume,epaisseur);
  }
  if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
  {
    MG_CG_FORME_MULTI_VOLUME* forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)forme;
    std::map<long,MG_VOLUME*>::iterator it_volume;
    for(MG_VOLUME* volume=forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume->get_suivant_mg_volume(it_volume))
    {
      configurer_volume_mince(volume,epaisseur);
    }
  }
return 0;
}
 
int MSTRUCT_GENERATEUR::configurer_volume_mince(MG_VOLUME* volume, double epaisseur)
{
  TPL_MAP_ENTITE<MG_FACE*> tpl_map_face;
  OT_GEOMETRIE::get_map_mg_face_sous_jacent(volume,tpl_map_face);
  if(tpl_map_face.get_nb()<2) return FAIL;
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face1;
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face2;  
  std::cout << "NB_FACE = " << tpl_map_face.get_nb() << std::endl;
  while(tpl_map_face.get_nb()>=2)
  {
    bool trouve=false;
    MG_FACE* face1=tpl_map_face.get_premier(it_face1);
    it_face2=it_face1;
    MG_FACE* face2=tpl_map_face.get_suivant(it_face2);
    while(trouve==false && face1!=NULL && face2!=NULL)
    {
      double distance_moyenne;
      double ecart_type_distance;
      OT_GEOMETRIE::declage_mg_face_mg_face(face1,face2,distance_moyenne,ecart_type_distance,32);
      std::cout << "   Distance = " << distance_moyenne << " Std-dev = " << ecart_type_distance << " Epaisseur = " << epaisseur << std::endl;
      if(OPERATEUR::egal(epaisseur,distance_moyenne,m_precision) && ecart_type_distance<m_precision)
      {
        std::cout << "   Correspondance : " << face1->get_id() << " , " << face2->get_id()  << std::endl;
        trouve=true;
        bool face1_base=false;
        bool face2_base=false;
        if(face1_base==true)
        {
          volume->ajouter_face_correspondante(face1,face2);
        }
        else if(face2_base==true)
        {
          volume->ajouter_face_correspondante(face2,face1);
        }
        else
        {
          double aire_face1 = OT_GEOMETRIE::get_aire(face1,m_precision);
          double aire_face2 = OT_GEOMETRIE::get_aire(face2,m_precision);
          if(aire_face1<aire_face2)
          {
            volume->ajouter_face_correspondante(face1,face2);
          }
          else
          {
            volume->ajouter_face_correspondante(face2,face1);
          }
        }
      }
      else face2=tpl_map_face.get_suivant(it_face2);
    }
    if(trouve)
    {
      tpl_map_face.supprimer(face1);
      tpl_map_face.supprimer(face2);
    }
    else tpl_map_face.supprimer(face1);
  }  
 
return 0;    
}
 
 
void MSTRUCT_GENERATEUR::active_affichage(fonction_affiche* fonc)
{
  fonc_affiche = fonc;
  affichageactif = 1;
}
 
void MSTRUCT_GENERATEUR::affiche(char* message)
{
  if(affichageactif==1) fonc_affiche(message);
}