mg_cg_assemblage.cpp

Aller à la documentation de ce fichier.

//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//  MAGiC
//####//  Jean Christophe Cuilliere et Vincent FRANCOIS
//####//  Departement de Genie Mecanique - UQTR
//####//------------------------------------------------------------
//####//  MAGIC est un projet de recherche de l equipe ERICCA
//####//  du departement de genie mecanique de l Universite du Quebec a Trois Rivieres
//####//  http://www.uqtr.ca/ericca
//####//  http://www.uqtr.ca/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mg_cg_assemblage.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mg_cg_assemblage.h"
#include "mg_gestionnaire.h"
#include "mg_definition.h"
#include "mg_cg_forme.h"
#include "mg_cg_forme_volume.h"
#include "mg_cg_modele.h"
#include "mg_sous_geometrie.h"
MG_CG_ASSEMBLAGE::MG_CG_ASSEMBLAGE(MG_CG_MODELE* mgcg_modele,std::string nom_mgcg_assemblage)
{
  m_mgcg_modele=mgcg_modele;
  m_nom_mgcg_assemblage=nom_mgcg_assemblage;
  mgcg_modele->ajouter_mgcg_assemblage(this);
  m_mg_sous_geometrie = new MG_SOUS_GEOMETRIE(m_mgcg_modele->get_mg_geometrie(),
                                              get_id(),
                                              (char*)"MGCG_ASS",
                                              m_nom_mgcg_assemblage.c_str(),
                                              m_mgcg_modele->get_mg_geometrie()->get_valeur_unite(),
                                              m_mgcg_modele->get_mg_geometrie()->get_valeur_precision());
  m_mgcg_modele->get_mg_gestionnaire()->ajouter_mg_geometrie(m_mg_sous_geometrie);
}
 
 
MG_CG_ASSEMBLAGE::MG_CG_ASSEMBLAGE(MG_CG_MODELE* mgcg_modele, long unsigned int num,std::string nom_mgcg_assemblage, MG_SOUS_GEOMETRIE *mg_sous_geometrie): MG_CONSTRUCTION_GEOMETRIQUE(num)
{
  m_mgcg_modele=mgcg_modele;
  m_nom_mgcg_assemblage=nom_mgcg_assemblage;
  m_mg_sous_geometrie = mg_sous_geometrie;
}
 
MG_CG_ASSEMBLAGE::~MG_CG_ASSEMBLAGE(void)
{
  retirer_tout_mgcg_forme();
  m_mgcg_modele->get_mg_gestionnaire()->supprimer_mg_geometrieid(m_mg_sous_geometrie->get_id());
}
 
MG_CG_MODELE* MG_CG_ASSEMBLAGE::get_mgcg_modele(void)
{
  return m_mgcg_modele;
}
 
void MG_CG_ASSEMBLAGE::change_nom_mgcg_assemblage(std::string nom_mgcg_assemblage)
{
  m_nom_mgcg_assemblage=nom_mgcg_assemblage;
}
 
std::string MG_CG_ASSEMBLAGE::get_nom_mgcg_assemblage(void)
{
  return m_nom_mgcg_assemblage;
}
 
void MG_CG_ASSEMBLAGE::change_mg_sous_geometrie(MG_SOUS_GEOMETRIE* mg_sous_geometrie)
{
  m_mg_sous_geometrie=mg_sous_geometrie;
}
 
MG_SOUS_GEOMETRIE* MG_CG_ASSEMBLAGE::get_mg_sous_geometrie(void)
{
  return m_mg_sous_geometrie;
}
 
long int MG_CG_ASSEMBLAGE::get_nb_mgcg_forme(void)
{
  return m_map_mgcg_forme.size();
}
 
int MG_CG_ASSEMBLAGE::ajouter_mgcg_forme(MG_CG_FORME* mgcg_forme,bool avec_mg_element)
{
  std::pair<std::map<long,MG_CG_FORME*>::iterator,bool> p=m_map_mgcg_forme.insert(std::pair<long,MG_CG_FORME*>(mgcg_forme->get_id(),mgcg_forme));
  if (!p.second)  
    return FAIL;
  if(mgcg_forme->get_etat()==MG_CG_FORME::ETAT_FORME::CONSTRUITE && avec_mg_element) ajouter_mg_element_mgcg_forme(mgcg_forme);
  return OK;
}
 
MG_CG_FORME* MG_CG_ASSEMBLAGE::get_premiere_mgcg_forme(std::map< long, MG_CG_FORME* >::iterator& it)
{
  it=m_map_mgcg_forme.begin();
  if(it==m_map_mgcg_forme.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_ASSEMBLAGE::get_suivante_mgcg_forme(std::map< long, MG_CG_FORME* >::iterator& it)
{
  it++;
  if(it==m_map_mgcg_forme.end())  
    return NULL;
  return it->second;
}
 
MG_CG_FORME* MG_CG_ASSEMBLAGE::get_mgcg_formeid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it=m_map_mgcg_forme.find(id);
  if (it==m_map_mgcg_forme.end())
  {
      return NULL;
  }
  return ((*it).second);
}
 
int MG_CG_ASSEMBLAGE::retirer_mgcg_formeid(long int id)
{
  std::map<long,MG_CG_FORME*>::iterator it;
  it=m_map_mgcg_forme.find(id);
  if(it!=m_map_mgcg_forme.end())
  {
    m_map_mgcg_forme.erase(it);
    actualiser_mg_sous_geometrie();
    return OK;
  }
  else return FAIL;
}
 
void MG_CG_ASSEMBLAGE::retirer_tout_mgcg_forme(void)
{
  m_map_mgcg_forme.clear();
  m_mg_sous_geometrie->retirer_tout();
}
 
void MG_CG_ASSEMBLAGE::enregistrer(std::ostream& o,double version)
{
   o << "%" << get_id() << "=MG_CG_ASSEMBLAGE($"<< m_mgcg_modele->get_id()<< "," 
                                                << m_nom_mgcg_assemblage << ",$"
                                                << m_mg_sous_geometrie->get_id() << ","
                                                << get_nb_mgcg_forme() <<",(";
  std::map<long,MG_CG_FORME*>::iterator it_forme;
  for(it_forme=m_map_mgcg_forme.begin();it_forme!=m_map_mgcg_forme.end();it_forme++)
  {
    o << "$" << it_forme->second->get_id();
    if(it_forme!=--m_map_mgcg_forme.end()) o << ",";
  }
   o << "));" << std::endl;
   enregistrer_infos(o,version);
}
 
int MG_CG_ASSEMBLAGE::get_type_mg_construction_geometrique(void)
{
  return TYPE_MG_CONSTRUCTION_GEOMETRIQUE::MGCG_ASSEMBLAGE;
}
 
void MG_CG_ASSEMBLAGE::ajouter_mg_element_mgcg_forme(MG_CG_FORME* mgcg_forme)
{
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*> map_mg_element_topologique;
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*> map_mg_element_cotopologique;
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*> map_mg_element_geometrique;
  MG_GEOMETRIE* geo=m_mg_sous_geometrie->get_mg_geometrie();
  if (geo->est_virtuelle())
        {
        LISTE_MG_VOLUME::iterator itv;
        LISTE_MG_FACE::iterator itf;
        LISTE_MG_ARETE::iterator ita;
        LISTE_MG_SOMMET::iterator its;
        for (MG_VOLUME* vol=geo->get_premier_volume(itv);vol!=NULL;vol=geo->get_suivant_volume(itv))
            map_mg_element_topologique.ajouter(vol);
        for (MG_FACE* face=geo->get_premier_face(itf);face!=NULL;face=geo->get_suivant_face(itf))
            map_mg_element_topologique.ajouter(face);
        for (MG_ARETE* are=geo->get_premier_arete(ita);are!=NULL;are=geo->get_suivant_arete(ita))
            map_mg_element_topologique.ajouter(are);
        for (MG_SOMMET* som=geo->get_premier_sommet(its);som!=NULL;som=geo->get_suivant_sommet(its))
            map_mg_element_topologique.ajouter(som);
            
        }
  else
        mgcg_forme->get_mg_element(&map_mg_element_topologique,&map_mg_element_cotopologique,&map_mg_element_geometrique);
  TPL_MAP_ENTITE<MG_ELEMENT_TOPOLOGIQUE*>::ITERATEUR it_topo;
  for(MG_ELEMENT_TOPOLOGIQUE* ele=map_mg_element_topologique.get_premier(it_topo);ele!=NULL;ele=map_mg_element_topologique.get_suivant(it_topo))
  {
    m_mg_sous_geometrie->ajouter_mg_element_topologique(ele);
  }
  TPL_MAP_ENTITE<MG_ELEMENT_COTOPOLOGIQUE*>::ITERATEUR it_cotopo;
  for(MG_ELEMENT_COTOPOLOGIQUE* ele=map_mg_element_cotopologique.get_premier(it_cotopo);ele!=NULL;ele=map_mg_element_cotopologique.get_suivant(it_cotopo))
  {
    m_mg_sous_geometrie->ajouter_mg_element_cotopologique(ele);
  }  
  TPL_MAP_ENTITE<MG_ELEMENT_GEOMETRIQUE*>::ITERATEUR it_geo;
  for(MG_ELEMENT_GEOMETRIQUE* ele=map_mg_element_geometrique.get_premier(it_geo);ele!=NULL;ele=map_mg_element_geometrique.get_suivant(it_geo))
  {
    m_mg_sous_geometrie->ajouter_mg_element_geometrique(ele);
  }
}
 
void MG_CG_ASSEMBLAGE::actualiser_mg_sous_geometrie(void)
{
  m_mg_sous_geometrie->retirer_tout();
  std::map<long,MG_CG_FORME*>::iterator it;
  for(MG_CG_FORME* mgcg_forme=get_premiere_mgcg_forme(it);mgcg_forme!=NULL;mgcg_forme=get_suivante_mgcg_forme(it))
  {
    if(mgcg_forme->get_etat()==MG_CG_FORME::ETAT_FORME::CONSTRUITE)
      ajouter_mg_element_mgcg_forme(mgcg_forme);
  }
}