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 "affiche.h"
//#include "message.h"


//using namespace std;

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)
{
    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)))
    {
    if (strcmp(type_geo,"OCC")==0) fonction1=new OCC_FONCTION;
    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();
    if (nom_du_fichier!=NULL) delete [] nom_du_fichier;

#ifdef BREP_OCC
    if ((strcmp(type_geo,"STEPOCC")==0)||(strcmp(type_geo,"OCC")==0)||((strcmp(type_geo,"OCCV2015")==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);
    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);
    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);
        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


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;
}

// 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();
    supprimer_mg_cosommet(cosom1);
    supprimer_mg_cosommet(cosom2);
    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);
    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);
          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

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;
}

// ENTITE MG_BOUCLE

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);
    lst_mg_boucle.insert(tmp);
    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);
    lst_mg_boucle.insert(tmp);
    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);
    }
    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);
    }
    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);
        }
        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;
        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);
    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);
    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);
        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


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;
}

// ENTITE MG_COQUILLE

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);
    lst_mg_coquille.insert(tmp);
    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);
    lst_mg_coquille.insert(tmp);
    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);
    }
    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);
    }
    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);
        }
        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);
    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);
    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);
        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();
}


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;
    }
}


// FIN DE GESTION DES ENTITES

void MG_GEOMETRIE::enregistrer(std::ostream& o,double version)
{
    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;
    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);
}


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

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


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
Revision:	763
Committed:	Wed Dec 2 19:55:53 2015 UTC (9 years, 5 months ago) by francois
File size:	57218 byte(s)
Log Message:	Le fichier MAGiC est maintenant versionné. LA version actuelle est 2.0. L'ancienne version est 1.0. Tout est transparent pour l'utilisateur. Les vieilles versions sont lisibles mais les nouveaux enregistrements sont dans la version la plus récente. Changement des conditions aux limites : ajout d'un parametre pour dire si la condition numerique est une valeur ou une formule ou un lien vers une autre entité magic. Les parametres pour saisir sont maintenant -ccf -ccfi -ccff -ccft -ccfit -ccfft