geometrie/src/mg_geometrie.cpp

//------------------------------------------------------------
//------------------------------------------------------------
//  MAGiC
//  Jean Christophe Cuilli�e et Vincent FRANCOIS
//  D�artement de G�ie M�anique - UQTR
//------------------------------------------------------------
//  Le projet MAGIC est un projet de recherche du d�artement
//  de g�ie m�anique de l'Universit�du Qu�ec �
//  Trois Rivi�es
//  Les librairies ne peuvent �re utilis�s sans l'accord
//  des auteurs (contact : francois@uqtr.ca)
//------------------------------------------------------------
//------------------------------------------------------------
//
//       mg_geometrie.cpp
//
//------------------------------------------------------------
//------------------------------------------------------------
//  COPYRIGHT 2000
//  Version du 02/03/2006 �11H22
//------------------------------------------------------------
//------------------------------------------------------------


#include "gestionversion.h"
#include <iostream>
#include <string.h>


#include "mg_geometrie.h"
#include "mg_gestionnaire.h"
#include "mg_sommet_noeud.h"
#include "occ_fonction.h"
#include "occ_fonction_v2015.h"
#include "occ_fonction_v2017.h"
#include "ot_chaine.h"


MG_GEOMETRIE::MG_GEOMETRIE(char *type,const char *nom,double unite,double eps):MG_IDENTIFICATEUR(),gest_materiau(""),valeur_unite(unite),precision(eps)
{
ini(type,(char*)nom);
}

void MG_GEOMETRIE::ini(char *type,char *nom)
{
  geometrie_construction=false;
  fonction1=NULL;
    nom_du_fichier=new char[strlen(nom)+1];
    strcpy(nom_du_fichier,nom);
    strcpy(type_geo,type);
    
    #ifdef BREP_SAT
    if (strcmp(type_geo,"ACIS")==0)
      {
      get_gest_sat().change_nom(nom_du_fichier);
      get_gest_sat().lire();
      }
    #endif
    
    #ifdef BREP_STEP
    if (strcmp(type_geo,"STEP")==0)
      {
      get_gest_step().change_nom(nom_du_fichier);
      get_gest_step().lire();
      }
    #endif

    #ifdef BREP_OCC
    if ((strcmp(type_geo,"STEPOCC")==0)||(strcmp(type_geo,"OCC")==0)||((strcmp(type_geo,"OCCV2015")==0))||((strcmp(type_geo,"OCCV2017")==0)))
    {
    if (strcmp(type_geo,"OCC")==0) fonction1=new OCC_FONCTION;
    #ifdef ALL_OCC
    else if(strcmp(type_geo,"OCCV2017")==0) 
    {
      fonction1=new OCC_FONCTION_V2017;
      return;
    }
    #endif
    else fonction1=new OCC_FONCTION_V2015;
    char path2[500];
    strcpy(path2,nom_du_fichier);
    if (strcmp(type_geo,"STEPOCC")==0)
    {        
        fonction1->OuvrirFichierStep(nom_du_fichier);
        char *p=strchr(path2,'.')+1;
        p[0]='b';
        p[1]='r';
        p[2]='e';
        p[3]='p';
        p[4]=0;
        fonction1->Sauvegarder(path2);
        strcpy(nom_du_fichier,path2);
        strcpy(type_geo,"OCCV2015");
    }
    else fonction1->OuvrirFichier(nom_du_fichier);
    }
    #endif  
}

MG_GEOMETRIE::MG_GEOMETRIE(char *type,unsigned long num,const char *nom,double unite,double eps):MG_IDENTIFICATEUR(num),valeur_unite(unite),precision(eps)
{
ini(type,(char*)nom);
}


MG_GEOMETRIE::~MG_GEOMETRIE()
{
    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();
#ifdef BREP_OCC
    if ((strcmp(type_geo,"STEPOCC")==0)||(strcmp(type_geo,"OCC")==0)||((strcmp(type_geo,"OCCV2015")==0))||((strcmp(type_geo,"OCCV2017")==0)))
      delete fonction1;
#endif

}


void MG_GEOMETRIE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
{
    gest=mggest;
}

// ENTITE MG_POINT

int MG_GEOMETRIE::ajouter_mg_point(MG_POINT *mgpt)
{
    gest->recherche_bonid(*mgpt);
    MG_IDENTIFICATEUR *id=mgpt;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_POINT*> tmp(mgpt->get_id(),mgpt);
    lst_mg_point.insert(tmp);
    return OK;
}


MG_POINT* MG_GEOMETRIE::get_mg_pointid(unsigned long num)
{
    LISTE_MG_POINT::iterator i=lst_mg_point.find(num);
    if (i==lst_mg_point.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_POINT* MG_GEOMETRIE::get_mg_point(unsigned int num)
{
    if (!(num<lst_mg_point.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_POINT::iterator i=lst_mg_point.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_point(void)
{
    return lst_mg_point.size();
}


int MG_GEOMETRIE::supprimer_mg_pointid(unsigned long num)
{
    MG_POINT* mgpt=get_mg_pointid(num);
    if (mgpt==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgpt;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_POINT::iterator j=lst_mg_point.find(num);
    lst_mg_point.erase(j);
    delete mgpt;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_point(unsigned int num)
{
    MG_POINT* mgpt=get_mg_point(num);
    if (mgpt==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgpt;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_POINT::iterator j=lst_mg_point.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_point.erase(j);
    delete mgpt;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_point(void)
{
    while (get_nb_mg_point()!=0)
    {
        LISTE_MG_POINT::iterator j=lst_mg_point.begin();
        MG_POINT* mgpt=(*j).second;
        MG_IDENTIFICATEUR* id=mgpt;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_point.erase(j);
        delete mgpt;
    }
}

MG_POINT* MG_GEOMETRIE::get_premier_point(LISTE_MG_POINT::iterator &it)
{
    it = lst_mg_point.begin();
    if (it == lst_mg_point.end())
        return NULL;
    return it->second ;
}

MG_POINT* MG_GEOMETRIE::get_suivant_point(LISTE_MG_POINT::iterator &it)
{
    it++;
    if (it==lst_mg_point.end())
        return NULL;
    return it->second;
}


// ENTITE MG_COURBE

int MG_GEOMETRIE::ajouter_mg_courbe(MG_COURBE *mgcrb)
{
    gest->recherche_bonid(*mgcrb);
    MG_IDENTIFICATEUR *id=mgcrb;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }
    std::pair<const unsigned long,MG_COURBE*> tmp(mgcrb->get_id(),mgcrb);
    lst_mg_courbe.insert(tmp);
    return OK;
}


MG_COURBE* MG_GEOMETRIE::get_mg_courbeid(unsigned long num)
{
    LISTE_MG_COURBE::iterator i=lst_mg_courbe.find(num);
    if (i==lst_mg_courbe.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_COURBE* MG_GEOMETRIE::get_mg_courbe(unsigned int num)
{
    if (!(num<lst_mg_courbe.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_COURBE::iterator i=lst_mg_courbe.begin();

    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_courbe(void)
{
    return lst_mg_courbe.size();
}


int MG_GEOMETRIE::supprimer_mg_courbeid(unsigned long num)
{
    MG_COURBE* mgcrb=get_mg_courbeid(num);
    if (mgcrb==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcrb;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COURBE::iterator j=lst_mg_courbe.find(num);
    lst_mg_courbe.erase(j);
    delete mgcrb;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_courbe(unsigned int num)
{
    MG_COURBE* mgcrb=get_mg_courbe(num);
    if (mgcrb==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcrb;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COURBE::iterator j=lst_mg_courbe.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_courbe.erase(j);
    delete mgcrb;
    return OK;
}

void MG_GEOMETRIE::supprimer_tout_mg_courbe(void)
{
    while (get_nb_mg_courbe()!=0)
    {
        LISTE_MG_COURBE::iterator j=lst_mg_courbe.begin();
        MG_COURBE* mgcrb=(*j).second;
        MG_IDENTIFICATEUR* id=mgcrb;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_courbe.erase(j);
        delete mgcrb;
    }
}

MG_COURBE* MG_GEOMETRIE::get_premier_courbe(LISTE_MG_COURBE::iterator &it)
{
    it = lst_mg_courbe.begin();
    if (it == lst_mg_courbe.end())
        return NULL;
    return it->second ;
}

MG_COURBE* MG_GEOMETRIE::get_suivant_courbe(LISTE_MG_COURBE::iterator &it)
{
    it++;
    if (it==lst_mg_courbe.end())
        return NULL;
    return it->second;
}


// ENTITE MG_SURFACE

int MG_GEOMETRIE::ajouter_mg_surface(MG_SURFACE *mgsrf)
{
    gest->recherche_bonid(*mgsrf);
    MG_IDENTIFICATEUR *id=mgsrf;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_SURFACE*> tmp(mgsrf->get_id(),mgsrf);
    lst_mg_surface.insert(tmp);
    return OK;
}


MG_SURFACE* MG_GEOMETRIE::get_mg_surfaceid(unsigned long num)
{
    LISTE_MG_SURFACE::iterator i=lst_mg_surface.find(num);
    if (i==lst_mg_surface.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_SURFACE* MG_GEOMETRIE::get_mg_surface(unsigned int num)
{
    if (!(num<lst_mg_surface.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_SURFACE::iterator i=lst_mg_surface.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_surface(void)
{
    return lst_mg_surface.size();
}


int MG_GEOMETRIE::supprimer_mg_surfaceid(unsigned long num)
{
    MG_SURFACE* mgsrf=get_mg_surfaceid(num);
    if (mgsrf==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsrf;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SURFACE::iterator j=lst_mg_surface.find(num);
    lst_mg_surface.erase(j);
    delete mgsrf;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_surface(unsigned int num)
{
    MG_SURFACE* mgsrf=get_mg_surface(num);
    if (mgsrf==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsrf;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SURFACE::iterator j=lst_mg_surface.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_surface.erase(j);
    delete mgsrf;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_surface(void)
{
    while (get_nb_mg_surface()!=0)
    {
        LISTE_MG_SURFACE::iterator j=lst_mg_surface.begin();
        MG_SURFACE* mgsrf=(*j).second;
        MG_IDENTIFICATEUR* id=mgsrf;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_surface.erase(j);
        delete mgsrf;
    }
}

MG_SURFACE* MG_GEOMETRIE::get_premier_surface(LISTE_MG_SURFACE::iterator &it)
{
    it = lst_mg_surface.begin();
    if (it == lst_mg_surface.end())
        return NULL;
    return it->second ;
}

MG_SURFACE* MG_GEOMETRIE::get_suivant_surface(LISTE_MG_SURFACE::iterator &it)
{
    it++;
    if (it==lst_mg_surface.end())
        return NULL;
    return it->second;
}


// ENTITE MG_SOMMET
MG_SOMMET_NOEUD* MG_GEOMETRIE::ajouter_mg_sommet_noeud(MG_NOEUD *noeud)
{
MG_SOMMET_NOEUD* somno=new MG_SOMMET_NOEUD(noeud);
gest->recherche_bonid(*somno);
MG_IDENTIFICATEUR *id=somno;
std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
if (!p.second)
    {
      delete somno;
      return NULL;
    }
std::pair<const unsigned long,MG_SOMMET*> tmp(somno->get_id(),somno);
lst_mg_sommet.insert(tmp);
return somno;
}
  
int MG_GEOMETRIE::ajouter_mg_sommet(MG_SOMMET *mgsom)
{
    gest->recherche_bonid(*mgsom);
    MG_IDENTIFICATEUR *id=mgsom;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_SOMMET*> tmp(mgsom->get_id(),mgsom);
    lst_mg_sommet.insert(tmp);
    return OK;
}


MG_SOMMET* MG_GEOMETRIE::get_mg_sommetid(unsigned long num)
{
    LISTE_MG_SOMMET::iterator i=lst_mg_sommet.find(num);
    if (i==lst_mg_sommet.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_SOMMET* MG_GEOMETRIE::get_mg_sommetid(std::string id)
{
    LISTE_MG_SOMMET::iterator i=lst_mg_sommet.begin();
    int nb=lst_mg_sommet.size();
    for (int j=0;j<nb;j++)
    {
        MG_SOMMET* sommet=(*i).second;
        std::string idori=sommet->get_idoriginal();
        if (idori==id) return sommet;
        i++;
    }
    return NULL;
}


MG_SOMMET* MG_GEOMETRIE::get_mg_sommet(unsigned int num)
{
    if (!(num<lst_mg_sommet.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_SOMMET::iterator i=lst_mg_sommet.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_sommet(void)
{
    return lst_mg_sommet.size();
}


int MG_GEOMETRIE::supprimer_mg_sommetid(unsigned long num)
{
    MG_SOMMET* mgsom=get_mg_sommetid(num);
    if (mgsom==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgsom->get_nb_mg_cosommet()!=0)
    {
//       afficheur << ERRCOSOMMET << mgsom->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsom;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOMMET::iterator j=lst_mg_sommet.find(num);
    lst_mg_sommet.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_SOMMET((OCC_SOMMET*)mgsom);
#endif
    delete mgsom;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_sommet(unsigned int num)
{
    MG_SOMMET* mgsom=get_mg_sommet(num);
    if (mgsom==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgsom->get_nb_mg_cosommet()!=0)
    {
//      afficheur << ERRCOSOMMET << mgsom->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgsom;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_SOMMET::iterator j=lst_mg_sommet.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_sommet.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_SOMMET((OCC_SOMMET*)mgsom);
#endif
    delete mgsom;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_sommet(void)
{
    while (get_nb_mg_sommet()!=0)
    {
        LISTE_MG_SOMMET::iterator j=lst_mg_sommet.begin();
        MG_SOMMET* mgsom=(*j).second;
        MG_IDENTIFICATEUR* id=mgsom;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_sommet.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_SOMMET((OCC_SOMMET*)mgsom);
#endif
        delete mgsom;
    }
}

MG_SOMMET* MG_GEOMETRIE::get_premier_sommet(LISTE_MG_SOMMET::iterator &it)
{
    it = lst_mg_sommet.begin();
    if (it == lst_mg_sommet.end())
        return NULL;
    return it->second ;
}

MG_SOMMET* MG_GEOMETRIE::get_suivant_sommet(LISTE_MG_SOMMET::iterator &it)
{
    it++;
    if (it==lst_mg_sommet.end())
        return NULL;
    return it->second;
}


// ENTITE MG_COSOMMET


int MG_GEOMETRIE::ajouter_mg_cosommet(MG_COSOMMET* mgcosom)
{
    gest->recherche_bonid(*mgcosom);
    MG_IDENTIFICATEUR *id=mgcosom;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
      return FAIL;
    }

    std::pair<const unsigned long,MG_COSOMMET*> tmp(mgcosom->get_id(),mgcosom);
    lst_mg_cosommet.insert(tmp);
    return OK;
}

MG_COSOMMET* MG_GEOMETRIE::ajouter_mg_cosommet(MG_ARETE *mgarete,MG_SOMMET *mgsom)
{
    MG_COSOMMET* mgcosom=new MG_COSOMMET(mgsom,mgarete,precision);
    gest->recherche_bonid(*mgcosom);
    MG_IDENTIFICATEUR *id=mgcosom;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcosom;
        return NULL;
    }

    std::pair<const unsigned long,MG_COSOMMET*> tmp(mgcosom->get_id(),mgcosom);
    lst_mg_cosommet.insert(tmp);
    mgsom->ajouter_mg_cosommet(mgcosom);
    return mgcosom;
}

MG_COSOMMET* MG_GEOMETRIE::ajouter_mg_cosommet(unsigned long num,MG_ARETE *mgarete,MG_SOMMET *mgsom)
{
    MG_COSOMMET* mgcosom=new MG_COSOMMET(num,mgsom,mgarete,precision);
    MG_IDENTIFICATEUR *id=mgcosom;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcosom;
        return NULL;
    }

    std::pair<const unsigned long,MG_COSOMMET*> tmp(mgcosom->get_id(),mgcosom);
    lst_mg_cosommet.insert(tmp);
    mgsom->ajouter_mg_cosommet(mgcosom);
    return mgcosom;
}

int MG_GEOMETRIE::supprimer_mg_cosommet(MG_COSOMMET* mgcosom)
{
    if (mgcosom==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcosom;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COSOMMET::iterator j=lst_mg_cosommet.find(mgcosom->get_id());
    lst_mg_cosommet.erase(j);
    mgcosom->get_sommet()->supprimer_mg_cosommet(mgcosom);
    delete mgcosom;
    return OK;
}

int MG_GEOMETRIE::supprimer_mg_cosommetid(long int num)
{
    MG_COSOMMET* mgcosommet=get_mg_cosommetid(num);
    if (mgcosommet==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcosommet;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COSOMMET::iterator j=lst_mg_cosommet.find(num);
    lst_mg_cosommet.erase(j);
    mgcosommet->get_sommet()->supprimer_mg_cosommet(mgcosommet);
    delete mgcosommet;
    return OK;
}


unsigned int MG_GEOMETRIE::get_nb_cosommet(void)
{
  return lst_mg_cosommet.size();
}

MG_COSOMMET* MG_GEOMETRIE::get_premier_cosommet(LISTE_MG_COSOMMET::iterator& it)
{
  it=lst_mg_cosommet.begin();
  if(it==lst_mg_cosommet.end()) return NULL;
  return it->second;
}

MG_COSOMMET* MG_GEOMETRIE::get_suivant_cosommet(LISTE_MG_COSOMMET::iterator& it)
{
  it++;
  if(it==lst_mg_cosommet.end()) return NULL;
  return it->second;
}

MG_COSOMMET* MG_GEOMETRIE::get_mg_cosommetid(long num)
{
  LISTE_MG_COSOMMET::iterator i=lst_mg_cosommet.find(num);
  if (i==lst_mg_cosommet.end())
  {
      return NULL;
  }
  return ((*i).second);
}


// ENTITE MG_ARETE

int MG_GEOMETRIE::ajouter_mg_arete(MG_ARETE *mgarete)
{
    gest->recherche_bonid(*mgarete);
    MG_IDENTIFICATEUR *id=mgarete;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_ARETE*> tmp(mgarete->get_id(),mgarete);
    lst_mg_arete.insert(tmp);
    return OK;
}


MG_ARETE* MG_GEOMETRIE::get_mg_areteid(unsigned long num)
{
    LISTE_MG_ARETE::iterator i=lst_mg_arete.find(num);
    if (i==lst_mg_arete.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_ARETE* MG_GEOMETRIE::get_mg_areteid(std::string id)
{
    LISTE_MG_ARETE::iterator i=lst_mg_arete.begin();
    int nb=lst_mg_arete.size();
    for (int j=0;j<nb;j++)
    {
        MG_ARETE* arete=(*i).second;
        std::string idori=arete->get_idoriginal();
        if (idori==id) return arete;
        i++;
    }
    return NULL;
}


MG_ARETE* MG_GEOMETRIE::get_mg_arete(unsigned int num)
{
    if (!(num<lst_mg_arete.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_ARETE::iterator i=lst_mg_arete.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_arete(void)
{
    return lst_mg_arete.size();
}


int MG_GEOMETRIE::supprimer_mg_areteid(unsigned long num)
{
    MG_ARETE* mgarete=get_mg_areteid(num);
    if (mgarete==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgarete->get_nb_mg_coarete()!=0)
    {
//      afficheur << ERRCOARETE << mgarete->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgarete;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ARETE::iterator j=lst_mg_arete.find(num);
    lst_mg_arete.erase(j);
    MG_COSOMMET* cosom1=mgarete->get_cosommet1();
    MG_COSOMMET* cosom2=mgarete->get_cosommet2();
    cosom1->get_sommet()->supprimer_mg_cosommet(cosom1);
    cosom2->get_sommet()->supprimer_mg_cosommet(cosom2);
    supprimer_mg_cosommet(cosom1);
    supprimer_mg_cosommet(cosom2);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_ARETE((OCC_ARETE*)mgarete);
#endif
    delete mgarete;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_arete(unsigned int num)
{
    MG_ARETE* mgarete=get_mg_arete(num);
    if (mgarete==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgarete->get_nb_mg_coarete()!=0)
    {
//      afficheur << ERRCOARETE << mgarete->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgarete;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ARETE::iterator j=lst_mg_arete.find(num);
    lst_mg_arete.erase(j);
    MG_COSOMMET* cosom1=mgarete->get_cosommet1();
    MG_COSOMMET* cosom2=mgarete->get_cosommet2();
    cosom1->get_sommet()->supprimer_mg_cosommet(cosom1);
    cosom2->get_sommet()->supprimer_mg_cosommet(cosom2);
    supprimer_mg_cosommet(cosom1);
    supprimer_mg_cosommet(cosom2);
    
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_ARETE((OCC_ARETE*)mgarete);
#endif
    delete mgarete;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_arete(void)
{
    while (get_nb_mg_arete()!=0)
    {
        LISTE_MG_ARETE::iterator j=lst_mg_arete.begin();
        MG_ARETE* mgarete=(*j).second;
        MG_IDENTIFICATEUR* id=mgarete;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_arete.erase(j);
        if (!mgarete->est_une_arete_element())
          {
            
          MG_COSOMMET* cosom1=mgarete->get_cosommet1();
          MG_COSOMMET* cosom2=mgarete->get_cosommet2();
          cosom1->get_sommet()->supprimer_mg_cosommet(cosom1);
          cosom2->get_sommet()->supprimer_mg_cosommet(cosom2);
          supprimer_mg_cosommet(cosom1);
          supprimer_mg_cosommet(cosom2);  
#ifdef ALL_OCC
          if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_ARETE((OCC_ARETE*)mgarete);
#endif
          delete mgarete;
          }
    }
}

MG_ARETE* MG_GEOMETRIE::get_premier_arete(LISTE_MG_ARETE::iterator &it)
{
    it = lst_mg_arete.begin();
    if (it == lst_mg_arete.end())
        return NULL;
    return it->second ;
}

MG_ARETE* MG_GEOMETRIE::get_suivant_arete(LISTE_MG_ARETE::iterator &it)
{
    it++;
    if (it==lst_mg_arete.end())
        return NULL;
    return it->second;
}


// ENTITE MG_COARETE

int MG_GEOMETRIE::ajouter_mg_coarete(MG_COARETE* mgcoarete)
{
    gest->recherche_bonid(*mgcoarete);
    MG_IDENTIFICATEUR *id=mgcoarete;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }
    std::pair<const unsigned long,MG_COARETE*> tmp(mgcoarete->get_id(),mgcoarete);
    lst_mg_coarete.insert(tmp);
    return OK;
}


MG_COARETE* MG_GEOMETRIE::ajouter_mg_coarete(MG_ARETE *mgarete,MG_BOUCLE *mgboucle,int sens)
{
    MG_COARETE* mgcoarete=new MG_COARETE(mgarete,mgboucle,sens);
    gest->recherche_bonid(*mgcoarete);
    MG_IDENTIFICATEUR *id=mgcoarete;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcoarete;
        return NULL;
    }

    std::pair<const unsigned long,MG_COARETE*> tmp(mgcoarete->get_id(),mgcoarete);
    lst_mg_coarete.insert(tmp);
    mgarete->ajouter_mg_coarete(mgcoarete);
    return mgcoarete;
}


MG_COARETE* MG_GEOMETRIE::ajouter_mg_coarete(unsigned long num,MG_ARETE *mgarete,MG_BOUCLE *mgboucle,int sens)
{
    MG_COARETE* mgcoarete=new MG_COARETE(num,mgarete,mgboucle,sens);
    MG_IDENTIFICATEUR *id=mgcoarete;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcoarete;
        return NULL;
    }

    std::pair<const unsigned long,MG_COARETE*> tmp(mgcoarete->get_id(),mgcoarete);
    lst_mg_coarete.insert(tmp);
    mgarete->ajouter_mg_coarete(mgcoarete);
    return mgcoarete;
}

int MG_GEOMETRIE::supprimer_mg_coarete(MG_COARETE* mgcoarete)
{
    if (mgcoarete==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoarete;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COARETE::iterator j=lst_mg_coarete.find(mgcoarete->get_id());
    lst_mg_coarete.erase(j);
    mgcoarete->get_arete()->supprimer_mg_coarete(mgcoarete);
    delete mgcoarete;
    return OK;
}

int MG_GEOMETRIE::supprimer_mg_coareteid(long int num)
{
    MG_COARETE* mgcoarete=get_mg_coareteid(num);
    if (mgcoarete==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoarete;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COARETE::iterator j=lst_mg_coarete.find(num);
    lst_mg_coarete.erase(j);
    mgcoarete->get_arete()->supprimer_mg_coarete(mgcoarete);
    delete mgcoarete;
    return OK;
}


unsigned int MG_GEOMETRIE::get_nb_coarete(void)
{
  return lst_mg_coarete.size();
}

MG_COARETE* MG_GEOMETRIE::get_premier_coarete(LISTE_MG_COARETE::iterator& it)
{
  it=lst_mg_coarete.begin();
  if(it==lst_mg_coarete.end()) return NULL;
  return it->second;
}

MG_COARETE* MG_GEOMETRIE::get_suivant_coarete(LISTE_MG_COARETE::iterator& it)
{
  it++;
  if(it==lst_mg_coarete.end()) return NULL;
  return it->second;
}

MG_COARETE* MG_GEOMETRIE::get_mg_coareteid(long num)
{
  LISTE_MG_COARETE::iterator i=lst_mg_coarete.find(num);
  if (i==lst_mg_coarete.end())
  {
      return NULL;
  }
  return ((*i).second);
}


// ENTITE MG_BOUCLE

int MG_GEOMETRIE::ajouter_mg_boucle(MG_BOUCLE* mgboucle)
{
    gest->recherche_bonid(*mgboucle);
    MG_IDENTIFICATEUR *id=mgboucle;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }
    std::pair<const unsigned long,MG_BOUCLE*> tmp(mgboucle->get_id(),mgboucle);
    std::pair<LISTE_MG_BOUCLE::iterator,bool> p2 =  lst_mg_boucle.insert(tmp);
    return OK;
}

int MG_GEOMETRIE::ajouter_mg_boucle(MG_BOUCLE *mgboucle,MG_POUTRE* mgpoutre)
{
    gest->recherche_bonid(*mgboucle);
    MG_IDENTIFICATEUR *id=mgboucle;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_BOUCLE*> tmp(mgboucle->get_id(),mgboucle);
    std::pair<LISTE_MG_BOUCLE::iterator,bool> p2 =  lst_mg_boucle.insert(tmp);
    if(p2.second) mgpoutre->ajouter_mg_boucle(mgboucle); 
    return OK;
}

int MG_GEOMETRIE::ajouter_mg_boucle(MG_BOUCLE *mgboucle,MG_FACE* mgface)
{
    gest->recherche_bonid(*mgboucle);
    MG_IDENTIFICATEUR *id=mgboucle;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_BOUCLE*> tmp(mgboucle->get_id(),mgboucle);
    std::pair<LISTE_MG_BOUCLE::iterator,bool> p2 =  lst_mg_boucle.insert(tmp);
    if(p2.second) mgface->ajouter_mg_boucle(mgboucle);    
    return OK;
}


MG_BOUCLE* MG_GEOMETRIE::get_mg_boucleid(unsigned long num)
{
    LISTE_MG_BOUCLE::iterator i=lst_mg_boucle.find(num);
    if (i==lst_mg_boucle.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_BOUCLE* MG_GEOMETRIE::get_mg_boucle(unsigned int num)
{
    if (!(num<lst_mg_boucle.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_BOUCLE::iterator i=lst_mg_boucle.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_boucle(void)
{
    return lst_mg_boucle.size();
}


int MG_GEOMETRIE::supprimer_mg_boucleid(unsigned long num)
{
    MG_BOUCLE* mgboucle=get_mg_boucleid(num);
    if (mgboucle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgboucle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_BOUCLE::iterator j=lst_mg_boucle.find(num);
    lst_mg_boucle.erase(j);
    for (int k=0;k<mgboucle->get_nb_mg_coarete();k++)
    {
        MG_COARETE* coarete=mgboucle->get_mg_coarete(k);
        supprimer_mg_coarete(coarete);
    }
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_BOUCLE((OCC_BOUCLE*)mgboucle);
#endif
    delete mgboucle;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_boucle(unsigned int num)
{
    MG_BOUCLE* mgboucle=get_mg_boucle(num);
    if (mgboucle==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgboucle;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_BOUCLE::iterator j=lst_mg_boucle.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_boucle.erase(j);
    for (int k=0;k<mgboucle->get_nb_mg_coarete();k++)
    {
        MG_COARETE* coarete=mgboucle->get_mg_coarete(k);
        supprimer_mg_coarete(coarete);
    }
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_BOUCLE((OCC_BOUCLE*)mgboucle);
#endif
    delete mgboucle;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_boucle(void)
{
    while (get_nb_mg_boucle()!=0)
    {
        LISTE_MG_BOUCLE::iterator j=lst_mg_boucle.begin();
        MG_BOUCLE* mgboucle=(*j).second;
        MG_IDENTIFICATEUR* id=mgboucle;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_boucle.erase(j);
        for (int k=0;k<mgboucle->get_nb_mg_coarete();k++)
        {
            MG_COARETE* coarete=mgboucle->get_mg_coarete(k);
            supprimer_mg_coarete(coarete);
        }
#ifdef ALL_OCC
        if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_BOUCLE((OCC_BOUCLE*)mgboucle);
#endif
        delete mgboucle;
    }
}

MG_BOUCLE* MG_GEOMETRIE::get_premier_boucle(LISTE_MG_BOUCLE::iterator &it)
{
    it = lst_mg_boucle.begin();
    if (it == lst_mg_boucle.end())
        return NULL;
    return it->second ;
}

MG_BOUCLE* MG_GEOMETRIE::get_suivant_boucle(LISTE_MG_BOUCLE::iterator &it)
{
    it++;
    if (it==lst_mg_boucle.end())
        return NULL;
    return it->second;
}


// ENTITE MG_FACE

int MG_GEOMETRIE::ajouter_mg_face(MG_FACE *mgface)
{
    gest->recherche_bonid(*mgface);
    MG_IDENTIFICATEUR *id=mgface;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_FACE*> tmp(mgface->get_id(),mgface);
    lst_mg_face.insert(tmp);
    return OK;
}


MG_FACE* MG_GEOMETRIE::get_mg_faceid(unsigned long num)
{
    LISTE_MG_FACE::iterator i=lst_mg_face.find(num);
    if (i==lst_mg_face.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_FACE* MG_GEOMETRIE::get_mg_faceid(std::string id)
{
    LISTE_MG_FACE::iterator i=lst_mg_face.begin();
    int nb=lst_mg_face.size();
    for (int j=0;j<nb;j++)
    {
        MG_FACE* face=(*i).second;
        std::string idori=face->get_idoriginal();
        if (idori==id) return face;
        i++;
    }
    return NULL;
}


MG_FACE* MG_GEOMETRIE::get_mg_face(unsigned int num)
{
    if (!(num<lst_mg_face.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_FACE::iterator i=lst_mg_face.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_face(void)
{
    return lst_mg_face.size();
}


int MG_GEOMETRIE::supprimer_mg_faceid(unsigned long num)
{
    MG_FACE* mgface=get_mg_faceid(num);
    if (mgface==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgface->get_nb_mg_coface()!=0)
    {
//      afficheur << ERRCOFACE << mgface->get_id() << enderr;
        std::cerr << "ERRCOFACE !!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!!" << std::endl;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgface;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_FACE::iterator j=lst_mg_face.find(num);
    lst_mg_face.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_FACE((OCC_FACE*)mgface);
#endif
    delete mgface;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_face(unsigned int num)
{
    MG_FACE* mgface=get_mg_face(num);
    if (mgface==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    if (mgface->get_nb_mg_coface()!=0)
    {
//      afficheur << ERRCOFACE << mgface->get_id() << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgface;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_FACE::iterator j=lst_mg_face.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_face.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_FACE((OCC_FACE*)mgface);
#endif
    delete mgface;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_face(void)
{

    while (get_nb_mg_face()!=0)
    {
        LISTE_MG_FACE::iterator j=lst_mg_face.begin();
        MG_FACE* mgface=(*j).second;
        MG_IDENTIFICATEUR* id=mgface;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_face.erase(j);
#ifdef ALL_OCC
        if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_FACE((OCC_FACE*)mgface);
#endif
        delete mgface;
    }
}

MG_FACE* MG_GEOMETRIE::get_premier_face(LISTE_MG_FACE::iterator &it)
{
    it = lst_mg_face.begin();
    if (it == lst_mg_face.end())
        return NULL;
    return it->second ;
}

MG_FACE* MG_GEOMETRIE::get_suivant_face(LISTE_MG_FACE::iterator &it)
{
    it++;
    if (it==lst_mg_face.end())
        return NULL;
    return it->second;
}


// ENTITE MG_COFACE

int MG_GEOMETRIE::ajouter_mg_coface(MG_COFACE* mgcoface)
{
    gest->recherche_bonid(*mgcoface);
    MG_IDENTIFICATEUR *id=mgcoface;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }

    std::pair<const unsigned long,MG_COFACE*> tmp(mgcoface->get_id(),mgcoface);
    lst_mg_coface.insert(tmp);
    return OK;
}

MG_COFACE* MG_GEOMETRIE::ajouter_mg_coface(MG_FACE *mgface,MG_COQUILLE *mgcoq,int sens)
{
    MG_COFACE* mgcoface=new MG_COFACE(mgface,mgcoq,sens);
    gest->recherche_bonid(*mgcoface);
    MG_IDENTIFICATEUR *id=mgcoface;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcoface;
        return NULL;
    }

    std::pair<const unsigned long,MG_COFACE*> tmp(mgcoface->get_id(),mgcoface);
    lst_mg_coface.insert(tmp);
    mgface->ajouter_mg_coface(mgcoface);
    return mgcoface;
}


MG_COFACE* MG_GEOMETRIE::ajouter_mg_coface(unsigned long num,MG_FACE *mgface,MG_COQUILLE *mgcoq,int sens)
{
    MG_COFACE* mgcoface=new MG_COFACE(num,mgface,mgcoq,sens);
    MG_IDENTIFICATEUR *id=mgcoface;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        delete mgcoface;
        return NULL;
    }

    std::pair<const unsigned long,MG_COFACE*> tmp(mgcoface->get_id(),mgcoface);
    lst_mg_coface.insert(tmp);
    mgface->ajouter_mg_coface(mgcoface);
    return mgcoface;
}

int MG_GEOMETRIE::supprimer_mg_coface(MG_COFACE* mgcoface)
{
    if (mgcoface==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoface;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COFACE::iterator j=lst_mg_coface.find(mgcoface->get_id());
    lst_mg_coface.erase(j);
    mgcoface->get_face()->supprimer_mg_coface(mgcoface);
    delete mgcoface;
    return OK;
}

int MG_GEOMETRIE::supprimer_mg_cofaceid(long int num)
{
    MG_COFACE* mgcoface=get_mg_cofaceid(num);
    if (mgcoface==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoface;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COFACE::iterator j=lst_mg_coface.find(num);
    lst_mg_coface.erase(j);
    mgcoface->get_face()->supprimer_mg_coface(mgcoface);
    delete mgcoface;
    return OK;
}


unsigned int MG_GEOMETRIE::get_nb_coface(void)
{
  return lst_mg_coface.size();
}

MG_COFACE* MG_GEOMETRIE::get_premier_coface(LISTE_MG_COFACE::iterator& it)
{
  it=lst_mg_coface.begin();
  if(it==lst_mg_coface.end()) return NULL;
  return it->second;
}

MG_COFACE* MG_GEOMETRIE::get_suivant_coface(LISTE_MG_COFACE::iterator& it)
{
  it++;
  if(it==lst_mg_coface.end()) return NULL;
  return it->second;
}

MG_COFACE* MG_GEOMETRIE::get_mg_cofaceid(long num)
{
  LISTE_MG_COFACE::iterator i=lst_mg_coface.find(num);
  if (i==lst_mg_coface.end())
  {
      return NULL;
  }
  return ((*i).second);
}


// ENTITE MG_COQUILLE

int MG_GEOMETRIE::ajouter_mg_coquille(MG_COQUILLE* mgcoq)
{
  gest->recherche_bonid(*mgcoq);
  MG_IDENTIFICATEUR *id=mgcoq;
  std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
  if (!p.second)
  {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
      return FAIL;
  }
  std::pair<const unsigned long,MG_COQUILLE*> tmp(mgcoq->get_id(),mgcoq);
  std::pair<LISTE_MG_COQUILLE::iterator,bool> p2 = lst_mg_coquille.insert(tmp);
  return OK;
}

int MG_GEOMETRIE::ajouter_mg_coquille(MG_COQUILLE *mgcoq,MG_COQUE *mgcoque)
{
    gest->recherche_bonid(*mgcoq);
    MG_IDENTIFICATEUR *id=mgcoq;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_COQUILLE*> tmp(mgcoq->get_id(),mgcoq);
    std::pair<LISTE_MG_COQUILLE::iterator,bool> p2 = lst_mg_coquille.insert(tmp);
    if(p2.second) mgcoque->ajouter_mg_coquille(mgcoq);
    return OK;
}


int MG_GEOMETRIE::ajouter_mg_coquille(MG_COQUILLE *mgcoquille,MG_VOLUME* mgvolume)
{
    gest->recherche_bonid(*mgcoquille);
    MG_IDENTIFICATEUR *id=mgcoquille;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_COQUILLE*> tmp(mgcoquille->get_id(),mgcoquille);
    std::pair<LISTE_MG_COQUILLE::iterator,bool> p2 = lst_mg_coquille.insert(tmp);
    if(p2.second) mgvolume->ajouter_mg_coquille(mgcoquille);
    return OK;
}


MG_COQUILLE* MG_GEOMETRIE::get_mg_coquilleid(unsigned long num)
{
    LISTE_MG_COQUILLE::iterator i=lst_mg_coquille.find(num);
    if (i==lst_mg_coquille.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_COQUILLE* MG_GEOMETRIE::get_mg_coquille(unsigned int num)
{
    if (!(num<lst_mg_coquille.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_COQUILLE::iterator i=lst_mg_coquille.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_COQUILLE* MG_GEOMETRIE::get_premier_coquille(LISTE_MG_COQUILLE::iterator &it)
{
    it = lst_mg_coquille.begin();
    if (it == lst_mg_coquille.end())
        return NULL;
    return it->second ;
}

MG_COQUILLE* MG_GEOMETRIE::get_suivant_coquille(LISTE_MG_COQUILLE::iterator &it)
{
    it++;
    if (it==lst_mg_coquille.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_coquille(void)
{
    return lst_mg_coquille.size();
}


int MG_GEOMETRIE::supprimer_mg_coquilleid(unsigned long num)
{
    MG_COQUILLE* mgcoquille=get_mg_coquilleid(num);
    if (mgcoquille==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoquille;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COQUILLE::iterator j=lst_mg_coquille.find(num);
    lst_mg_coquille.erase(j);
    for (int k=0;k<mgcoquille->get_nb_mg_coface();k++)
    {
        MG_COFACE* coface=mgcoquille->get_mg_coface(k);
        supprimer_mg_coface(coface);
    }
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_COQUILLE((OCC_COQUILLE*)mgcoquille);
#endif
    delete mgcoquille;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_coquille(unsigned int num)
{
    MG_COQUILLE* mgcoquille=get_mg_coquille(num);
    if (mgcoquille==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoquille;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COQUILLE::iterator j=lst_mg_coquille.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_coquille.erase(j);
    for (int k=0;k<mgcoquille->get_nb_mg_coface();k++)
    {
        MG_COFACE* coface=mgcoquille->get_mg_coface(k);
        supprimer_mg_coface(coface);
    }
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_COQUILLE((OCC_COQUILLE*)mgcoquille);
#endif
    delete mgcoquille;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_coquille(void)
{
    while (get_nb_mg_coquille()!=0)
    {
        LISTE_MG_COQUILLE::iterator j=lst_mg_coquille.begin();
        MG_COQUILLE* mgcoquille=(*j).second;
        MG_IDENTIFICATEUR* id=mgcoquille;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_coquille.erase(j);
        for (int k=0;k<mgcoquille->get_nb_mg_coface();k++)
        {
            MG_COFACE* coface=mgcoquille->get_mg_coface(k);
            supprimer_mg_coface(coface);
        }
#ifdef ALL_OCC
        if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_COQUILLE((OCC_COQUILLE*)mgcoquille);
#endif
        delete mgcoquille;
    }
}


// ENTITE MG_VOLUME

int MG_GEOMETRIE::ajouter_mg_volume(MG_VOLUME *mgvolume)
{
    gest->recherche_bonid(*mgvolume);
    MG_IDENTIFICATEUR *id=mgvolume;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_VOLUME*> tmp(mgvolume->get_id(),mgvolume);
    lst_mg_volume.insert(tmp);
    return OK;
}


MG_VOLUME* MG_GEOMETRIE::get_mg_volumeid(unsigned long num)
{
    LISTE_MG_VOLUME::iterator i=lst_mg_volume.find(num);
    if (i==lst_mg_volume.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_VOLUME* MG_GEOMETRIE::get_mg_volumeid(std::string id)
{
    LISTE_MG_VOLUME::iterator i=lst_mg_volume.begin();
    int nb=lst_mg_volume.size();
    for (int j=0;j<nb;j++)
    {
        MG_VOLUME* volume=(*i).second;
        std::string idori=volume->get_idoriginal();
        if (idori==id) return volume;
        i++;
    }
    return NULL;
}


MG_VOLUME* MG_GEOMETRIE::get_mg_volume(unsigned int num)
{
    if (!(num<lst_mg_volume.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_VOLUME::iterator i=lst_mg_volume.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}

MG_VOLUME* MG_GEOMETRIE::get_premier_volume(LISTE_MG_VOLUME::iterator &it)
{
    it = lst_mg_volume.begin();
    if (it == lst_mg_volume.end())
        return NULL;
    return it->second ;
}

MG_VOLUME* MG_GEOMETRIE::get_suivant_volume(LISTE_MG_VOLUME::iterator &it)
{
    it++;
    if (it==lst_mg_volume.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_volume(void)
{
    return lst_mg_volume.size();
}


int MG_GEOMETRIE::supprimer_mg_volumeid(unsigned long num)
{
    MG_VOLUME* mgvolume=get_mg_volumeid(num);
    if (mgvolume==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgvolume;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_VOLUME::iterator j=lst_mg_volume.find(num);
    lst_mg_volume.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_VOLUME((OCC_VOLUME*)mgvolume);
#endif
    delete mgvolume;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_volume(unsigned int num)
{
    MG_VOLUME* mgvolume=get_mg_volume(num);
    if (mgvolume==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgvolume;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_VOLUME::iterator j=lst_mg_volume.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_volume.erase(j);
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_VOLUME((OCC_VOLUME*)mgvolume);
#endif
    delete mgvolume;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_volume(void)
{
    while (get_nb_mg_volume()!=0)
    {
        LISTE_MG_VOLUME::iterator j=lst_mg_volume.begin();
        MG_VOLUME* mgvolume=(*j).second;
        MG_IDENTIFICATEUR* id=mgvolume;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_volume.erase(j);
#ifdef ALL_OCC
        if(strcmp(type_geo,"OCCV2017")==0) ((OCC_FONCTION_V2017*)fonction1)->supprimer_OCC_VOLUME((OCC_VOLUME*)mgvolume);
#endif
        delete mgvolume;
    }
}

// ENTITE MG_COQUE

int MG_GEOMETRIE::ajouter_mg_coque(MG_COQUE *mgcoque)
{
    gest->recherche_bonid(*mgcoque);
    MG_IDENTIFICATEUR *id=mgcoque;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_COQUE*> tmp(mgcoque->get_id(),mgcoque);
    lst_mg_coque.insert(tmp);
    return OK;
}


MG_COQUE* MG_GEOMETRIE::get_mg_coqueid(unsigned long num)
{
    LISTE_MG_COQUE::iterator i=lst_mg_coque.find(num);
    if (i==lst_mg_coque.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_COQUE* MG_GEOMETRIE::get_mg_coqueid(std::string id)
{
    LISTE_MG_COQUE::iterator i=lst_mg_coque.begin();
    int nb=lst_mg_coque.size();
    for (int j=0;j<nb;j++)
    {
        MG_COQUE* coque=(*i).second;
        std::string idori=coque->get_idoriginal();
        if (idori==id) return coque;
        i++;
    }
    return NULL;
}


MG_COQUE* MG_GEOMETRIE::get_mg_coque(unsigned int num)
{
    if (!(num<lst_mg_coque.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_COQUE::iterator i=lst_mg_coque.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_COQUE* MG_GEOMETRIE::get_premier_coque(LISTE_MG_COQUE::iterator &it)
{
    it = lst_mg_coque.begin();
    if (it == lst_mg_coque.end())
        return NULL;
    return it->second ;
}

MG_COQUE* MG_GEOMETRIE::get_suivant_coque(LISTE_MG_COQUE::iterator &it)
{
    it++;
    if (it==lst_mg_coque.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_coque(void)
{
    return lst_mg_coque.size();
}


int MG_GEOMETRIE::supprimer_mg_coqueid(unsigned long num)
{
    MG_COQUE* mgcoque=get_mg_coqueid(num);
    if (mgcoque==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoque;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COQUE::iterator j=lst_mg_coque.find(num);
    lst_mg_coque.erase(j);
    delete mgcoque;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_coque(unsigned int num)
{
    MG_COQUE* mgcoque=get_mg_coque(num);
    if (mgcoque==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgcoque;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_COQUE::iterator j=lst_mg_coque.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_coque.erase(j);
    delete mgcoque;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_coque(void)
{
    while (get_nb_mg_coque()!=0)
    {
        LISTE_MG_COQUE::iterator j=lst_mg_coque.begin();
        MG_COQUE* mgcoque=(*j).second;
        MG_IDENTIFICATEUR* id=mgcoque;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_coque.erase(j);
        delete mgcoque;
    }
}


// ENTITE MG_POUTRE

int MG_GEOMETRIE::ajouter_mg_poutre(MG_POUTRE *mgpoutre)
{
    gest->recherche_bonid(*mgpoutre);
    MG_IDENTIFICATEUR *id=mgpoutre;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_POUTRE*> tmp(mgpoutre->get_id(),mgpoutre);
    lst_mg_poutre.insert(tmp);
    return OK;
}


MG_POUTRE* MG_GEOMETRIE::get_mg_poutreid(unsigned long num)
{
    LISTE_MG_POUTRE::iterator i=lst_mg_poutre.find(num);
    if (i==lst_mg_poutre.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}

MG_POUTRE* MG_GEOMETRIE::get_mg_poutreid(std::string id)
{
    LISTE_MG_POUTRE::iterator i=lst_mg_poutre.begin();
    int nb=lst_mg_poutre.size();
    for (int j=0;j<nb;j++)
    {
        MG_POUTRE* poutre=(*i).second;
        std::string idori=poutre->get_idoriginal();
        if (idori==id) return poutre;
        i++;
    }
    return NULL;
}


MG_POUTRE* MG_GEOMETRIE::get_mg_poutre(unsigned int num)
{
    if (!(num<lst_mg_poutre.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_POUTRE::iterator i=lst_mg_poutre.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_POUTRE* MG_GEOMETRIE::get_premier_poutre(LISTE_MG_POUTRE::iterator &it)
{
    it = lst_mg_poutre.begin();
    if (it == lst_mg_poutre.end())
        return NULL;
    return it->second ;
}

MG_POUTRE* MG_GEOMETRIE::get_suivant_poutre(LISTE_MG_POUTRE::iterator &it)
{
    it++;
    if (it==lst_mg_poutre.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_poutre(void)
{
    return lst_mg_poutre.size();
}


int MG_GEOMETRIE::supprimer_mg_poutreid(unsigned long num)
{
    MG_POUTRE* mgpoutre=get_mg_poutreid(num);
    if (mgpoutre==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgpoutre;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_POUTRE::iterator j=lst_mg_poutre.find(num);
    lst_mg_poutre.erase(j);
    delete mgpoutre;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_poutre(unsigned int num)
{
    MG_POUTRE* mgpoutre=get_mg_poutre(num);
    if (mgpoutre==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgpoutre;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_POUTRE::iterator j=lst_mg_poutre.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_poutre.erase(j);
    delete mgpoutre;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_poutre(void)
{
    while (get_nb_mg_poutre()!=0)
    {
        LISTE_MG_POUTRE::iterator j=lst_mg_poutre.begin();
        MG_POUTRE* mgpoutre=(*j).second;
        MG_IDENTIFICATEUR* id=mgpoutre;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_poutre.erase(j);
        delete mgpoutre;
    }
}
// ENTITE MG_GROUPE_TOPOLOGIQUE

int MG_GEOMETRIE::ajouter_mg_groupe_topologique(MG_GROUPE_TOPOLOGIQUE *mggroupe_topologique)
{
    gest->recherche_bonid(*mggroupe_topologique);
    MG_IDENTIFICATEUR *id=mggroupe_topologique;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_GROUPE_TOPOLOGIQUE*> tmp(mggroupe_topologique->get_id(),mggroupe_topologique);
    lst_mg_groupe_topologique.insert(tmp);
    return OK;
}


MG_GROUPE_TOPOLOGIQUE* MG_GEOMETRIE::get_mg_groupe_topologiqueid(unsigned long num)
{
    LISTE_MG_GROUPE_TOPOLOGIQUE::iterator i=lst_mg_groupe_topologique.find(num);
    if (i==lst_mg_groupe_topologique.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_GROUPE_TOPOLOGIQUE* MG_GEOMETRIE::get_mg_groupe_topologique(unsigned int num)
{
    if (!(num<lst_mg_groupe_topologique.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_GROUPE_TOPOLOGIQUE::iterator i=lst_mg_groupe_topologique.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_GROUPE_TOPOLOGIQUE* MG_GEOMETRIE::get_premier_groupe_topologique(LISTE_MG_GROUPE_TOPOLOGIQUE::iterator &it)
{
    it = lst_mg_groupe_topologique.begin();
    if (it == lst_mg_groupe_topologique.end())
        return NULL;
    return it->second ;
}

MG_GROUPE_TOPOLOGIQUE* MG_GEOMETRIE::get_suivant_groupe_topologique(LISTE_MG_GROUPE_TOPOLOGIQUE::iterator &it)
{
    it++;
    if (it==lst_mg_groupe_topologique.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_groupe_topologique(void)
{
    return lst_mg_groupe_topologique.size();
}


int MG_GEOMETRIE::supprimer_mg_groupe_topologiqueid(unsigned long num)
{
    MG_GROUPE_TOPOLOGIQUE* mggroupe_topologique=get_mg_groupe_topologiqueid(num);
    if (mggroupe_topologique==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggroupe_topologique;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GROUPE_TOPOLOGIQUE::iterator j=lst_mg_groupe_topologique.find(num);
    lst_mg_groupe_topologique.erase(j);
    delete mggroupe_topologique;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_groupe_topologique(unsigned int num)
{
    MG_GROUPE_TOPOLOGIQUE* mggroupe_topologique=get_mg_groupe_topologique(num);
    if (mggroupe_topologique==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggroupe_topologique;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    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);
    delete mggroupe_topologique;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_groupe_topologique(void)
{
    while (get_nb_mg_groupe_topologique()!=0)
    {
        LISTE_MG_GROUPE_TOPOLOGIQUE::iterator j=lst_mg_groupe_topologique.begin();
        MG_GROUPE_TOPOLOGIQUE* mggroupe_topologique=(*j).second;
        MG_IDENTIFICATEUR* id=mggroupe_topologique;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_groupe_topologique.erase(j);
        delete mggroupe_topologique;
    }
}
// ENTITE MG_GEOM_FONCTION

int MG_GEOMETRIE::ajouter_mg_geom_fonction(MG_GEOM_FONCTION *mggeomfon)
{
    gest->recherche_bonid(*mggeomfon);
    MG_IDENTIFICATEUR *id=mggeomfon;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
//      afficheur << ENTITEID << id->get_id() << DUPLIQUE << enderr;
        return FAIL;
    }

    std::pair<const unsigned long,MG_GEOM_FONCTION*> tmp(mggeomfon->get_id(),mggeomfon);
    lst_mg_geom_fonction.insert(tmp);
    return OK;
}


MG_GEOM_FONCTION* MG_GEOMETRIE::get_mg_geom_fonctionid(unsigned long num)
{
    LISTE_MG_GEOM_FONCTION::iterator i=lst_mg_geom_fonction.find(num);
    if (i==lst_mg_geom_fonction.end())
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    return ((*i).second);
}


MG_GEOM_FONCTION* MG_GEOMETRIE::get_mg_geom_fonction(unsigned int num)
{
    if (!(num<lst_mg_geom_fonction.size()))
    {
//      afficheur << INEXISTE << enderr;
        return NULL;
    }
    LISTE_MG_GEOM_FONCTION::iterator i=lst_mg_geom_fonction.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


MG_GEOM_FONCTION* MG_GEOMETRIE::get_premier_geom_fonction(LISTE_MG_GEOM_FONCTION::iterator &it)
{
    it = lst_mg_geom_fonction.begin();
    if (it == lst_mg_geom_fonction.end())
        return NULL;
    return it->second ;
}

MG_GEOM_FONCTION* MG_GEOMETRIE::get_suivant_geom_fonction(LISTE_MG_GEOM_FONCTION::iterator &it)
{
    it++;
    if (it==lst_mg_geom_fonction.end())
        return NULL;
    return it->second;
}


unsigned int MG_GEOMETRIE::get_nb_mg_geom_fonction(void)
{
    return lst_mg_geom_fonction.size();
}


int MG_GEOMETRIE::supprimer_mg_geom_fonctionid(unsigned long num)
{
    MG_GEOM_FONCTION* mggeomfon=get_mg_geom_fonctionid(num);
    if (mggeomfon==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeomfon;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_GEOM_FONCTION::iterator j=lst_mg_geom_fonction.find(num);
    lst_mg_geom_fonction.erase(j);
    delete mggeomfon;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_geom_fonction(unsigned int num)
{
    MG_GEOM_FONCTION* mggeomfon=get_mg_geom_fonction(num);
    if (mggeomfon==NULL)
    {
//      afficheur << INEXISTE2 << enderr;
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mggeomfon;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    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);
    delete mggeomfon;
    return OK;
}


void MG_GEOMETRIE::supprimer_tout_mg_geom_fonction(void)
{
    while (get_nb_mg_geom_fonction()!=0)
    {
        LISTE_MG_GEOM_FONCTION::iterator j=lst_mg_geom_fonction.begin();
        MG_GEOM_FONCTION* mggeomfon=(*j).second;
        MG_IDENTIFICATEUR* id=mggeomfon;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_geom_fonction.erase(j);
        delete mggeomfon;
    }
}


// ENTITE MG_VISU_COURBE

int MG_GEOMETRIE::ajouter_mg_visu_courbe(MG_VISU_COURBE *mgvcrb)
{
    gest->recherche_bonidvisuel(*mgvcrb);
    std::pair<const unsigned long,MG_VISU_COURBE*> tmp(mgvcrb->get_id(),mgvcrb);
    lst_mg_visu_courbe.insert(tmp);
    return OK;
}


MG_VISU_COURBE* MG_GEOMETRIE::get_mg_visu_courbeid(unsigned long num)
{
    LISTE_MG_VISU_COURBE::iterator i=lst_mg_visu_courbe.find(num);
    if (i==lst_mg_visu_courbe.end())
    {
        return NULL;
    }
    return ((*i).second);
}


MG_VISU_COURBE* MG_GEOMETRIE::get_mg_visu_courbe(unsigned int num)
{
    if (!(num<lst_mg_visu_courbe.size()))
    {
        return NULL;
    }
    LISTE_MG_VISU_COURBE::iterator i=lst_mg_visu_courbe.begin();

    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}


unsigned int MG_GEOMETRIE::get_nb_mg_visu_courbe(void)
{
    return lst_mg_visu_courbe.size();
}

MG_VISU_COURBE* MG_GEOMETRIE::get_premier_visu_courbe(LISTE_MG_VISU_COURBE::iterator& it)
{
    it = lst_mg_visu_courbe.begin();
    if (it == lst_mg_visu_courbe.end())
        return NULL;
    return it->second ;
}

MG_VISU_COURBE* MG_GEOMETRIE::get_suivant_visu_courbe(LISTE_MG_VISU_COURBE::iterator& it)
{
    it++;
    if (it == lst_mg_visu_courbe.end())
        return NULL;
    return it->second ;
}


int MG_GEOMETRIE::supprimer_mg_visu_courbeid(unsigned long num)
{
    MG_VISU_COURBE* mgvcrb=get_mg_visu_courbeid(num);
    if (mgvcrb==NULL)
    {
        return FAIL;
    }
    LISTE_MG_VISU_COURBE::iterator j=lst_mg_visu_courbe.find(num);
    lst_mg_visu_courbe.erase(j);
    delete mgvcrb;
    return OK;
}


int MG_GEOMETRIE::supprimer_mg_visu_courbe(unsigned int num)
{
    MG_VISU_COURBE* mgvcrb=get_mg_visu_courbe(num);
    if (mgvcrb==NULL)
    {
        return FAIL;
    }
    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);
    delete mgvcrb;
    return OK;
}

void MG_GEOMETRIE::supprimer_tout_mg_visu_courbe(void)
{
    while (get_nb_mg_visu_courbe()!=0)
    {
        LISTE_MG_VISU_COURBE::iterator j=lst_mg_visu_courbe.begin();
        MG_VISU_COURBE* mgvcrb=(*j).second;
        lst_mg_visu_courbe.erase(j);
        delete mgvcrb;
    }
}

int MG_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_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_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_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_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_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;
}


MG_ELEMENT_TOPOLOGIQUE* MG_GEOMETRIE::get_mg_element_topologiqueid(long int num)
{
  MG_ELEMENT_TOPOLOGIQUE* ele;
  if(get_mg_sommetid(num)!=NULL)
  {
    ele = get_mg_sommetid(num);
    return ele;
  }
  else if(get_mg_areteid(num)!=NULL)
  {
    ele = get_mg_areteid(num);
    return ele;
  }
  else if(get_mg_faceid(num)!=NULL)
  {
    ele = get_mg_faceid(num);
    return ele;
  }
  else if(get_mg_volumeid(num)!=NULL)
  {
    ele = get_mg_volumeid(num);
    return ele;
  }
  else if(get_mg_poutreid(num)!=NULL)
  {
    ele = get_mg_poutreid(num);
    return ele;
  }
  else if(get_mg_coqueid(num)!=NULL)
  {
    ele = get_mg_coqueid(num);
    return ele;
  }
  else return NULL;
}

MG_ELEMENT_COTOPOLOGIQUE* MG_GEOMETRIE::get_mg_element_cotopologiqueid(long int num)
{
  MG_ELEMENT_COTOPOLOGIQUE* ele;
  if(get_mg_cosommetid(num)!=NULL)
  {
    ele = get_mg_cosommetid(num);
    return ele;
  }
  else if(get_mg_coareteid(num)!=NULL)
  {
    ele = get_mg_coareteid(num);
    return ele;
  }
  else if(get_mg_boucleid(num)!=NULL)
  {
    ele = get_mg_boucleid(num);
    return ele;
  }
  else if(get_mg_cofaceid(num)!=NULL)
  {
    ele = get_mg_cofaceid(num);
    return ele;
  }
  else if(get_mg_coquilleid(num)!=NULL)
  {
    ele = get_mg_coquilleid(num);
    return ele;
  }
  else return NULL;
}


void MG_GEOMETRIE::remplir_mg_groupe_topologique(MG_GROUPE_TOPOLOGIQUE* mg_groupe_topologique)
{
  LISTE_MG_SOMMET::iterator it_sommet;
  for(MG_SOMMET* sommet=get_premier_sommet(it_sommet);sommet!=NULL;sommet=get_suivant_sommet(it_sommet)) mg_groupe_topologique->ajouter(sommet);
  LISTE_MG_ARETE::iterator it_arete;
  for(MG_ARETE* arete=get_premier_arete(it_arete);arete!=NULL;arete=get_suivant_arete(it_arete)) mg_groupe_topologique->ajouter(arete);
  LISTE_MG_FACE::iterator it_face;
  for(MG_FACE* face=get_premier_face(it_face);face!=NULL;face=get_suivant_face(it_face)) mg_groupe_topologique->ajouter(face);
  LISTE_MG_VOLUME::iterator it_volume;
  for(MG_VOLUME* volume=get_premier_volume(it_volume);volume!=NULL;volume=get_suivant_volume(it_volume)) mg_groupe_topologique->ajouter(volume);
  LISTE_MG_COQUE::iterator it_coque;
  for(MG_COQUE* coque=get_premier_coque(it_coque);coque!=NULL;coque=get_suivant_coque(it_coque)) mg_groupe_topologique->ajouter(coque);
  LISTE_MG_POUTRE::iterator it_poutre;
  for(MG_POUTRE* poutre=get_premier_poutre(it_poutre);poutre!=NULL;poutre=get_suivant_poutre(it_poutre)) mg_groupe_topologique->ajouter(poutre);
}


// FIN DE GESTION DES ENTITES

void MG_GEOMETRIE::enregistrer(std::ostream& o,double version)
{
#ifdef ALL_OCC
    if(strcmp(type_geo,"OCCV2017")==0)
    {
      OCC_FONCTION_V2017* occ_fonction_v2017 = (OCC_FONCTION_V2017*)fonction1;
      occ_fonction_v2017->enregistrer_fichier_OCAF(nom_du_fichier,this);
    }
#endif
    if(!geometrie_construction)
    {
      if (nom_du_fichier==NULL) o << "%" << get_id() << "=GEOMETRIE(" << valeur_unite << "," << type_geo ;
      else  o << "%" << get_id() << "=GEOMETRIE(" << valeur_unite << "," << type_geo << "," << nom_du_fichier;
    }
    else o << "%" << get_id() << "=CONSTRUCTION(" << valeur_unite << "," << type_geo << "," << nom_du_fichier;
    if (gest_materiau!="") o << "," << gest_materiau.c_str() ;
    o <<  ");" << std::endl;
    o << "%" << get_id() << "=GEOMETRIE_EPS(" << precision  <<  ");" << std::endl;
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->enregistrer(o,version);
}

void MG_GEOMETRIE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
    liste_fichier.push_back(nom_du_fichier);
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->get_fichier_dependant(liste_fichier);
}

char* MG_GEOMETRIE::get_nom_du_fichier(void)
{
    return nom_du_fichier;
}

char* MG_GEOMETRIE::get_type_geometrie(void)
{
    return type_geo;
}

bool MG_GEOMETRIE::est_virtuelle(void)
{
bool res=false;
std::string type=get_type_geometrie();
OT_CHAINE ot;
type=ot.upcase(type);
if (type=="VIRTUEL") res=true;
return res;
}

void MG_GEOMETRIE::cree_entite_visuel(double facteur)
{
    supprimer_tout_mg_visu_courbe();
    int nbarete=get_nb_mg_arete();
    for (int i=0;i<nbarete;i++)
    {
        MG_ARETE* mgarete=get_mg_arete(i);
        double xyz1[3];
        double tmin=mgarete->get_tmin();
        double tmax=mgarete->get_tmax();
        mgarete->evaluer(tmin,xyz1);
        int nb_pas=(int)(20.*facteur);
        for (int j=1;j<nb_pas+1;j++)
        {
            double t=tmin+j*(tmax-tmin)/nb_pas;
            double xyz2[3];
            mgarete->evaluer(t,xyz2);
            MG_VISU_COURBE* mgvisucourbe=new MG_VISU_COURBE(xyz1,xyz2);
            ajouter_mg_visu_courbe(mgvisucourbe);
            xyz1[0]=xyz2[0];
            xyz1[1]=xyz2[1];
            xyz1[2]=xyz2[2];
        }
    }
}

std::ostream& operator << (std::ostream& o,MG_GEOMETRIE& geo)
{
    geo.enregistrer(o,VERSIONFICHIER);
    return o;
}


void MG_GEOMETRIE::change_gest_materiau(char* nom)
{
    gest_materiau=nom;
}

char* MG_GEOMETRIE::get_gest_materiau(void)
{
    return (char*)gest_materiau.c_str();
}

double MG_GEOMETRIE::get_valeur_precision(void)
{
    return precision;
}

void MG_GEOMETRIE::change_valeur_precision(double val)
{
    precision=val;
}

double MG_GEOMETRIE::get_valeur_unite(void)
{
    return valeur_unite;
}

void MG_GEOMETRIE::change_valeur_unite(double val)
{
    valeur_unite=val;
}


void MG_GEOMETRIE::construit_vectorisation(void)
{
    LISTE_MG_FACE::iterator itface;
    for (MG_FACE* face=get_premier_face(itface);face!=NULL;face=get_suivant_face(itface))
        face->get_vectorisation();
    LISTE_MG_ARETE::iterator itarete;
    for (MG_ARETE* arete=get_premier_arete(itarete);arete!=NULL;arete=get_suivant_arete(itarete))
        arete->get_vectorisation();
    LISTE_MG_SOMMET::iterator itsommet;
    for (MG_SOMMET* som=get_premier_sommet(itsommet);som!=NULL;som=get_suivant_sommet(itsommet))
        som->get_vectorisation();
    LISTE_MG_SURFACE::iterator itsurface;
    for (MG_SURFACE* surface=get_premier_surface(itsurface);surface!=NULL;surface=get_suivant_surface(itsurface))
        surface->get_vectorisation();
    LISTE_MG_COURBE::iterator itcourbe;
    for (MG_COURBE* courb=get_premier_courbe(itcourbe);courb!=NULL;courb=get_suivant_courbe(itcourbe))
        courb->get_vectorisation();
    LISTE_MG_POINT::iterator itpoint;
    for (MG_POINT* point=get_premier_point(itpoint);point!=NULL;point=get_suivant_point(itpoint))
        point->get_vectorisation();
}


#ifdef BREP_SAT
SAT_GESTIONNAIRE&  MG_GEOMETRIE::get_gest_sat(void)
{
    return fichsat;
}
#endif
#ifdef BREP_STEP
ST_GESTIONNAIRE& MG_GEOMETRIE::get_gest_step(void)
{
    return fichstep;
}
#endif

#ifdef BREP_OCC
OCC_FONCTION& MG_GEOMETRIE::get_occ_fonction(void)
{
    return *fonction1;
}
#endif

bool MG_GEOMETRIE::est_construction(void)
{
  return geometrie_construction;
}

void MG_GEOMETRIE::change_est_construction(bool val)
{
  geometrie_construction=val;
}

void MG_GEOMETRIE::efface_ccf(bool volume, bool face, bool arete, bool sommet)
{
if (volume)
  {
  LISTE_MG_VOLUME::iterator it;
  for (MG_VOLUME* vol=get_premier_volume(it);vol!=NULL;vol=get_suivant_volume(it))
      {
      while (vol->get_nb_ccf()>0)
        vol->supprimer_ccf(0);
      }
  }
if (face)
  {
  LISTE_MG_FACE::iterator it;
  for (MG_FACE* fac=get_premier_face(it);fac!=NULL;fac=get_suivant_face(it))
      {
      while (fac->get_nb_ccf()>0)
        fac->supprimer_ccf(0);
      }
  }
if (arete)
  {
  LISTE_MG_ARETE::iterator it;
  for (MG_ARETE* are=get_premier_arete(it);are!=NULL;are=get_suivant_arete(it))
      {
      while (are->get_nb_ccf()>0)
        are->supprimer_ccf(0);
      }
  }
if (sommet)
  {
  LISTE_MG_SOMMET::iterator it;
  for (MG_SOMMET* som=get_premier_sommet(it);som!=NULL;som=get_suivant_sommet(it))
      {
      while (som->get_nb_ccf()>0)
            som->supprimer_ccf(0);
      }
  }    
}
Revision:	1075
Committed:	Tue Aug 10 17:02:54 2021 UTC (4 years ago) by francois
File size:	75437 byte(s)
Log Message:	suppression de warning avec le dernier compilateur