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


//using namespace std;

MG_GEOMETRIE::MG_GEOMETRIE(char *type,const char *nom,double unite):MG_IDENTIFICATEUR(),gest_materiau(""),valeur_unite(unite)
{
nom_du_fichier=new char[strlen(nom)+1];
strcpy(nom_du_fichier,nom);
strcpy(type_geo,type);
}


MG_GEOMETRIE::MG_GEOMETRIE(char *type,unsigned long num,const char *nom,double unite):MG_IDENTIFICATEUR(num),valeur_unite(unite)
{
nom_du_fichier=new char[strlen(nom)+1];
strcpy(nom_du_fichier,nom);
strcpy(type_geo,type);
}


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();

if (nom_du_fichier!=NULL) delete [] nom_du_fichier;

}


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

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);
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);
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);
    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_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)
{
   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;
  LISTE_ENTITE::const_iterator i;
  for (i=lst_entite.begin();i!=lst_entite.end();i++)
     (*i)->enregistrer(o);
}


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);
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_unite(void)
{
return valeur_unite;
}

void MG_GEOMETRIE::change_valeur_unite(double val)
{
valeur_unite=val;
}
Revision:	5
Committed:	Tue Jun 12 20:26:34 2007 UTC (17 years, 11 months ago)
Original Path:	*magic/lib/geometrie/geometrie/src/mg_geometrie.cpp*
File size:	45467 byte(s)
Log Message: