mstruct_groupe_forme.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       mstruct_groupe_forme.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:57 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#include "mstruct_groupe_forme.h"
#include "mg_cg_forme.h"
#include "mg_cg_forme_volume.h"
#include "mg_cg_forme_multi_volume.h"
#include "mg_cg_modele.h"
#include "parse.h"
#include "pars_argument.h"
#include <sstream>
 
GROUPE_FORME::GROUPE_FORME(void)
{
 
}
 
GROUPE_FORME::GROUPE_FORME(std::string nom)
{
  m_nom=nom;
}
 
GROUPE_FORME::~GROUPE_FORME(void)
{
 
}
 
GROUPE_FORME::GROUPE_FORME(GROUPE_FORME& mdd)
{
  m_nom=mdd.m_nom;
  TPL_MAP_ENTITE<MG_CG_FORME*>::ITERATEUR it;
  for(MG_CG_FORME* forme=mdd.m_tpl_map_forme.get_premier(it);forme!=NULL;forme=mdd.m_tpl_map_forme.get_suivant(it))
  {
    m_tpl_map_forme.ajouter(forme);
  }
  m_map_donnees_forme=mdd.m_map_donnees_forme;
}
 
int GROUPE_FORME::ajouter_donnee_forme(MG_CG_FORME* mgcg_forme, std::string donnee)
{
  m_map_donnees_forme.insert(std::pair<long,std::string>(mgcg_forme->get_id(),donnee));
return 0;
    
}
 
long int GROUPE_FORME::get_nb_donnee_forme(MG_CG_FORME* mgcg_forme)
{
  return m_map_donnees_forme.count(mgcg_forme->get_id());
}
 
std::string GROUPE_FORME::get_premiere_donnee_forme(MG_CG_FORME* mgcg_forme, std::multimap< long int, std::string >::iterator& it)
{
  std::pair<std::multimap<long,std::string>::iterator,std::multimap<long,std::string>::iterator> ret;
  ret=m_map_donnees_forme.equal_range(mgcg_forme->get_id());
  it=ret.first;
  if(it==ret.second) return "";
  return (*it).second;
}
 
std::string GROUPE_FORME::get_suivante_donnee_forme(MG_CG_FORME* mgcg_forme, std::multimap< long int, std::string >::iterator& it)
{
  std::pair<std::multimap<long,std::string>::iterator,std::multimap<long,std::string>::iterator> ret;
  ret=m_map_donnees_forme.equal_range(mgcg_forme->get_id());
  it++;
  if(it==ret.second) return "";
  return (*it).second;
}
 
TPL_MAP_ENTITE< MG_VOLUME* > GROUPE_FORME::get_tpl_map_volume(void)
{
  TPL_MAP_ENTITE<MG_VOLUME*> tpl_map_volume;
  TPL_MAP_ENTITE<MG_CG_FORME*>::ITERATEUR it;
  for(MG_CG_FORME* forme=m_tpl_map_forme.get_premier(it);forme!=NULL;forme=m_tpl_map_forme.get_suivant(it))
  {
    if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::VOLUME)
    {
      MG_CG_FORME_VOLUME* forme_volume = (MG_CG_FORME_VOLUME*)forme;
      tpl_map_volume.ajouter(forme_volume->get_mg_volume());
    }
    else if(forme->get_type_forme()==MG_CG_FORME::TYPE_FORME::MULTI_VOLUME)
    {
      MG_CG_FORME_MULTI_VOLUME* forme_multi_volume = (MG_CG_FORME_MULTI_VOLUME*)forme;
      std::map<long,MG_VOLUME*>::iterator it_volume;
      for(MG_VOLUME* volume=forme_multi_volume->get_premier_mg_volume(it_volume);volume!=NULL;volume=forme_multi_volume->get_suivant_mg_volume(it_volume))
      {
        tpl_map_volume.ajouter(volume);
      }
    }
  }
  return tpl_map_volume;
}
 
int GROUPE_FORME::ajouter_id_forme_ini(MG_CG_FORME* mgcg_forme, long int id)
{
  char data[500];
  sprintf(data,"ID_FORME_INI=(%li)",id);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_id_forme_ini(MG_CG_FORME* mgcg_forme, long int& id)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@)",param);
    if(param[0].argument[0]=="ID_FORME_INI")
    {
      trouve=true;
      id = atol(param[1].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
int GROUPE_FORME::ajouter_centre_forme(MG_CG_FORME* mgcg_forme, double* centre_xyz)
{
  char data[500];
  sprintf(data,"CENTRE=(%.15lf,%.15lf,%.15lf)",centre_xyz[0],centre_xyz[1],centre_xyz[2]);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_centre_forme(MG_CG_FORME* mgcg_forme, double* centre_xyz)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@,@,@)",param);
    if(param[0].argument[0]=="CENTRE")
    {
      trouve=true;
      centre_xyz[0] = atof(param[1].argument[0].c_str());
      centre_xyz[1] = atof(param[2].argument[0].c_str());
      centre_xyz[2] = atof(param[3].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
int GROUPE_FORME::ajouter_extremite_forme(MG_CG_FORME* mgcg_forme, double* extremite_xyz)
{
  char data[500];
  sprintf(data,"EXTREMITE=(%.15lf,%.15lf,%.15lf)",extremite_xyz[0],extremite_xyz[1],extremite_xyz[2]);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_extremite_forme(MG_CG_FORME* mgcg_forme, double* extremite_xyz)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@,@,@)",param);
    if(param[0].argument[0]=="EXTREMITE")
    {
      trouve=true;
      extremite_xyz[0] = atof(param[1].argument[0].c_str());
      extremite_xyz[1] = atof(param[2].argument[0].c_str());
      extremite_xyz[2] = atof(param[3].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
int GROUPE_FORME::ajouter_position_relative(MG_CG_FORME* mgcg_forme, std::string str)
{
  char data[500];
  sprintf(data,"POSITION_RELATIVE=(%s)",str.c_str());
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_position_relative(MG_CG_FORME* mgcg_forme, std::string& str)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@)",param);
    if(param[0].argument[0]=="POSITION_RELATIVE")
    {
      trouve=true;
      str = param[1].argument[0];
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
 
int GROUPE_FORME::ajouter_axe_forme(MG_CG_FORME* mgcg_forme, double* axe_xyz)
{
  char data[500];
  sprintf(data,"AXE=(%.15lf,%.15lf,%.15lf)",axe_xyz[0],axe_xyz[1],axe_xyz[2]);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_axe_forme(MG_CG_FORME* mgcg_forme, double* axe_xyz)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && data!="")
  {
    parse.decode(data.c_str(),"@=(@,@,@)",param);
    if(param[0].argument[0]=="AXE")
    {
      trouve=true;
      axe_xyz[0] = atof(param[1].argument[0].c_str());
      axe_xyz[1] = atof(param[2].argument[0].c_str());
      axe_xyz[2] = atof(param[3].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
int GROUPE_FORME::ajouter_rayon_forme(MG_CG_FORME* mgcg_forme, double rayon)
{
  char data[500];
  sprintf(data,"RAYON=(%.15lf)",rayon);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_rayon_forme(MG_CG_FORME* mgcg_forme, double& rayon)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@)",param);
    if(param[0].argument[0]=="RAYON")
    {
      trouve=true;
      rayon = atof(param[1].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
int GROUPE_FORME::ajouter_longueur_forme(MG_CG_FORME* mgcg_forme, double longueur)
{
  char data[500];
  sprintf(data,"LONGUEUR=(%.15lf)",longueur);
  ajouter_donnee_forme(mgcg_forme,std::string(data));
  return OK;
}
 
int GROUPE_FORME::get_longueur_forme(MG_CG_FORME* mgcg_forme, double& longueur)
{
  PARS_ARGUMENT param[100];
  PARSE parse;
  bool trouve=false;
  std::multimap< long int, std::string >::iterator it_data;
  std::string data = get_premiere_donnee_forme(mgcg_forme,it_data);
  while(trouve==false && it_data!=m_map_donnees_forme.end())
  {
    parse.decode(data.c_str(),"@=(@)",param);
    if(param[0].argument[0]=="LONGUEUR")
    {
      trouve=true;
      longueur = atof(param[1].argument[0].c_str());
      return OK;
    }
    else data = get_suivante_donnee_forme(mgcg_forme,it_data);
  }
  return FAIL;
}
 
void GROUPE_FORME::exporter(std::ofstream& f)
{
  f << "GROUPE_MG_CG_FORME " << m_nom << std::endl;
  f << "NB_MG_CG_FORME " << m_tpl_map_forme.get_nb() << std::endl;
  TPL_MAP_ENTITE<MG_CG_FORME*>::ITERATEUR it;
  for(MG_CG_FORME* forme=m_tpl_map_forme.get_premier(it);forme!=NULL;forme=m_tpl_map_forme.get_suivant(it))
  {
    long id = forme->get_id();
    f << id 
      << " " << get_nb_donnee_forme(forme);
    std::multimap< long int,std::string >::iterator it;
    for(std::string donnee = get_premiere_donnee_forme(forme,it);donnee!="";donnee=get_suivante_donnee_forme(forme,it))
    {
      f << " " << donnee;
    }
    f << std::endl;
  }
}
 
void GROUPE_FORME::importer(std::ifstream& f, MG_CG_MODELE* mgcg_modele)
{
  char ligne[10000];
  f.getline(ligne,10000);
  char nom[500];
  sscanf(ligne,"%*s %s",nom);
  m_nom=nom;
  long nb_forme;
  f.getline(ligne,10000);
  sscanf(ligne,"%*s %li",&nb_forme);
  for(long i=0;i<nb_forme;i++)
  {    
    char val[500];
    f.getline(val,500,' ');
    long id_forme;
    sscanf(val,"%li",&id_forme);    
    MG_CG_FORME* forme = mgcg_modele->get_mgcg_formeid(id_forme);
    m_tpl_map_forme.ajouter(forme);
    f.getline(val,500,' ');
    long nb_donnees;
    sscanf(val,"%li",&nb_donnees);
    for(int j=0;j<nb_donnees;j++)
    {
      if(j==nb_donnees-1) f.getline(val,500);
      else f.getline(val,500,' ');
      char chr_donnee[500];
      sscanf(val,"%s",chr_donnee);
      std::string donnee(chr_donnee);
      ajouter_donnee_forme(forme,donnee);
    }
  }
}
 
std::string GROUPE_FORME::get_nom(void)
{
  return m_nom;
}
 
TPL_MAP_ENTITE< MG_CG_FORME* >& GROUPE_FORME::get_tpl_map_forme(void)
{
  return m_tpl_map_forme;
}