mg_sous_geometrie.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_sous_geometrie.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:55 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mg_sous_geometrie.h"
#include "gestionversion.h"
 
MG_SOUS_GEOMETRIE::MG_SOUS_GEOMETRIE(MG_GEOMETRIE* mg_geometrie,
                                     char* type,
                                     const char* nom,
                                     double unite,
                                     double eps): MG_GEOMETRIE(type, nom, unite, eps),m_mg_geometrie(mg_geometrie)
{
  m_id_parent=0;
  fonction1=&mg_geometrie->get_occ_fonction();
}
 
MG_SOUS_GEOMETRIE::MG_SOUS_GEOMETRIE(MG_GEOMETRIE* mg_geometrie,
                                     char* type,
                                     long unsigned int num,
                                     const char* nom,
                                     double unite,
                                     double eps): MG_GEOMETRIE(type, num, nom, unite, eps),m_mg_geometrie(mg_geometrie)
{
  m_id_parent=0;
  fonction1=&mg_geometrie->get_occ_fonction();
}
 
MG_SOUS_GEOMETRIE::MG_SOUS_GEOMETRIE(MG_GEOMETRIE* mg_geometrie,
                                     long int id_parent,
                                     char* type,
                                     const char* nom,
                                     double unite,
                                     double eps): MG_GEOMETRIE(type, nom, unite, eps),m_mg_geometrie(mg_geometrie),m_id_parent(id_parent)
{
  fonction1=&mg_geometrie->get_occ_fonction();
}
 
MG_SOUS_GEOMETRIE::MG_SOUS_GEOMETRIE(MG_GEOMETRIE* mg_geometrie,
                                     long int id_parent,
                                     char* type,
                                     long unsigned int num,
                                     const char* nom,
                                     double unite,
                                     double eps): MG_GEOMETRIE(type, num, nom, unite, eps),m_mg_geometrie(mg_geometrie),m_id_parent(id_parent)
{
  fonction1=&mg_geometrie->get_occ_fonction();
}
 
void MG_SOUS_GEOMETRIE::change_id_parent(long int id_parent)
{
  m_id_parent=id_parent;
}
 
long int MG_SOUS_GEOMETRIE::get_id_parent(void)
{
  return m_id_parent;
}
 
MG_SOUS_GEOMETRIE::~MG_SOUS_GEOMETRIE(void)
{
}
 
void MG_SOUS_GEOMETRIE::retirer_tout(void)
{
  supprimer_tout_mg_volume();
  supprimer_tout_mg_coquille();
  supprimer_tout_mg_face();
  supprimer_tout_mg_boucle();
  supprimer_tout_mg_arete();
  supprimer_tout_mg_sommet();
  supprimer_tout_mg_point();
  supprimer_tout_mg_courbe();
  supprimer_tout_mg_surface();
  supprimer_tout_mg_visu_courbe();
  supprimer_tout_mg_poutre();
  supprimer_tout_mg_coque();
  supprimer_tout_mg_groupe_topologique();
  supprimer_tout_mg_geom_fonction();
}
 
 
MG_GEOMETRIE* MG_SOUS_GEOMETRIE::get_mg_geometrie(void)
{
  return m_mg_geometrie;
}
 
void MG_SOUS_GEOMETRIE::change_mg_geometrie(MG_GEOMETRIE* mg_geometrie)
{
  m_mg_geometrie=mg_geometrie;
}
 
int MG_SOUS_GEOMETRIE::inclure_mg_sous_geometrie(MG_SOUS_GEOMETRIE* mg_sous_geometrie)
{
  LISTE_MG_POINT::iterator it_point;
  LISTE_MG_COURBE::iterator it_courbe;
  LISTE_MG_SURFACE::iterator it_surface;
  LISTE_MG_SOMMET::iterator it_sommet;
  LISTE_MG_COSOMMET::iterator it_cosommet;
  LISTE_MG_ARETE::iterator it_arete;
  LISTE_MG_COARETE::iterator it_coarete;
  LISTE_MG_BOUCLE::iterator it_boucle;
  LISTE_MG_FACE::iterator it_face;
  LISTE_MG_COFACE::iterator it_coface;
  LISTE_MG_COQUILLE::iterator it_coquille;
  LISTE_MG_VOLUME::iterator it_volume;
  LISTE_MG_COQUE::iterator it_coque;
  LISTE_MG_POUTRE::iterator it_poutre;
  LISTE_MG_GROUPE_TOPOLOGIQUE::iterator it_groupe_topologique;
  LISTE_MG_GEOM_FONCTION::iterator it_geom_fonction;
  LISTE_MG_VISU_COURBE::iterator it_visu_courbe;
  
  for(MG_POINT*point=mg_sous_geometrie->get_premier_point(it_point);point!=NULL;point=mg_sous_geometrie->get_suivant_point(it_point))
  {
    lst_mg_point.insert(std::pair<long,MG_POINT*>(point->get_id(),point));
  }
  for(MG_COURBE*courbe=mg_sous_geometrie->get_premier_courbe(it_courbe);courbe!=NULL;courbe=mg_sous_geometrie->get_suivant_courbe(it_courbe))
  {
    lst_mg_courbe.insert(std::pair<long,MG_COURBE*>(courbe->get_id(),courbe));
  }
  for(MG_SURFACE*surface=mg_sous_geometrie->get_premier_surface(it_surface);surface!=NULL;surface=mg_sous_geometrie->get_suivant_surface(it_surface))
  {
    lst_mg_surface.insert(std::pair<long,MG_SURFACE*>(surface->get_id(),surface));
  }
  for(MG_SOMMET*sommet=mg_sous_geometrie->get_premier_sommet(it_sommet);sommet!=NULL;sommet=mg_sous_geometrie->get_suivant_sommet(it_sommet))
  {
    lst_mg_sommet.insert(std::pair<long,MG_SOMMET*>(sommet->get_id(),sommet));
  }
  for(MG_COSOMMET*cosommet=mg_sous_geometrie->get_premier_cosommet(it_cosommet);cosommet!=NULL;cosommet=mg_sous_geometrie->get_suivant_cosommet(it_cosommet))
  {
    lst_mg_cosommet.insert(std::pair<long,MG_COSOMMET*>(cosommet->get_id(),cosommet));
  }
  for(MG_ARETE*arete=mg_sous_geometrie->get_premier_arete(it_arete);arete!=NULL;arete=mg_sous_geometrie->get_suivant_arete(it_arete))
  {
    lst_mg_arete.insert(std::pair<long,MG_ARETE*>(arete->get_id(),arete));
  }
  for(MG_COARETE*coarete=mg_sous_geometrie->get_premier_coarete(it_coarete);coarete!=NULL;coarete=mg_sous_geometrie->get_suivant_coarete(it_coarete))
  {
    lst_mg_coarete.insert(std::pair<long,MG_COARETE*>(coarete->get_id(),coarete));
  }
  for(MG_BOUCLE*boucle=mg_sous_geometrie->get_premier_boucle(it_boucle);boucle!=NULL;boucle=mg_sous_geometrie->get_suivant_boucle(it_boucle))
  {
    lst_mg_boucle.insert(std::pair<long,MG_BOUCLE*>(boucle->get_id(),boucle));
  }
  for(MG_FACE*face=mg_sous_geometrie->get_premier_face(it_face);face!=NULL;face=mg_sous_geometrie->get_suivant_face(it_face))
  {
    lst_mg_face.insert(std::pair<long,MG_FACE*>(face->get_id(),face));
  }
  for(MG_COFACE*coface=mg_sous_geometrie->get_premier_coface(it_coface);coface!=NULL;coface=mg_sous_geometrie->get_suivant_coface(it_coface))
  {
    lst_mg_coface.insert(std::pair<long,MG_COFACE*>(coface->get_id(),coface));
  }
  for(MG_COQUILLE*coquille=mg_sous_geometrie->get_premier_coquille(it_coquille);coquille!=NULL;coquille=mg_sous_geometrie->get_suivant_coquille(it_coquille))
  {
    lst_mg_coquille.insert(std::pair<long,MG_COQUILLE*>(coquille->get_id(),coquille));
  }
  for(MG_VOLUME*volume=mg_sous_geometrie->get_premier_volume(it_volume);volume!=NULL;volume=mg_sous_geometrie->get_suivant_volume(it_volume))
  {
    lst_mg_volume.insert(std::pair<long,MG_VOLUME*>(volume->get_id(),volume));
  }
  for(MG_COQUE*coque=mg_sous_geometrie->get_premier_coque(it_coque);coque!=NULL;coque=mg_sous_geometrie->get_suivant_coque(it_coque))
  {
    lst_mg_coque.insert(std::pair<long,MG_COQUE*>(coque->get_id(),coque));
  }
  for(MG_POUTRE*poutre=mg_sous_geometrie->get_premier_poutre(it_poutre);poutre!=NULL;poutre=mg_sous_geometrie->get_suivant_poutre(it_poutre))
  {
    lst_mg_poutre.insert(std::pair<long,MG_POUTRE*>(poutre->get_id(),poutre));
  }
  for(MG_GROUPE_TOPOLOGIQUE*groupe_topologique=mg_sous_geometrie->get_premier_groupe_topologique(it_groupe_topologique);groupe_topologique!=NULL;groupe_topologique=mg_sous_geometrie->get_suivant_groupe_topologique(it_groupe_topologique))
  {
    lst_mg_groupe_topologique.insert(std::pair<long,MG_GROUPE_TOPOLOGIQUE*>(groupe_topologique->get_id(),groupe_topologique));
  }
  for(MG_GEOM_FONCTION*geom_fonction=mg_sous_geometrie->get_premier_geom_fonction(it_geom_fonction);geom_fonction!=NULL;geom_fonction=mg_sous_geometrie->get_suivant_geom_fonction(it_geom_fonction))
  {
    lst_mg_geom_fonction.insert(std::pair<long,MG_GEOM_FONCTION*>(geom_fonction->get_id(),geom_fonction));
  }
  for(MG_VISU_COURBE*visu_courbe=mg_sous_geometrie->get_premier_visu_courbe(it_visu_courbe);visu_courbe!=NULL;visu_courbe=mg_sous_geometrie->get_suivant_visu_courbe(it_visu_courbe))
  {
    lst_mg_visu_courbe.insert(std::pair<long,MG_VISU_COURBE*>(visu_courbe->get_id(),visu_courbe));
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::exclure_mg_sous_geometrie(MG_SOUS_GEOMETRIE* mg_sous_geometrie)
{
  LISTE_MG_POINT::iterator it_point;
  LISTE_MG_COURBE::iterator it_courbe;
  LISTE_MG_SURFACE::iterator it_surface;
  LISTE_MG_SOMMET::iterator it_sommet;
  LISTE_MG_COSOMMET::iterator it_cosommet;
  LISTE_MG_ARETE::iterator it_arete;
  LISTE_MG_COARETE::iterator it_coarete;
  LISTE_MG_BOUCLE::iterator it_boucle;
  LISTE_MG_FACE::iterator it_face;
  LISTE_MG_COFACE::iterator it_coface;
  LISTE_MG_COQUILLE::iterator it_coquille;
  LISTE_MG_VOLUME::iterator it_volume;
  LISTE_MG_COQUE::iterator it_coque;
  LISTE_MG_POUTRE::iterator it_poutre;
  LISTE_MG_GROUPE_TOPOLOGIQUE::iterator it_groupe_topologique;
  LISTE_MG_GEOM_FONCTION::iterator it_geom_fonction;
  LISTE_MG_VISU_COURBE::iterator it_visu_courbe;
  
  for(MG_POINT*point=mg_sous_geometrie->get_premier_point(it_point);point!=NULL;point=mg_sous_geometrie->get_suivant_point(it_point))
  {
    supprimer_mg_pointid(point->get_id());
  }
  for(MG_COURBE*courbe=mg_sous_geometrie->get_premier_courbe(it_courbe);courbe!=NULL;courbe=mg_sous_geometrie->get_suivant_courbe(it_courbe))
  {
    supprimer_mg_courbeid(courbe->get_id());
  }  
  for(MG_SURFACE*surface=mg_sous_geometrie->get_premier_surface(it_surface);surface!=NULL;surface=mg_sous_geometrie->get_suivant_surface(it_surface))
  {
    supprimer_mg_surfaceid(surface->get_id());
  }
  for(MG_SOMMET*sommet=mg_sous_geometrie->get_premier_sommet(it_sommet);sommet!=NULL;sommet=mg_sous_geometrie->get_suivant_sommet(it_sommet))
  {
    supprimer_mg_sommetid(sommet->get_id());
  }
  for(MG_COSOMMET*cosommet=mg_sous_geometrie->get_premier_cosommet(it_cosommet);cosommet!=NULL;cosommet=mg_sous_geometrie->get_suivant_cosommet(it_cosommet))
  {
    supprimer_mg_cosommet(cosommet);
  }
  for(MG_ARETE*arete=mg_sous_geometrie->get_premier_arete(it_arete);arete!=NULL;arete=mg_sous_geometrie->get_suivant_arete(it_arete))
  {
    supprimer_mg_areteid(arete->get_id());
  }
  for(MG_COARETE*coarete=mg_sous_geometrie->get_premier_coarete(it_coarete);coarete!=NULL;coarete=mg_sous_geometrie->get_suivant_coarete(it_coarete))
  {
    supprimer_mg_coarete(coarete);
  }
  for(MG_BOUCLE*boucle=mg_sous_geometrie->get_premier_boucle(it_boucle);boucle!=NULL;boucle=mg_sous_geometrie->get_suivant_boucle(it_boucle))
  {
    supprimer_mg_boucleid(boucle->get_id());
  }
  for(MG_FACE*face=mg_sous_geometrie->get_premier_face(it_face);face!=NULL;face=mg_sous_geometrie->get_suivant_face(it_face))
  {
    supprimer_mg_faceid(face->get_id());
  }
  for(MG_COFACE*coface=mg_sous_geometrie->get_premier_coface(it_coface);coface!=NULL;coface=mg_sous_geometrie->get_suivant_coface(it_coface))
  {
    supprimer_mg_coface(coface);
  }
  for(MG_COQUILLE*coquille=mg_sous_geometrie->get_premier_coquille(it_coquille);coquille!=NULL;coquille=mg_sous_geometrie->get_suivant_coquille(it_coquille))
  {
    supprimer_mg_coquilleid(coquille->get_id());
  }
  for(MG_VOLUME*volume=mg_sous_geometrie->get_premier_volume(it_volume);volume!=NULL;volume=mg_sous_geometrie->get_suivant_volume(it_volume))
  {
    supprimer_mg_volumeid(volume->get_id());
  }
  for(MG_COQUE*coque=mg_sous_geometrie->get_premier_coque(it_coque);coque!=NULL;coque=mg_sous_geometrie->get_suivant_coque(it_coque))
  {
    supprimer_mg_coqueid(coque->get_id());
  }
  for(MG_POUTRE*poutre=mg_sous_geometrie->get_premier_poutre(it_poutre);poutre!=NULL;poutre=mg_sous_geometrie->get_suivant_poutre(it_poutre))
  {
    supprimer_mg_poutreid(poutre->get_id());
  }
  for(MG_GROUPE_TOPOLOGIQUE*groupe_topologique=mg_sous_geometrie->get_premier_groupe_topologique(it_groupe_topologique);groupe_topologique!=NULL;groupe_topologique=mg_sous_geometrie->get_suivant_groupe_topologique(it_groupe_topologique))
  {
    supprimer_mg_groupe_topologiqueid(groupe_topologique->get_id());
  }
  for(MG_GEOM_FONCTION*geom_fonction=mg_sous_geometrie->get_premier_geom_fonction(it_geom_fonction);geom_fonction!=NULL;geom_fonction=mg_sous_geometrie->get_suivant_geom_fonction(it_geom_fonction))
  {
    supprimer_mg_geom_fonctionid(geom_fonction->get_id());
  }
  for(MG_VISU_COURBE*visu_courbe=mg_sous_geometrie->get_premier_visu_courbe(it_visu_courbe);visu_courbe!=NULL;visu_courbe=mg_sous_geometrie->get_suivant_visu_courbe(it_visu_courbe))
  {
    supprimer_mg_visu_courbeid(visu_courbe->get_id());
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_point(MG_POINT *mgpt)
{
  std::pair<LISTE_MG_POINT::iterator,bool> p = lst_mg_point.insert(std::pair<long,MG_POINT*>(mgpt->get_id(),mgpt));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_pointid(unsigned long num)
{
  LISTE_MG_POINT::iterator it = lst_mg_point.find(num);
  if(it!=lst_mg_point.end())
  {
    lst_mg_point.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_point(unsigned int num)
{
  if(num<lst_mg_point.size())
  {
    LISTE_MG_POINT::iterator j=lst_mg_point.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_point.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_point(void)
{
  lst_mg_point.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_courbe(MG_COURBE *mgcrb)
{
  std::pair<LISTE_MG_COURBE::iterator,bool> p = lst_mg_courbe.insert(std::pair<long,MG_COURBE*>(mgcrb->get_id(),mgcrb));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_courbeid(unsigned long num)
{
  LISTE_MG_COURBE::iterator it = lst_mg_courbe.find(num);
  if(it!=lst_mg_courbe.end())
  {
    lst_mg_courbe.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_courbe(unsigned int num)
{
  if(num<lst_mg_courbe.size())
  {
    LISTE_MG_COURBE::iterator j=lst_mg_courbe.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_courbe.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_courbe(void)
{
  lst_mg_courbe.clear();
}
 
 
int MG_SOUS_GEOMETRIE::ajouter_mg_surface(MG_SURFACE *mgsrf)
{
  std::pair<LISTE_MG_SURFACE::iterator,bool> p = lst_mg_surface.insert(std::pair<long,MG_SURFACE*>(mgsrf->get_id(),mgsrf));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_surfaceid(unsigned long num)
{
  LISTE_MG_SURFACE::iterator it = lst_mg_surface.find(num);
  if(it!=lst_mg_surface.end())
  {
    lst_mg_surface.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_surface(unsigned int num)
{
  if(num<lst_mg_surface.size())
  {
    LISTE_MG_SURFACE::iterator j=lst_mg_surface.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_surface.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_surface(void)
{
  lst_mg_surface.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_sommet(MG_SOMMET *mgsom)
{
  std::pair<LISTE_MG_SOMMET::iterator,bool> p = lst_mg_sommet.insert(std::pair<long,MG_SOMMET*>(mgsom->get_id(),mgsom));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_sommetid(unsigned long num)
{
  LISTE_MG_SOMMET::iterator it = lst_mg_sommet.find(num);
  if(it!=lst_mg_sommet.end())
  {
    lst_mg_sommet.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_sommet(unsigned int num)
{
  if(num<lst_mg_sommet.size())
  {
    LISTE_MG_SOMMET::iterator j=lst_mg_sommet.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_sommet.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_sommet(void)
{
  lst_mg_sommet.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_arete(MG_ARETE *mgarete)
{
  std::pair<LISTE_MG_ARETE::iterator,bool> p = lst_mg_arete.insert(std::pair<long,MG_ARETE*>(mgarete->get_id(),mgarete));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_areteid(unsigned long num)
{
  LISTE_MG_ARETE::iterator it = lst_mg_arete.find(num);
  if(it!=lst_mg_arete.end())
  {
    lst_mg_arete.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_arete(unsigned int num)
{
  if(num<lst_mg_arete.size())
  {
    LISTE_MG_ARETE::iterator j=lst_mg_arete.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_arete.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_arete(void)
{
  lst_mg_arete.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_boucle(MG_BOUCLE* mgboucle)
{
  std::pair<LISTE_MG_BOUCLE::iterator,bool> p = lst_mg_boucle.insert(std::pair<long,MG_BOUCLE*>(mgboucle->get_id(),mgboucle));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_boucleid(unsigned long num)
{
  LISTE_MG_BOUCLE::iterator it = lst_mg_boucle.find(num);
  if(it!=lst_mg_boucle.end())
  {
    lst_mg_boucle.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_boucle(unsigned int num)
{
  if(num<lst_mg_boucle.size())
  {
    LISTE_MG_BOUCLE::iterator j=lst_mg_boucle.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_boucle.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_boucle(void)
{
  lst_mg_boucle.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_face(MG_FACE *mgface)
{
  std::pair<LISTE_MG_FACE::iterator,bool> p = lst_mg_face.insert(std::pair<long,MG_FACE*>(mgface->get_id(),mgface));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_faceid(unsigned long num)
{
  LISTE_MG_FACE::iterator it = lst_mg_face.find(num);
  if(it!=lst_mg_face.end())
  {
    lst_mg_face.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_face(unsigned int num)
{
  if(num<lst_mg_face.size())
  {
    LISTE_MG_FACE::iterator j=lst_mg_face.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_face.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_face(void)
{
  lst_mg_face.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_coquille(MG_COQUILLE* mgcoq)
{
  std::pair<LISTE_MG_COQUILLE::iterator,bool> p = lst_mg_coquille.insert(std::pair<long,MG_COQUILLE*>(mgcoq->get_id(),mgcoq));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coquilleid(unsigned long num)
{
  LISTE_MG_COQUILLE::iterator it = lst_mg_coquille.find(num);
  if(it!=lst_mg_coquille.end())
  {
    lst_mg_coquille.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coquille(unsigned int num)
{
  if(num<lst_mg_coquille.size())
  {
    LISTE_MG_COQUILLE::iterator j=lst_mg_coquille.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_coquille.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_coquille(void)
{
  lst_mg_coquille.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_volume(MG_VOLUME *mgvol)
{
  std::pair<LISTE_MG_VOLUME::iterator,bool> p = lst_mg_volume.insert(std::pair<long,MG_VOLUME*>(mgvol->get_id(),mgvol));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_volumeid(unsigned long num)
{
  LISTE_MG_VOLUME::iterator it = lst_mg_volume.find(num);
  if(it!=lst_mg_volume.end())
  {
    lst_mg_volume.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_volume(unsigned int num)
{
  if(num<lst_mg_volume.size())
  {
    LISTE_MG_VOLUME::iterator j=lst_mg_volume.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_volume.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_volume(void)
{
  lst_mg_volume.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_coque(MG_COQUE *mgcoque)
{
  std::pair<LISTE_MG_COQUE::iterator,bool> p = lst_mg_coque.insert(std::pair<long,MG_COQUE*>(mgcoque->get_id(),mgcoque));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coqueid(unsigned long num)
{
  LISTE_MG_COQUE::iterator it = lst_mg_coque.find(num);
  if(it!=lst_mg_coque.end())
  {
    lst_mg_coque.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coque(unsigned int num)
{
  if(num<lst_mg_coque.size())
  {
    LISTE_MG_COQUE::iterator j=lst_mg_coque.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_coque.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_coque(void)
{
  lst_mg_coque.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_poutre(MG_POUTRE *mgpoutre)
{
  std::pair<LISTE_MG_POUTRE::iterator,bool> p = lst_mg_poutre.insert(std::pair<long,MG_POUTRE*>(mgpoutre->get_id(),mgpoutre));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_poutreid(unsigned long num)
{
  LISTE_MG_POUTRE::iterator it = lst_mg_poutre.find(num);
  if(it!=lst_mg_poutre.end())
  {
    lst_mg_poutre.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_poutre(unsigned int num)
{
  if(num<lst_mg_poutre.size())
  {
    LISTE_MG_POUTRE::iterator j=lst_mg_poutre.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_poutre.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_poutre(void)
{
  lst_mg_poutre.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_groupe_topologique(MG_GROUPE_TOPOLOGIQUE *mggroupe_topologique)
{
  std::pair<LISTE_MG_GROUPE_TOPOLOGIQUE::iterator,bool> p = lst_mg_groupe_topologique.insert(std::pair<long,MG_GROUPE_TOPOLOGIQUE*>(mggroupe_topologique->get_id(),mggroupe_topologique));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_groupe_topologiqueid(unsigned long num)
{
  LISTE_MG_GROUPE_TOPOLOGIQUE::iterator it = lst_mg_groupe_topologique.find(num);
  if(it!=lst_mg_groupe_topologique.end())
  {
    lst_mg_groupe_topologique.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_groupe_topologique(unsigned int num)
{
  if(num<lst_mg_groupe_topologique.size())
  {
    LISTE_MG_GROUPE_TOPOLOGIQUE::iterator j=lst_mg_groupe_topologique.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_groupe_topologique.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_groupe_topologique(void)
{
  lst_mg_groupe_topologique.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_geom_fonction(MG_GEOM_FONCTION *mggeofon)
{
  std::pair<LISTE_MG_GEOM_FONCTION::iterator,bool> p = lst_mg_geom_fonction.insert(std::pair<long,MG_GEOM_FONCTION*>(mggeofon->get_id(),mggeofon));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_geom_fonctionid(unsigned long num)
{
  LISTE_MG_GEOM_FONCTION::iterator it = lst_mg_geom_fonction.find(num);
  if(it!=lst_mg_geom_fonction.end())
  {
    lst_mg_geom_fonction.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_geom_fonction(unsigned int num)
{
  if(num<lst_mg_geom_fonction.size())
  {
    LISTE_MG_GEOM_FONCTION::iterator j=lst_mg_geom_fonction.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_geom_fonction.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_geom_fonction(void)
{
  lst_mg_geom_fonction.clear();
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_cosommet(MG_COSOMMET* mgcosom)
{
  std::pair<LISTE_MG_COSOMMET::iterator,bool> p = lst_mg_cosommet.insert(std::pair<long,MG_COSOMMET*>(mgcosom->get_id(),mgcosom));
  if(!p.second) return FAIL;
  return OK;
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_cosommet(MG_COSOMMET* mgcosom)
{
  LISTE_MG_COSOMMET::iterator it = lst_mg_cosommet.find(mgcosom->get_id());
  if(it!=lst_mg_cosommet.end())
  {
    lst_mg_cosommet.erase(it);
    return OK;
  }
  else return FAIL;
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_cosommetid(long int num)
{
  return supprimer_mg_cosommet(get_mg_cosommetid(num));
}
 
 
int MG_SOUS_GEOMETRIE::ajouter_mg_coarete(MG_COARETE* mgcoarete)
{
  std::pair<LISTE_MG_COARETE::iterator,bool> p = lst_mg_coarete.insert(std::pair<long,MG_COARETE*>(mgcoarete->get_id(),mgcoarete));
  if(!p.second) return FAIL;
  return OK;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coarete(MG_COARETE* mgcoarete)
{
  LISTE_MG_COARETE::iterator it = lst_mg_coarete.find(mgcoarete->get_id());
  if(it!=lst_mg_coarete.end())
  {
    lst_mg_coarete.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_coareteid(long int num)
{
  return supprimer_mg_coarete(get_mg_coareteid(num));
}
 
 
int MG_SOUS_GEOMETRIE::ajouter_mg_coface(MG_COFACE* mgcoface)
{
  std::pair<LISTE_MG_COFACE::iterator,bool> p = lst_mg_coface.insert(std::pair<long,MG_COFACE*>(mgcoface->get_id(),mgcoface));
  if(!p.second) return FAIL;
  return OK;
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_coface(MG_COFACE* mgcoface)
{
  LISTE_MG_COFACE::iterator it = lst_mg_coface.find(mgcoface->get_id());
  if(it!=lst_mg_coface.end())
  {
    lst_mg_coface.erase(it);
    return OK;
  }
  else return FAIL;
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_cofaceid(long int num)
{
  return supprimer_mg_coface(get_mg_cofaceid(num));
}
 
 
int MG_SOUS_GEOMETRIE::ajouter_mg_visu_courbe(MG_VISU_COURBE *mgvcrb)
{
  std::pair<LISTE_MG_VISU_COURBE::iterator,bool> p = lst_mg_visu_courbe.insert(std::pair<long,MG_VISU_COURBE*>(mgvcrb->get_id(),mgvcrb));
  if(!p.second) return FAIL;
  return OK;
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_visu_courbeid(unsigned long num)
{
  LISTE_MG_VISU_COURBE::iterator it = lst_mg_visu_courbe.find(num);
  if(it!=lst_mg_visu_courbe.end())
  {
    lst_mg_visu_courbe.erase(it);
    return OK;
  }
  else return FAIL;
}
int MG_SOUS_GEOMETRIE::supprimer_mg_visu_courbe(unsigned int num)
{
  if(num<lst_mg_visu_courbe.size())
  {
    LISTE_MG_VISU_COURBE::iterator j=lst_mg_visu_courbe.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_visu_courbe.erase(j);
    return OK;
  }
  else return FAIL;
}
void MG_SOUS_GEOMETRIE::supprimer_tout_mg_visu_courbe(void)
{
  lst_mg_visu_courbe.clear();
}
 
 
int MG_SOUS_GEOMETRIE::ajouter_mg_element_topologique(MG_ELEMENT_TOPOLOGIQUE* mg_element_topologique)
{
  switch(mg_element_topologique->get_type())
  {
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::SOMMET:
      ajouter_mg_sommet((MG_SOMMET*)mg_element_topologique); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::ARETE:
      ajouter_mg_arete((MG_ARETE*)mg_element_topologique); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::FACE:
      ajouter_mg_face((MG_FACE*)mg_element_topologique); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::COQUE:
      ajouter_mg_coque((MG_COQUE*)mg_element_topologique); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::POUTRE:
      ajouter_mg_poutre((MG_POUTRE*)mg_element_topologique); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::VOLUME:
      ajouter_mg_volume((MG_VOLUME*)mg_element_topologique); break;
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_element_cotopologique(MG_ELEMENT_COTOPOLOGIQUE* mg_element_cotopologique)
{
  switch(mg_element_cotopologique->get_type())
  {
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COSOMMET:
      ajouter_mg_cosommet((MG_COSOMMET*)mg_element_cotopologique); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COARETE:
      ajouter_mg_coarete((MG_COARETE*)mg_element_cotopologique); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::BOUCLE:
      ajouter_mg_boucle((MG_BOUCLE*)mg_element_cotopologique); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COFACE:
      ajouter_mg_coface((MG_COFACE*)mg_element_cotopologique); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COQUILLE:
      ajouter_mg_coquille((MG_COQUILLE*)mg_element_cotopologique); break;
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::ajouter_mg_element_geometrique(MG_ELEMENT_GEOMETRIQUE* mg_element_geometrique)
{
  switch(mg_element_geometrique->get_type())
  {
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::POINT:
      ajouter_mg_point((MG_POINT*)mg_element_geometrique); break;
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::COURBE:
      ajouter_mg_courbe((MG_COURBE*)mg_element_geometrique); break;
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::SURFACE:
      ajouter_mg_surface((MG_SURFACE*)mg_element_geometrique); break;
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_element_topologique(MG_ELEMENT_TOPOLOGIQUE* mg_element_topologique)
{
  switch(mg_element_topologique->get_type())
  {
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::SOMMET:
      supprimer_mg_sommetid(mg_element_topologique->get_id()); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::ARETE:
      supprimer_mg_areteid(mg_element_topologique->get_id()); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::FACE:
      supprimer_mg_faceid(mg_element_topologique->get_id()); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::COQUE:
      supprimer_mg_coqueid(mg_element_topologique->get_id()); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::POUTRE:
      supprimer_mg_poutreid(mg_element_topologique->get_id()); break;
    case MG_ELEMENT_TOPOLOGIQUE::TYPE_ELEMENT_TOPOLOGIQUE::VOLUME:
      supprimer_mg_volumeid(mg_element_topologique->get_id()); break;
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_element_cotopologique(MG_ELEMENT_COTOPOLOGIQUE* mg_element_cotopologique)
{
  switch(mg_element_cotopologique->get_type())
  {
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COSOMMET:
      supprimer_mg_cosommetid(mg_element_cotopologique->get_id()); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COARETE:
      supprimer_mg_coareteid(mg_element_cotopologique->get_id()); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::BOUCLE:
      supprimer_mg_boucleid(mg_element_cotopologique->get_id()); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COFACE:
      supprimer_mg_cofaceid(mg_element_cotopologique->get_id()); break;
    case MG_ELEMENT_COTOPOLOGIQUE::TYPE_ELEMENT_COTOPOLOGIQUE::COQUILLE:
      supprimer_mg_coquilleid(mg_element_cotopologique->get_id()); break;
  }
return 0;    
}
 
int MG_SOUS_GEOMETRIE::supprimer_mg_element_geometrique(MG_ELEMENT_GEOMETRIQUE* mg_element_geometrique)
{
  switch(mg_element_geometrique->get_type())
  {
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::POINT:
      supprimer_mg_pointid(mg_element_geometrique->get_id()); break;
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::COURBE:
      supprimer_mg_courbeid(mg_element_geometrique->get_id()); break;
    case MG_ELEMENT_GEOMETRIQUE::TYPE_ELEMENT_GEOMETRIQUE::SURFACE:
      supprimer_mg_surfaceid(mg_element_geometrique->get_id()); break;
  }
return 0;    
}
 
void MG_SOUS_GEOMETRIE::enregistrer(std::ostream& o, double version)
{
  o << "%" << get_id() 
    << "=MG_SOUS_GEOMETRIE("    
    << "$" << m_mg_geometrie->get_id()
    << ",$" << m_id_parent
    << "," << type_geo
    << "," << nom_du_fichier
    << "," << precision
    << "," << valeur_unite
    << ");" << std::endl;
}
 
void MG_SOUS_GEOMETRIE::get_fichier_dependant(std::vector< std::string >& liste_fichier)
{
 
}