mg_cg_modele.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_cg_modele.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mg_cg_modele.h"
 
#include "mg_gestionnaire.h"
#include "ot_geometrie.h"
#include "mg_geometrie.h"
#include "mg_sous_geometrie.h"
 
 
#include "mg_cg_assemblage.h"
 
#include "mg_cg_forme.h"
#include "mg_cg_forme_volume.h"
#include "mg_cg_forme_multi_volume.h"
#include "mg_cg_forme_multiple.h"
 
#include "mg_cg_operateur.h"
 
#include "mg_cg_groupe_forme.h"
 
MG_CG_MODELE::MG_CG_MODELE(MG_GESTIONNAIRE* mg_gestionnaire, std::string nom_mgcg_modele, MG_GEOMETRIE* mg_geometrie): MG_CONSTRUCTION_GEOMETRIQUE(),
                                                                                                                       m_mg_gestionnaire(mg_gestionnaire),
                                                                                                                       m_nom_mgcg_modele(nom_mgcg_modele),
                                                                                                                       m_mg_geometrie(mg_geometrie)
{
  m_fonction_affichage=NULL;
  m_fusionner_entite_similaire=false;
  m_importer_triangulation=false;
  m_epsilon_triangulation=1.0;
}
 
MG_CG_MODELE::MG_CG_MODELE(MG_GESTIONNAIRE* mg_gestionnaire, std::string nom_mgcg_modele, MG_GEOMETRIE* mg_geometrie, unsigned long num): MG_CONSTRUCTION_GEOMETRIQUE(num),
                                                                                                                                          m_mg_gestionnaire(mg_gestionnaire),
                                                                                                                                          m_nom_mgcg_modele(nom_mgcg_modele),
                                                                                                                                          m_mg_geometrie(mg_geometrie)
{
  m_fonction_affichage=NULL;
}
 
MG_CG_MODELE::~MG_CG_MODELE(void)
{
  supprimer_tout_mgcg_assemblage();
  std::map<long,MG_CG_FORME*>::iterator it;
  for(it=m_map_mgcg_forme.begin();it!=m_map_mgcg_forme.end();it++)
  {
    MG_CG_FORME* forme = it->second;
    delete forme;
  }
  m_map_mgcg_forme.clear();
  supprimer_tout_mgcg_operateur();  
}
 
void MG_CG_MODELE::active_affichagage(FONCTION_AFFICHAGE* fonction_affichage)
{
  m_fonction_affichage=fonction_affichage;
}
 
void MG_CG_MODELE::affiche(char* message)
{
  if(m_fonction_affichage!=NULL) m_fonction_affichage(message);
}
 
MG_GESTIONNAIRE* MG_CG_MODELE::get_mg_gestionnaire(void)
{
  return m_mg_gestionnaire;
}
 
void MG_CG_MODELE::change_mg_gestionnaire(MG_GESTIONNAIRE* mg_gestionnaire)
{
  m_mg_gestionnaire=mg_gestionnaire;
}
 
void MG_CG_MODELE::change_mg_geometrie(MG_GEOMETRIE* mg_geometrie)
{
  m_mg_geometrie=mg_geometrie;
}
 
MG_GEOMETRIE* MG_CG_MODELE::get_mg_geometrie(void)
{
  return m_mg_geometrie;
}
 
long int MG_CG_MODELE::get_nb_mgcg_operateur(void)
{
  return m_map_mgcg_operateur.size();
}
 
void MG_CG_MODELE::change_nom_mgcg_modele(std::string nom_mgcg_modele)
{
  m_nom_mgcg_modele=nom_mgcg_modele;
}
 
std::string MG_CG_MODELE::get_nom_mgcg_modele(void)
{
  return m_nom_mgcg_modele;
}
 
int MG_CG_MODELE::ajouter_mgcg_operateur(MG_CG_OPERATEUR* mgcg_operateur)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_operateur);
  std::pair<std::map<long,MG_CG_OPERATEUR*>::iterator,bool> p=m_map_mgcg_operateur.insert(std::pair<long,MG_CG_OPERATEUR*>(mgcg_operateur->get_id(),mgcg_operateur));
  if (!p.second)  
    return FAIL;
  mgcg_operateur->change_mgcg_modele(this);
  ajouter_objet_sequence_construction(mgcg_operateur);
  return OK;
}
 
int MG_CG_MODELE::ajouter_mgcg_operateur_avant(MG_CG_OPERATEUR* mgcg_operateur, MG_CONSTRUCTION_GEOMETRIQUE* objet_avant)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_operateur);
  std::pair<std::map<long,MG_CG_OPERATEUR*>::iterator,bool> p=m_map_mgcg_operateur.insert(std::pair<long,MG_CG_OPERATEUR*>(mgcg_operateur->get_id(),mgcg_operateur));
  if (!p.second)  
    return FAIL;
  mgcg_operateur->change_mgcg_modele(this);
  ajouter_objet_sequence_construction_avant(mgcg_operateur,objet_avant);
  return OK;
}
 
 
int MG_CG_MODELE::supprimer_mgcg_operateurid(long int id)
{
  std::map<long,MG_CG_OPERATEUR*>::iterator it;
  it=m_map_mgcg_operateur.find(id);
  if(it!=m_map_mgcg_operateur.end())
  {
    retirer_objet_sequence_construction(it->second);
    delete it->second;
    m_map_mgcg_operateur.erase(it);
  } 
  else return FAIL;
  return OK;
}
 
void MG_CG_MODELE::supprimer_tout_mgcg_operateur(void)
{
  std::map<long,MG_CG_OPERATEUR*>::iterator it;
  for(it=m_map_mgcg_operateur.begin();it!=m_map_mgcg_operateur.end();it++)
  {
    delete it->second;
  }
  m_map_mgcg_operateur.clear();
}
 
MG_CG_OPERATEUR* MG_CG_MODELE::get_premier_mgcg_operateur(std::map< long, MG_CG_OPERATEUR* >::iterator& it)
{
  it=m_map_mgcg_operateur.begin();
  if(it==m_map_mgcg_operateur.end())  
    return NULL;
  return it->second;  
}
MG_CG_OPERATEUR* MG_CG_MODELE::get_suivant_mgcg_operateur(std::map< long, MG_CG_OPERATEUR* >::iterator& it)
{
  it++;
  if(it==m_map_mgcg_operateur.end())  
    return NULL;
  return it->second;
}
 
MG_CG_OPERATEUR* MG_CG_MODELE::get_mgcg_operateurid(long int id)
{
  std::map<long,MG_CG_OPERATEUR*>::iterator it=m_map_mgcg_operateur.find(id);
  if (it==m_map_mgcg_operateur.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
long int MG_CG_MODELE::get_nb_mgcg_forme(void)
{
  return m_map_mgcg_forme.size();
}
 
int MG_CG_MODELE::ajouter_mgcg_forme(MG_CG_FORME* mgcg_forme)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_forme);
  std::pair<std::map<long,MG_CG_FORME*>::iterator,bool> p=m_map_mgcg_forme.insert(std::pair<long,MG_CG_FORME*>(mgcg_forme->get_id(),mgcg_forme));
  if (!p.second)  
    return FAIL;
  mgcg_forme->change_mgcg_modele(this);
  ajouter_objet_sequence_construction(mgcg_forme);
  return OK;
}
 
int MG_CG_MODELE::ajouter_mgcg_forme_avant(MG_CG_FORME* mgcg_forme, MG_CONSTRUCTION_GEOMETRIQUE* objet_avant)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_forme);
  std::pair<std::map<long,MG_CG_FORME*>::iterator,bool> p=m_map_mgcg_forme.insert(std::pair<long,MG_CG_FORME*>(mgcg_forme->get_id(),mgcg_forme));
  if (!p.second)  
    return FAIL;
  mgcg_forme->change_mgcg_modele(this);
  ajouter_objet_sequence_construction_avant(mgcg_forme,objet_avant);
  return OK;
}
 
int MG_CG_MODELE::remplacer_mgcg_forme(MG_CG_FORME* mgcg_forme_nouvelle, MG_CG_FORME* mgcg_forme_ancienne)
{
  if(ajouter_mgcg_forme_avant(mgcg_forme_nouvelle,mgcg_forme_ancienne)!=OK) return FAIL;
  mgcg_forme_nouvelle->change_mgcg_operateur_parent(mgcg_forme_ancienne->get_mgcg_operateur_parent());
  std::map<long,MG_CG_OPERATEUR*>::iterator it_operateur;
  for(MG_CG_OPERATEUR* operateur=mgcg_forme_ancienne->get_premier_mgcg_operateur_dependant(it_operateur);operateur!=NULL;operateur=mgcg_forme_ancienne->get_suivant_mgcg_operateur_dependant(it_operateur))
  {
    mgcg_forme_nouvelle->ajouter_mgcg_operateur_dependant(operateur);
  }
  std::map<long,MG_CG_ASSEMBLAGE*>::iterator it_assemblage;
  for(MG_CG_ASSEMBLAGE* assemblage=get_premier_mgcg_assemblage(it_assemblage);assemblage!=NULL;assemblage=get_suivant_mgcg_assemblage(it_assemblage))
  {
    if(assemblage->get_mgcg_formeid(mgcg_forme_ancienne->get_id())!=NULL)
    {
      assemblage->retirer_mgcg_formeid(mgcg_forme_ancienne->get_id());
      assemblage->ajouter_mgcg_forme(mgcg_forme_nouvelle);
    }    
  }
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it_groupe_forme;
    for(MG_CG_GROUPE_FORME* groupe_forme=get_premier_mgcg_groupe_forme(it_groupe_forme);groupe_forme!=NULL;groupe_forme=get_suivant_mgcg_groupe_forme(it_groupe_forme))
    {
      if(groupe_forme->get_mgcg_forme(mgcg_forme_ancienne->get_id())!=NULL)
      {
        groupe_forme->retirer_mgcg_forme(mgcg_forme_ancienne);
        groupe_forme->ajouter_mgcg_forme(mgcg_forme_nouvelle);
      }
    }
  supprimer_mgcg_formeid(mgcg_forme_ancienne->get_id());
  return 0;
}
 
int MG_CG_MODELE::supprimer_mgcg_formeid(long int id,bool avec_mg_element)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme.find(id);
  if(it!=m_map_mgcg_forme.end())
  {
    MG_CG_FORME* forme = it->second;
    std::map<long,MG_CG_ASSEMBLAGE*>::iterator it_assemblage;
    for(MG_CG_ASSEMBLAGE* assemblage=get_premier_mgcg_assemblage(it_assemblage);assemblage!=NULL;assemblage=get_suivant_mgcg_assemblage(it_assemblage))
    {
      if(assemblage->get_mgcg_formeid(forme->get_id())!=NULL) assemblage->retirer_mgcg_formeid(forme->get_id());
    }
    std::map<long,MG_CG_GROUPE_FORME*>::iterator it_groupe_forme;
    for(MG_CG_GROUPE_FORME* groupe_forme=get_premier_mgcg_groupe_forme(it_groupe_forme);groupe_forme!=NULL;groupe_forme=get_suivant_mgcg_groupe_forme(it_groupe_forme))
    {
      if(groupe_forme->get_mgcg_forme(forme->get_id())!=NULL) groupe_forme->retirer_mgcg_forme(forme);
    }
    m_map_mgcg_forme.erase(it);
    supprimer_mg_element_mgcg_forme(forme);
    retirer_objet_sequence_construction(forme);
    
    delete forme; 
    return OK;
  }
  else return FAIL;
}
 
void MG_CG_MODELE::supprimer_tout_mgcg_forme(bool avec_mg_element)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  for(it=m_map_mgcg_forme.begin();it!=m_map_mgcg_forme.end();it++)
  {
    MG_CG_FORME* forme = it->second;
    std::map<long,MG_CG_ASSEMBLAGE*>::iterator it_assemblage;
    for(MG_CG_ASSEMBLAGE* assemblage=get_premier_mgcg_assemblage(it_assemblage);assemblage!=NULL;assemblage=get_suivant_mgcg_assemblage(it_assemblage))
    {
      if(assemblage->get_mgcg_formeid(forme->get_id())!=NULL) assemblage->retirer_mgcg_formeid(forme->get_id());
    }
    std::map<long,MG_CG_GROUPE_FORME*>::iterator it_groupe_forme;
    for(MG_CG_GROUPE_FORME* groupe_forme=get_premier_mgcg_groupe_forme(it_groupe_forme);groupe_forme!=NULL;groupe_forme=get_suivant_mgcg_groupe_forme(it_groupe_forme))
    {
      if(groupe_forme->get_mgcg_forme(forme->get_id())!=NULL) groupe_forme->retirer_mgcg_forme(forme);
    }
    retirer_objet_sequence_construction(forme);
    supprimer_mg_element_mgcg_forme(forme);
    delete forme;
  }
  m_map_mgcg_forme.clear();
}
 
MG_CG_FORME* MG_CG_MODELE::get_mgcg_formeid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it=m_map_mgcg_forme.find(id);
  if (it==m_map_mgcg_forme.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
MG_CG_FORME* MG_CG_MODELE::get_premiere_mgcg_forme(std::map< long, MG_CG_FORME* >::iterator& it)
{
  it=m_map_mgcg_forme.begin();
  if(it==m_map_mgcg_forme.end())  
    return NULL;
  return it->second;  
}
 
MG_CG_FORME* MG_CG_MODELE::get_suivante_mgcg_forme(std::map< long, MG_CG_FORME* >::iterator& it)
{
  it++;
  if(it==m_map_mgcg_forme.end())  
    return NULL;
  return it->second;
}
 
long int MG_CG_MODELE::get_nb_mgcg_assemblage(void)
{
  return m_map_mgcg_assemblage.size();
}
 
int MG_CG_MODELE::ajouter_mgcg_assemblage(MG_CG_ASSEMBLAGE* mgcg_assemblage)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_assemblage);
  std::pair<std::map<long,MG_CG_ASSEMBLAGE*>::iterator,bool> p=m_map_mgcg_assemblage.insert(std::pair<long,MG_CG_ASSEMBLAGE*>(mgcg_assemblage->get_id(),mgcg_assemblage));
  if (!p.second)  
    return FAIL;
  return OK;
}
 
int MG_CG_MODELE::supprimer_mgcg_assemglageid(long int id)
{
  std::map<long,MG_CG_ASSEMBLAGE*>::iterator it;
  it=m_map_mgcg_assemblage.find(id);
  if(it!=m_map_mgcg_assemblage.end())
  {
    MG_CG_ASSEMBLAGE* assemblage = it->second;
    m_map_mgcg_assemblage.erase(it);    
    delete assemblage;   
    return OK;
    it++;
  }
  else return FAIL;
}
 
void MG_CG_MODELE::supprimer_tout_mgcg_assemblage(void)
{
  std::map<long,MG_CG_ASSEMBLAGE*>::iterator it;
  for(it=m_map_mgcg_assemblage.begin();it!=m_map_mgcg_assemblage.end();it++)
  {
    MG_CG_ASSEMBLAGE* assemblage = it->second;
    delete assemblage;
  }
  m_map_mgcg_assemblage.clear();
}
 
MG_CG_ASSEMBLAGE* MG_CG_MODELE::get_premier_mgcg_assemblage(std::map< long, MG_CG_ASSEMBLAGE* >::iterator& it)
{
  it=m_map_mgcg_assemblage.begin();
  if(it==m_map_mgcg_assemblage.end())  
    return NULL;
  return it->second; 
}
 
MG_CG_ASSEMBLAGE* MG_CG_MODELE::get_suivant_mgcg_assemblage(std::map< long, MG_CG_ASSEMBLAGE* >::iterator& it)
{
  it++;
  if(it==m_map_mgcg_assemblage.end())  
    return NULL;
  return it->second;
}
 
MG_CG_ASSEMBLAGE* MG_CG_MODELE::get_mgcg_assemblageid(long int id)
{
  std::map<long,MG_CG_ASSEMBLAGE*>::iterator it=m_map_mgcg_assemblage.find(id);
  if (it==m_map_mgcg_assemblage.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
long int MG_CG_MODELE::get_nb_objet_sequence_construction(void)
{
  return m_vector_objet_sequence_construction.size();
}
 
void MG_CG_MODELE::ajouter_objet_sequence_construction(MG_CONSTRUCTION_GEOMETRIQUE* objet)
{
  m_vector_objet_sequence_construction.push_back(objet);
}
 
int MG_CG_MODELE::ajouter_objet_sequence_construction_avant(MG_CONSTRUCTION_GEOMETRIQUE* objet, MG_CONSTRUCTION_GEOMETRIQUE* objet_avant)
{
  std::vector<MG_CONSTRUCTION_GEOMETRIQUE*>::iterator it;
  it=m_vector_objet_sequence_construction.begin();
  while(it!=m_vector_objet_sequence_construction.end())
  {
    if(*it==objet_avant)
    {
      m_vector_objet_sequence_construction.insert(it,objet);
      return OK;
    }
    it++;
  }
  return FAIL;
}
 
MG_CONSTRUCTION_GEOMETRIQUE* MG_CG_MODELE::get_premier_objet_sequence_construction(std::vector< MG_CONSTRUCTION_GEOMETRIQUE* >::iterator& it)
{
  it=m_vector_objet_sequence_construction.begin();
  if(it==m_vector_objet_sequence_construction.end()) return NULL;
  else return *it;
}
 
MG_CONSTRUCTION_GEOMETRIQUE* MG_CG_MODELE::get_suivant_objet_sequence_construction(std::vector< MG_CONSTRUCTION_GEOMETRIQUE* >::iterator& it)
{
  it++;
  if(it==m_vector_objet_sequence_construction.end()) return NULL;
  else return *it;
}
 
int MG_CG_MODELE::retirer_objet_sequence_construction(MG_CONSTRUCTION_GEOMETRIQUE* objet)
{
  std::vector<MG_CONSTRUCTION_GEOMETRIQUE*>::iterator it;
  it=m_vector_objet_sequence_construction.begin();
  while(it!=m_vector_objet_sequence_construction.end())
  {
    if(*it==objet)
    {
      m_vector_objet_sequence_construction.erase(it);
      return OK;
    }
    it++;
  }
  return FAIL;
}
 
void MG_CG_MODELE::retirer_tout_objet_sequence_construction(void)
{
  m_vector_objet_sequence_construction.clear();
}
 
long int MG_CG_MODELE::get_nb_mgcg_groupe_forme(void)
{
  return m_map_groupe_forme.size();
}
 
int MG_CG_MODELE::ajouter_mgcg_groupe_forme(MG_CG_GROUPE_FORME* mgcg_groupe_forme)
{
  m_mg_gestionnaire->recherche_bonid(*mgcg_groupe_forme);
  std::pair<std::map<long,MG_CG_GROUPE_FORME*>::iterator,bool> p=m_map_groupe_forme.insert(std::pair<long,MG_CG_GROUPE_FORME*>(mgcg_groupe_forme->get_id(),mgcg_groupe_forme));
  if (!p.second)  
    return FAIL;
  return OK;
}
 
int MG_CG_MODELE::supprimer_mgcg_groupe_forme(MG_CG_GROUPE_FORME* mgcg_groupe_forme)
{
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it;
  it=m_map_groupe_forme.find(mgcg_groupe_forme->get_id());
  if(it!=m_map_groupe_forme.end())
  {
    m_map_groupe_forme.erase(it);
    delete mgcg_groupe_forme;
    return OK;
  }
  else return FAIL;
}
 
MG_CG_GROUPE_FORME* MG_CG_MODELE::get_premier_mgcg_groupe_forme(std::map< long, MG_CG_GROUPE_FORME* >::iterator& it)
{
  it=m_map_groupe_forme.begin();
  if(it==m_map_groupe_forme.end())  
    return NULL;
  return it->second; 
}
 
MG_CG_GROUPE_FORME* MG_CG_MODELE::get_suivant_mgcg_groupe_forme(std::map< long, MG_CG_GROUPE_FORME* >::iterator& it)
{
  it++;
  if(it==m_map_groupe_forme.end())  
    return NULL;
  return it->second;
}
 
MG_CG_GROUPE_FORME* MG_CG_MODELE::get_mgcg_groupe_formeid(long int id)
{
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it=m_map_groupe_forme.find(id);
  if (it==m_map_groupe_forme.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
MG_CG_GROUPE_FORME* MG_CG_MODELE::get_mgcg_groupe_forme(std::string nom)
{
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it=m_map_groupe_forme.begin();
  MG_CG_GROUPE_FORME* groupe_forme=NULL;
  while(groupe_forme==NULL && it!=m_map_groupe_forme.end())
  {
    if(it->second->get_nom()==nom)
    {
      groupe_forme=it->second;
      return groupe_forme;
    }
    it++;
  }
  return NULL;
}
 
 
void MG_CG_MODELE::enregistrer(std::ostream& o, double version)
{
  o << "%" << get_id() 
    << "=MG_CG_MODELE("
    << m_nom_mgcg_modele
    << ",$" << m_mg_geometrie->get_id()
    << "," << m_fusionner_entite_similaire
    << "," << m_importer_triangulation
    << "," << m_epsilon_triangulation
    << ");" << std::endl;
  enregistrer_infos(o,version);
  std::vector<MG_CONSTRUCTION_GEOMETRIQUE*>::iterator it_objet;
  for(MG_CONSTRUCTION_GEOMETRIQUE* objet=get_premier_objet_sequence_construction(it_objet);objet!=NULL;objet=get_suivant_objet_sequence_construction(it_objet))
  {
    objet->enregistrer(o,version);
  }
  std::map<long,MG_CG_ASSEMBLAGE*>::iterator it_assemblage;
  for(MG_CG_ASSEMBLAGE* assemblage = get_premier_mgcg_assemblage(it_assemblage);assemblage!=NULL;assemblage=get_suivant_mgcg_assemblage(it_assemblage))
  {
    assemblage->enregistrer(o,version);
  }
  std::map<long,MG_CG_GROUPE_FORME*>::iterator it_groupe_forme;
  for(MG_CG_GROUPE_FORME* groupe_forme=get_premier_mgcg_groupe_forme(it_groupe_forme);groupe_forme!=NULL;groupe_forme=get_suivant_mgcg_groupe_forme(it_groupe_forme))
  {
    groupe_forme->enregistrer(o,version);
  }
  
}
 
 
void MG_CG_MODELE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
 
}
 
int MG_CG_MODELE::get_type_mg_construction_geometrique(void)
{
  return TYPE_MG_CONSTRUCTION_GEOMETRIQUE::MGCG_MODELE;
}
 
void MG_CG_MODELE::mise_a_jour_geometrie(void)
{
  TPL_MAP_ENTITE<MG_IDENTIFICATEUR*> map_id_present;
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_mg_element_topologique;
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*> map_mg_element_cotopologique;
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*> map_mg_element_geometrique;
  std::map<long,MG_CG_FORME*>::iterator it_forme;
  for(MG_CG_FORME* mgcg_forme=get_premiere_mgcg_forme(it_forme);mgcg_forme!=NULL;mgcg_forme=get_suivante_mgcg_forme(it_forme))
  {
    switch(mgcg_forme->get_type_forme())
    {
      case MG_CG_FORME::TYPE_FORME::MULTIPLE:
      {
        MG_CG_FORME_MULTIPLE* mgcg_forme_multiple = (MG_CG_FORME_MULTIPLE*)mgcg_forme;
        std::map<long,MG_ELEMENT_TOPOLOGIQUE*>::iterator it_topo;
        for(MG_ELEMENT_TOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_topologique(it_topo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_topologique(it_topo))
        {
          map_mg_element_topologique.ajouter(ele);
          OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                      &map_mg_element_topologique,
                                                      &map_mg_element_cotopologique,
                                                      &map_mg_element_geometrique);
        }
        std::map<long,MG_ELEMENT_COTOPOLOGIQUE*>::iterator it_cotopo;
        for(MG_ELEMENT_COTOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_cotopologique(it_cotopo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_cotopologique(it_cotopo))
        {
          map_mg_element_cotopologique.ajouter(ele);
          OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                      &map_mg_element_topologique,
                                                      &map_mg_element_cotopologique,
                                                      &map_mg_element_geometrique);
        }
        break;
      }
      case MG_CG_FORME::TYPE_FORME::MULTI_VOLUME:
      {
        MG_CG_FORME_MULTI_VOLUME* mgcg_forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)mgcg_forme;
        std::map<long,MG_VOLUME*>::iterator it_volume;
        for(MG_VOLUME* volume=mgcg_forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=mgcg_forme_multi_volume->get_suivant_mg_volume(it_volume))
        {
          map_mg_element_topologique.ajouter(volume);
          OT_GEOMETRIE::get_map_mg_element_sous_jacent(volume,
                                                      &map_mg_element_topologique,
                                                      &map_mg_element_cotopologique,
                                                      &map_mg_element_geometrique);
        }
        break;
      }
      case MG_CG_FORME::TYPE_FORME::VOLUME:
      {
        MG_CG_FORME_VOLUME* mgcg_forme_volume = (MG_CG_FORME_VOLUME*)mgcg_forme;
        map_mg_element_topologique.ajouter(mgcg_forme_volume->get_mg_volume());
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(mgcg_forme_volume->get_mg_volume(),
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
        break;
      }    
    }
  }
  
  LISTE_MG_POINT::iterator it_mg_point;
  LISTE_MG_COURBE::iterator it_mg_courbe;
  LISTE_MG_SURFACE::iterator it_mg_surface;
  LISTE_MG_SOMMET::iterator it_mg_sommet;
  LISTE_MG_COSOMMET::iterator it_mg_cosommet;
  LISTE_MG_ARETE::iterator it_mg_arete;
  LISTE_MG_COARETE::iterator it_mg_coarete;
  LISTE_MG_BOUCLE::iterator it_mg_boucle;
  LISTE_MG_FACE::iterator it_mg_face;
  LISTE_MG_COFACE::iterator it_mg_coface;
  LISTE_MG_COQUILLE::iterator it_mg_coquille;
  LISTE_MG_VOLUME::iterator it_mg_volume;
  LISTE_MG_COQUE::iterator it_mg_coque;
  LISTE_MG_POUTRE::iterator it_mg_poutre;
  
  for(MG_VOLUME* mg_volume=m_mg_geometrie->get_premier_volume(it_mg_volume);mg_volume!=NULL;mg_volume=m_mg_geometrie->get_suivant_volume(it_mg_volume))
  {
    if(map_mg_element_topologique.getid(mg_volume->get_id())==NULL) m_mg_geometrie->supprimer_mg_volumeid(mg_volume->get_id());
  }
  for(MG_COQUE* mg_coque=m_mg_geometrie->get_premier_coque(it_mg_coque);mg_coque!=NULL;mg_coque=m_mg_geometrie->get_suivant_coque(it_mg_coque))
  {
    if(map_mg_element_topologique.getid(mg_coque->get_id())==NULL) m_mg_geometrie->supprimer_mg_coqueid(mg_coque->get_id());
  }
  for(MG_POUTRE* mg_poutre=m_mg_geometrie->get_premier_poutre(it_mg_poutre);mg_poutre!=NULL;mg_poutre=m_mg_geometrie->get_suivant_poutre(it_mg_poutre))
  {
    if(map_mg_element_topologique.getid(mg_poutre->get_id())==NULL) m_mg_geometrie->supprimer_mg_poutreid(mg_poutre->get_id());
  }
  for(MG_COQUILLE* mg_coquille=m_mg_geometrie->get_premier_coquille(it_mg_coquille);mg_coquille!=NULL;mg_coquille=m_mg_geometrie->get_suivant_coquille(it_mg_coquille))
  {
    if(map_mg_element_cotopologique.getid(mg_coquille->get_id())==NULL) m_mg_geometrie->supprimer_mg_coquilleid(mg_coquille->get_id());
  }
  for(MG_FACE* mg_face=m_mg_geometrie->get_premier_face(it_mg_face);mg_face!=NULL;mg_face=m_mg_geometrie->get_suivant_face(it_mg_face))
  {
    if(map_mg_element_topologique.getid(mg_face->get_id())==NULL)
    {
      MG_SURFACE* surface = mg_face->get_surface();
      std::vector<MG_BOUCLE*> vector_boucle_face;
      for(int i=0;i<mg_face->get_nb_mg_boucle();i++) vector_boucle_face.push_back(mg_face->get_mg_boucle(i));
      if(m_mg_geometrie->supprimer_mg_faceid(mg_face->get_id())==OK)
      {
        m_mg_geometrie->supprimer_mg_surfaceid(surface->get_id());
        for(int i=0;i<vector_boucle_face.size();i++)
          m_mg_geometrie->supprimer_mg_boucleid(vector_boucle_face.at(i)->get_id());
      }
    }
  }
  for(MG_ARETE* mg_arete=m_mg_geometrie->get_premier_arete(it_mg_arete);mg_arete!=NULL;mg_arete=m_mg_geometrie->get_suivant_arete(it_mg_arete))
  {
    if(map_mg_element_topologique.getid(mg_arete->get_id())==NULL)
    {
      MG_COURBE* courbe = mg_arete->get_courbe();
      if(m_mg_geometrie->supprimer_mg_areteid(mg_arete->get_id())==OK)
      m_mg_geometrie->supprimer_mg_courbeid(courbe->get_id());
    }
  }
  for(MG_SOMMET* mg_sommet=m_mg_geometrie->get_premier_sommet(it_mg_sommet);mg_sommet!=NULL;mg_sommet=m_mg_geometrie->get_suivant_sommet(it_mg_sommet))
  {
    if(map_mg_element_topologique.getid(mg_sommet->get_id())==NULL)
    {
      MG_POINT* point = mg_sommet->get_point();
      if(m_mg_geometrie->supprimer_mg_sommetid(mg_sommet->get_id())==OK)
      m_mg_geometrie->supprimer_mg_pointid(point->get_id());      
    }
  }
}
 
void MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme)
{
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_mg_element_topologique;
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*> map_mg_element_cotopologique;
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*> map_mg_element_geometrique;
  switch(mgcg_forme->get_type_forme())
  {
    case MG_CG_FORME::TYPE_FORME::MULTIPLE:
    {
      MG_CG_FORME_MULTIPLE* mgcg_forme_multiple = (MG_CG_FORME_MULTIPLE*)mgcg_forme;
      std::map<long,MG_ELEMENT_TOPOLOGIQUE*>::iterator it_topo;
      for(MG_ELEMENT_TOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_topologique(it_topo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_topologique(it_topo))
      {
        map_mg_element_topologique.ajouter(ele);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      std::map<long,MG_ELEMENT_COTOPOLOGIQUE*>::iterator it_cotopo;
      for(MG_ELEMENT_COTOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_cotopologique(it_cotopo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_cotopologique(it_cotopo))
      {
        map_mg_element_cotopologique.ajouter(ele);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      break;
    }
    case MG_CG_FORME::TYPE_FORME::MULTI_VOLUME:
    {
      MG_CG_FORME_MULTI_VOLUME* mgcg_forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)mgcg_forme;
      std::map<long,MG_VOLUME*>::iterator it_volume;
      for(MG_VOLUME* volume=mgcg_forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=mgcg_forme_multi_volume->get_suivant_mg_volume(it_volume))
      {
        map_mg_element_topologique.ajouter(volume);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(volume,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      break;
    }
    case MG_CG_FORME::TYPE_FORME::VOLUME:
    {
      MG_CG_FORME_VOLUME* mgcg_forme_volume = (MG_CG_FORME_VOLUME*)mgcg_forme;
      map_mg_element_topologique.ajouter(mgcg_forme_volume->get_mg_volume());
      OT_GEOMETRIE::get_map_mg_element_sous_jacent(mgcg_forme_volume->get_mg_volume(),
                                                  &map_mg_element_topologique,
                                                  &map_mg_element_cotopologique,
                                                  &map_mg_element_geometrique);
      break;
    }    
  }  
  TPL_MAP_ENTITE<MG_VOLUME*> map_mg_volume;
  TPL_MAP_ENTITE<MG_COQUE*> map_mg_coque;
  TPL_MAP_ENTITE<MG_POUTRE*> map_mg_poutre;
  TPL_MAP_ENTITE<MG_COQUILLE*> map_mg_coquille;
  TPL_MAP_ENTITE<MG_COFACE*> map_mg_coface;
  TPL_MAP_ENTITE<MG_FACE*> map_mg_face;
  TPL_MAP_ENTITE<MG_SURFACE*> map_mg_surface;
  TPL_MAP_ENTITE<MG_BOUCLE*> map_mg_boucle;
  TPL_MAP_ENTITE<MG_COARETE*> map_mg_coarete;
  TPL_MAP_ENTITE<MG_ARETE*> map_mg_arete;
  TPL_MAP_ENTITE<MG_COURBE*> map_mg_courbe;
  TPL_MAP_ENTITE<MG_COSOMMET*> map_mg_cosommet;
  TPL_MAP_ENTITE<MG_SOMMET*> map_mg_sommet;
  TPL_MAP_ENTITE<MG_POINT*> map_mg_point;
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_topo;
  for(MG_ELEMENT_TOPOLOGIQUE* ele=map_mg_element_topologique.get_premier(it_topo);ele!=NULL;ele=map_mg_element_topologique.get_suivant(it_topo))
  {
    switch(ele->get_type())
    {
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::VOLUME:
        map_mg_volume.ajouter((MG_VOLUME*)ele); break;
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::COQUE:
        map_mg_coque.ajouter((MG_COQUE*)ele); break;
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::POUTRE:
        map_mg_poutre.ajouter((MG_POUTRE*)ele); break;
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::FACE:
        map_mg_face.ajouter((MG_FACE*)ele); break;
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::ARETE:
        map_mg_arete.ajouter((MG_ARETE*)ele); break;
      case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::SOMMET:
        map_mg_sommet.ajouter((MG_SOMMET*)ele); break;
    }
  }
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*>::ITERATEUR it_cotopo;
  for(MG_ELEMENT_COTOPOLOGIQUE* ele=map_mg_element_cotopologique.get_premier(it_cotopo);ele!=NULL;ele=map_mg_element_cotopologique.get_suivant(it_cotopo))
  {
    switch(ele->get_type())
    {
      case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COQUILLE:
        map_mg_coquille.ajouter((MG_COQUILLE*)ele);break;
      case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COFACE:
        map_mg_coface.ajouter((MG_COFACE*)ele);break;
      case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::BOUCLE:
        map_mg_boucle.ajouter((MG_BOUCLE*)ele);break;
      case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COARETE:
        map_mg_coarete.ajouter((MG_COARETE*)ele);break;
      case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COSOMMET:
        map_mg_cosommet.ajouter((MG_COSOMMET*)ele);break;
    }
  }
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*>::ITERATEUR it_geo;
  for(MG_ELEMENT_GEOMETRIQUE* ele=map_mg_element_geometrique.get_premier(it_geo);ele!=NULL;ele=map_mg_element_geometrique.get_suivant(it_geo))
  {
    switch(ele->get_type())
    {
      case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::POINT:
        map_mg_point.ajouter((MG_POINT*)ele);break;
      case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::COURBE:
        map_mg_courbe.ajouter((MG_COURBE*)ele);break;
      case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::SURFACE:
        map_mg_surface.ajouter((MG_SURFACE*)ele);break;
    }
  }
  
  TPL_MAP_ENTITE<MG_VOLUME*>::ITERATEUR it_volume;
  for(MG_VOLUME* volume=map_mg_volume.get_premier(it_volume);volume!=NULL;volume=map_mg_volume.get_suivant(it_volume))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(volume->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_volumeid(volume->get_id());        
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_COQUE*>::ITERATEUR it_coque;
  for(MG_COQUE* coque=map_mg_coque.get_premier(it_coque);coque!=NULL;coque=map_mg_coque.get_suivant(it_coque))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(coque->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_coqueid(coque->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }  
  TPL_MAP_ENTITE<MG_POUTRE*>::ITERATEUR it_poutre;
  for(MG_POUTRE* poutre=map_mg_poutre.get_premier(it_poutre);poutre!=NULL;poutre=map_mg_poutre.get_suivant(it_poutre))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(poutre->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_poutreid(poutre->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_COQUILLE*>::ITERATEUR it_coquille;
  for(MG_COQUILLE* coquille=map_mg_coquille.get_premier(it_coquille);coquille!=NULL;coquille=map_mg_coquille.get_suivant(it_coquille))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(coquille->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_coquilleid(coquille->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
      
    }
  }
  TPL_MAP_ENTITE<MG_FACE*>::ITERATEUR it_face;
  for(MG_FACE* face=map_mg_face.get_premier(it_face);face!=NULL;face=map_mg_face.get_suivant(it_face))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(face->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_faceid(face->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_SURFACE*>::ITERATEUR it_surface;
  for(MG_SURFACE* surface=map_mg_surface.get_premier(it_surface);surface!=NULL;surface=map_mg_surface.get_suivant(it_surface))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(surface->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_surfaceid(surface->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_BOUCLE*>::ITERATEUR it_boucle;
  for(MG_BOUCLE* boucle=map_mg_boucle.get_premier(it_boucle);boucle!=NULL;boucle=map_mg_boucle.get_suivant(it_boucle))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(boucle->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_boucleid(boucle->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_ARETE*>::ITERATEUR it_arete;
  for(MG_ARETE* arete=map_mg_arete.get_premier(it_arete);arete!=NULL;arete=map_mg_arete.get_suivant(it_arete))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(arete->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_areteid(arete->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_COURBE*>::ITERATEUR it_courbe;
  for(MG_COURBE* courbe=map_mg_courbe.get_premier(it_courbe);courbe!=NULL;courbe=map_mg_courbe.get_suivant(it_courbe))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(courbe->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_courbeid(courbe->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_SOMMET*>::ITERATEUR it_sommet;
  for(MG_SOMMET* sommet=map_mg_sommet.get_premier(it_sommet);sommet!=NULL;sommet=map_mg_sommet.get_suivant(it_sommet))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(sommet->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_sommetid(sommet->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }
  TPL_MAP_ENTITE<MG_POINT*>::ITERATEUR it_point;
  for(MG_POINT* point=map_mg_point.get_premier(it_point);point!=NULL;point=map_mg_point.get_suivant(it_point))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(point->get_id());
    if(f==m_map_nb_repetition.end()) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
    else
    {
      if(f->second==0)
      {
        m_map_nb_repetition.erase(f);
        m_mg_geometrie->supprimer_mg_pointid(point->get_id());
      }
      else if(f->second<0) std::cerr << "MG_CG_MODELE::supprimer_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme) --> ERREUR" << std::endl;
      else f->second--;
    }
  }  
}
 
void MG_CG_MODELE::mise_a_jout_lien_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme)
{
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_mg_element_topologique;
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*> map_mg_element_cotopologique;
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*> map_mg_element_geometrique;
  switch(mgcg_forme->get_type_forme())
  {
    case MG_CG_FORME::TYPE_FORME::MULTIPLE:
    {
      MG_CG_FORME_MULTIPLE* mgcg_forme_multiple = (MG_CG_FORME_MULTIPLE*)mgcg_forme;
      std::map<long,MG_ELEMENT_TOPOLOGIQUE*>::iterator it_topo;
      for(MG_ELEMENT_TOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_topologique(it_topo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_topologique(it_topo))
      {
        map_mg_element_topologique.ajouter(ele);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      std::map<long,MG_ELEMENT_COTOPOLOGIQUE*>::iterator it_cotopo;
      for(MG_ELEMENT_COTOPOLOGIQUE* ele=mgcg_forme_multiple->get_premier_mg_element_cotopologique(it_cotopo);ele!=NULL;ele=mgcg_forme_multiple->get_suivant_mg_element_cotopologique(it_cotopo))
      {
        map_mg_element_cotopologique.ajouter(ele);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(ele,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      break;
    }
    case MG_CG_FORME::TYPE_FORME::MULTI_VOLUME:
    {
      MG_CG_FORME_MULTI_VOLUME* mgcg_forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)mgcg_forme;
      std::map<long,MG_VOLUME*>::iterator it_volume;
      for(MG_VOLUME* volume=mgcg_forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=mgcg_forme_multi_volume->get_suivant_mg_volume(it_volume))
      {
        map_mg_element_topologique.ajouter(volume);
        OT_GEOMETRIE::get_map_mg_element_sous_jacent(volume,
                                                    &map_mg_element_topologique,
                                                    &map_mg_element_cotopologique,
                                                    &map_mg_element_geometrique);
      }
      break;
    }
    case MG_CG_FORME::TYPE_FORME::VOLUME:
    {
      MG_CG_FORME_VOLUME* mgcg_forme_volume = (MG_CG_FORME_VOLUME*)mgcg_forme;
      map_mg_element_topologique.ajouter(mgcg_forme_volume->get_mg_volume());
      OT_GEOMETRIE::get_map_mg_element_sous_jacent(mgcg_forme_volume->get_mg_volume(),
                                                  &map_mg_element_topologique,
                                                  &map_mg_element_cotopologique,
                                                  &map_mg_element_geometrique);
      break;
    }    
  }  
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_topo;
  for(MG_ELEMENT_TOPOLOGIQUE* ele=map_mg_element_topologique.get_premier(it_topo);ele!=NULL;ele=map_mg_element_topologique.get_suivant(it_topo))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(ele->get_id());
    if(f==m_map_nb_repetition.end())
    {
      m_map_nb_repetition.insert(std::pair<long,long>(ele->get_id(),0));
    }
    else
    {
      f->second+=1;
    }
  }
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*>::ITERATEUR it_cotopo;
  for(MG_ELEMENT_COTOPOLOGIQUE* ele=map_mg_element_cotopologique.get_premier(it_cotopo);ele!=NULL;ele=map_mg_element_cotopologique.get_suivant(it_cotopo))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(ele->get_id());
    if(f==m_map_nb_repetition.end())
    {
      m_map_nb_repetition.insert(std::pair<long,long>(ele->get_id(),0));
    }
    else
    {
      f->second+=1;
    }
  }
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*>::ITERATEUR it_geo;
  for(MG_ELEMENT_GEOMETRIQUE* ele=map_mg_element_geometrique.get_premier(it_geo);ele!=NULL;ele=map_mg_element_geometrique.get_suivant(it_geo))
  {
    std::map<long,long>::iterator f = m_map_nb_repetition.find(ele->get_id());
    if(f==m_map_nb_repetition.end())
    {
      m_map_nb_repetition.insert(std::pair<long,long>(ele->get_id(),0));
    }
    else
    {
      f->second+=1;
    }
  }
}
 
 
void MG_CG_MODELE::change_fusionner_entite_similaire(bool val)
{
  m_fusionner_entite_similaire=val;
}
 
bool MG_CG_MODELE::get_fusionner_entite_similaire(void)
{
  return m_fusionner_entite_similaire;
}
 
void MG_CG_MODELE::change_precision(double val)
{
  m_mg_geometrie->change_valeur_precision(val);
}
 
double MG_CG_MODELE::get_precision(void)
{
  return m_mg_geometrie->get_valeur_precision();
}
 
void MG_CG_MODELE::change_importer_triangulation(bool val)
{
  m_importer_triangulation=val;
}
 
bool MG_CG_MODELE::get_importer_triangulation(void)
{
  return m_importer_triangulation;
}
 
void MG_CG_MODELE::change_epsilon_triangulation(double val)
{
  m_epsilon_triangulation=val;
}
 
double MG_CG_MODELE::get_epsilon_triangulation(void)
{
  return m_epsilon_triangulation;
}
 
MG_IDENTIFICATEUR* MG_CG_MODELE::get_mg_identificateur(long int id)
{
  MG_IDENTIFICATEUR* mg_id=NULL;
  mg_id=get_mgcg_formeid(id);
  if(mg_id!=NULL) return mg_id;
  mg_id=get_mgcg_operateurid(id);
  if(mg_id!=NULL) return mg_id;
  mg_id=get_mgcg_assemblageid(id);
  if(mg_id!=NULL) return mg_id;
  mg_id=get_mgcg_groupe_formeid(id);
  if(mg_id!=NULL) return mg_id;
  return NULL;
}