microstructure/src/mstruct_generateur.cpp

#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;
  BOITE_3D boite_inclusion=inclusion->get_boite_3D(m_nb_pas_echantillonnage);
  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;    
  }
}

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());
//     volume_particule=OT_GEOMETRIE::get_volume(volume_inclusion_couche_externe,m_precision);
    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);
      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+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_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(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);
    }
  }
}

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)
        {
//        std::cout << "Face1 base" << std::endl;
          volume->ajouter_face_correspondante(face1,face2);
        }
        else if(face2_base==true)
        {
//        std::cout << "Face2 base" << std::endl;
          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)
          {
//          std::cout << "Aire Face1 base" << std::endl;
            volume->ajouter_face_correspondante(face1,face2);
          }
          else
          {
//          std::cout << "Aire Face2 base" << std::endl;
            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);
  }  
}


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);
}
Revision:	968
Committed:	Sun Sep 16 15:27:49 2018 UTC (6 years, 7 months ago) by couturad
File size:	47732 byte(s)
Log Message:	Ajout d'une condition de sortie et d'un renvoi d'erreur pour le mailleur FEM. Subdivision des fichiers mstruct_analyse.h/.cpp en sous fichiers pour une meilleure lisibilite. Ajout d'une analyse des modules d'elasticite. Ajout d'une analyse de l'energie. Reconfiguration du main de microstructure.exe (suppression d'actions obsolètes). Reconfiguration des fichiers generer_nb_ves, post_process.