mg_arbre.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_arbre.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
 
 
#include "gestionversion.h"
#include <fstream>
#include <iostream>
 
 
#include "mg_arbre.h"
#include "mg_primitive.h"
#include "mg_operateur_boolean.h"
#include "mg_assemblage.h"
#include "mg_gestionnaire.h"
#include "occ_import.h"
 
 
#include <Standard_TypeDef.hxx>
#include <Standard_Macro.hxx>
#include <TopoDS_Shape.hxx>
#include <BRepTools.hxx>
#include <BRep_Builder.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>
#include <XCAFDoc_ShapeTool.hxx>
#include <XCAFDoc_DocumentTool.hxx>
#include <STEPCAFControl_Writer.hxx>
#include <TDocStd_Document.hxx>
#include <XCAFApp_Application.hxx>
#include <XCAFDoc_ShapeTool.hxx>
 
 
 
MG_ARBRE::MG_ARBRE(std::string nm):MG_IDENTIFICATEUR(),nom(nm)
{
}
 
 
 
MG_ARBRE::MG_ARBRE(long unsigned int num,std::string nm): MG_IDENTIFICATEUR(num),nom(nm)
{
}
 
 
 
MG_ARBRE::MG_ARBRE(MG_ARBRE& mdd):MG_IDENTIFICATEUR(mdd),nom(mdd.nom)
{
}
 
 
 
 
MG_ARBRE::~MG_ARBRE()
{
supprimer_tout_mg_operateur_boolean();
supprimer_tout_mg_primitive();
}
 
 
 
void MG_ARBRE::change_gestionnaire(MG_GESTIONNAIRE* mggest)
{
    gest=mggest;
}
 
int MG_ARBRE::ajouter_mg_primitive(MG_PRIMITIVE* mgprim)
{
    gest->recherche_bonid(*mgprim);
    MG_IDENTIFICATEUR *id=mgprim;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }
 
    std::pair<const unsigned long,MG_PRIMITIVE*> tmp(mgprim->get_id(),mgprim);
    lst_mg_primitive.insert(tmp);
    return OK;
}
 
 
 
 
MG_PRIMITIVE* MG_ARBRE::get_mg_primitiveid(unsigned long num)
{
    LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.find(num);
    if (i==lst_mg_primitive.end())
    {
        return NULL;
    }
    return ((*i).second);
}
 
 
 
MG_PRIMITIVE* MG_ARBRE::get_mg_primitive(unsigned int num)
{
    if (!(num<lst_mg_primitive.size()))
    {
        return NULL;
    }
    LISTE_MG_PRIMITIVE::iterator i=lst_mg_primitive.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}
 
 
 
unsigned int MG_ARBRE::get_nb_mg_primitive(void)
{
    return lst_mg_primitive.size();
}
 
 
int MG_ARBRE::supprimer_mg_primitiveid(unsigned long num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitiveid(num);
    if (mgprim==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.find(num);
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}
 
 
int MG_ARBRE::supprimer_mg_primitive(unsigned int num)
{
    MG_PRIMITIVE* mgprim=get_mg_primitive(num);
    if (mgprim==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgprim;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_primitive.erase(j);
    delete mgprim;
    return OK;
}
 
 
void MG_ARBRE::supprimer_tout_mg_primitive(void)
{
    while (get_nb_mg_primitive()!=0)
    {
        LISTE_MG_PRIMITIVE::iterator j=lst_mg_primitive.begin();
        MG_PRIMITIVE* mgprim=(*j).second;
        MG_IDENTIFICATEUR* id=mgprim;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_primitive.erase(j);
        delete mgprim;
    }
}
 
 
MG_PRIMITIVE* MG_ARBRE::get_premier_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it = lst_mg_primitive.begin();
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}
 
MG_PRIMITIVE* MG_ARBRE::get_suivant_primitive(LISTE_MG_PRIMITIVE::iterator & it)
{
    it++;
    if (it == lst_mg_primitive.end())
        return NULL;
    return it->second;
}
 
int MG_ARBRE::ajouter_mg_operateur_boolean(MG_OPERATEUR_BOOLEAN* mgop)
{
    gest->recherche_bonid(*mgop);
    MG_IDENTIFICATEUR *id=mgop;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }
 
    std::pair<const unsigned long,MG_OPERATEUR_BOOLEAN*> tmp(mgop->get_id(),mgop);
    lst_mg_operateur_boolean.insert(tmp);
    return OK;
}
 
 
 
 
MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_booleanid(unsigned long num)
{
    LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.find(num);
    if (i==lst_mg_operateur_boolean.end())
    {
        return NULL;
    }
    return ((*i).second);
}
 
 
 
MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_mg_operateur_boolean(unsigned int num)
{
    if (!(num<lst_mg_operateur_boolean.size()))
    {
        return NULL;
    }
    LISTE_MG_OPERATEUR_BOOLEAN::iterator i=lst_mg_operateur_boolean.begin();
    for (unsigned long j=0;j<num;j++) i++;
    return ((*i).second);
}
 
 
 
unsigned int MG_ARBRE::get_nb_mg_operateur_boolean(void)
{
    return lst_mg_operateur_boolean.size();
}
 
 
int MG_ARBRE::supprimer_mg_operateur_booleanid(unsigned long num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_booleanid(num);
    if (mgop==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.find(num);
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}
 
 
int MG_ARBRE::supprimer_mg_operateur_boolean(unsigned int num)
{
    MG_OPERATEUR_BOOLEAN* mgop=get_mg_operateur_boolean(num);
    if (mgop==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgop;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
    for (unsigned int k=0;k<num;k++) j++;
    lst_mg_operateur_boolean.erase(j);
    delete mgop;
    return OK;
}
 
 
void MG_ARBRE::supprimer_tout_mg_operateur_boolean(void)
{
    while (get_nb_mg_operateur_boolean()!=0)
    {
        LISTE_MG_OPERATEUR_BOOLEAN::iterator j=lst_mg_operateur_boolean.begin();
        MG_OPERATEUR_BOOLEAN* mgop=(*j).second;
        MG_IDENTIFICATEUR* id=mgop;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_operateur_boolean.erase(j);
        delete mgop;
    }
}
 
 
MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_premier_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it = lst_mg_operateur_boolean.begin();
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}
 
MG_OPERATEUR_BOOLEAN* MG_ARBRE::get_suivant_operateur_boolean(LISTE_MG_OPERATEUR_BOOLEAN::iterator & it)
{
    it++;
    if (it == lst_mg_operateur_boolean.end())
        return NULL;
    return it->second;
}
 
int MG_ARBRE::ajouter_mg_assemblage(MG_ASSEMBLAGE* mgassembl)
{
    gest->recherche_bonid(*mgassembl);
    MG_IDENTIFICATEUR *id=mgassembl;
    std::pair<LISTE_ENTITE::iterator,bool> p=lst_entite.insert(id);
    if (!p.second)
    {
        return FAIL;
    }
 
    std::pair<const unsigned long,MG_ASSEMBLAGE*> tmp(mgassembl->get_id(),mgassembl);
    lst_mg_assemblage.insert(tmp);
    return OK;
}
 
MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblage(unsigned int num)
{
    LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
    if (i==lst_mg_assemblage.end())
    {
        return NULL;
    }
    return ((*i).second);
}
 
MG_ASSEMBLAGE* MG_ARBRE::get_mg_assemblageid(long unsigned int num)
{
    LISTE_MG_ASSEMBLAGE::iterator i=lst_mg_assemblage.find(num);
    if (i==lst_mg_assemblage.end())
    {
        return NULL;
    }
    return ((*i).second);
}
 
unsigned int MG_ARBRE::get_nb_mg_assemblage(void)
{
    return lst_mg_assemblage.size();
}
 
MG_ASSEMBLAGE* MG_ARBRE::get_premier_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
{
    it = lst_mg_assemblage.begin();
    if (it == lst_mg_assemblage.end())
        return NULL;
    return it->second;
}
 
MG_ASSEMBLAGE* MG_ARBRE::get_suivant_assemblage(LISTE_MG_ASSEMBLAGE::iterator & it)
{
    it++;
    if (it == lst_mg_assemblage.end())
        return NULL;
    return it->second;
}
 
int MG_ARBRE::supprimer_mg_assemblage(unsigned int num)
{
    MG_ASSEMBLAGE* mgassembl=get_mg_assemblage(num);
    if (mgassembl==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgassembl;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
    lst_mg_assemblage.erase(j);
    delete mgassembl;
    return OK;
}
 
int MG_ARBRE::supprimer_mg_assemblageid(long unsigned int num)
{
    MG_ASSEMBLAGE* mgassembl=get_mg_assemblageid(num);
    if (mgassembl==NULL)
    {
        return FAIL;
    }
    MG_IDENTIFICATEUR* id=mgassembl;
    LISTE_ENTITE::iterator i=lst_entite.find(id);
    lst_entite.erase(i);
    LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.find(num);
    lst_mg_assemblage.erase(j);
    delete mgassembl;
    return OK;
}
 
void MG_ARBRE::supprimer_tout_mg_assemblage(void)
{
    while (get_nb_mg_assemblage()!=0)
    {
        LISTE_MG_ASSEMBLAGE::iterator j=lst_mg_assemblage.begin();
        MG_ASSEMBLAGE* mgassembl=(*j).second;
        MG_IDENTIFICATEUR* id=mgassembl;
        LISTE_ENTITE::iterator i=lst_entite.find(id);
        lst_entite.erase(i);
        lst_mg_assemblage.erase(j);
        delete mgassembl;
    }
}
 
MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(char *nom_fichier,bool export_step,bool import_stl,double precision,double eps)
{
  int nb_primitive = get_nb_mg_primitive();
  char nom_fichier_brep[500];
  strcpy(nom_fichier_brep,nom_fichier);
  strcat(nom_fichier_brep,".brep");
  BRepTools::Write(get_mg_primitive(nb_primitive-1)->get_forme(),nom_fichier_brep);
  if(export_step==true)
  {
    char nom_fichier_step[500];
    strcpy(nom_fichier_step,nom_fichier);
    strcat(nom_fichier_step,".step");
    Handle(TDocStd_Document) Doc;
    Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
    App->NewDocument("MDTV-XCAF",Doc);  
    Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
    STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
    TDF_Label Label_shape = myShapeTool->NewShape();
    myShapeTool->SetShape(Label_shape, get_mg_primitive(nb_primitive-1)->get_forme());
    myWriter->Perform(Doc,nom_fichier_step);
  }
  OCC_IMPORT occimport;
  MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
  if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);  
  return mggeo;
}
 
 
MG_GEOMETRIE* MG_ARBRE::evaluer_geometrie(MG_ASSEMBLAGE* mgassembl, char* nom_fichier, bool avecfusion,bool export_step, bool import_stl, double precision, double eps)
{  
  char nom_fichier_brep[500];
  char nom_fichier_step[500];
  strcpy(nom_fichier_brep,nom_fichier);
  strcat(nom_fichier_brep,".brep");
  long nb_primitive = mgassembl->get_nb_mg_primitive();
  if(nb_primitive==1)
  {
    BRepTools::Write(mgassembl->get_mg_primitive(0)->get_forme(),nom_fichier_brep);
    if(export_step==true)
    {      
      strcpy(nom_fichier_step,nom_fichier);
      strcat(nom_fichier_step,".step");
      Handle(TDocStd_Document) Doc;
      Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
      App->NewDocument("MDTV-XCAF",Doc);  
      Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
      STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
      TDF_Label Label_shape = myShapeTool->NewShape();
      myShapeTool->SetShape(Label_shape, mgassembl->get_mg_primitive(nb_primitive-1)->get_forme());
      myWriter->Perform(Doc,nom_fichier_step);
    }
  }
  if(nb_primitive>1)
  {
    BRep_Builder constructeur_brep;
    TopoDS_Compound groupe_primitive;
    constructeur_brep.MakeCompound(groupe_primitive);
    for(long i=0;i<nb_primitive;i++)
    {
      constructeur_brep.Add(groupe_primitive,mgassembl->get_mg_primitive(i)->get_forme());
    }
    BRepTools::Write(groupe_primitive,nom_fichier_brep);
    if(export_step==true)
    {
      strcpy(nom_fichier_step,nom_fichier);
      strcat(nom_fichier_step,".step");
      Handle(TDocStd_Document) Doc;
      Handle(XCAFApp_Application) App = XCAFApp_Application::GetApplication();
      App->NewDocument("MDTV-XCAF",Doc); 
      Handle (XCAFDoc_ShapeTool) myShapeTool = XCAFDoc_DocumentTool::ShapeTool(Doc->Main());
      STEPCAFControl_Writer *myWriter = new STEPCAFControl_Writer();
      TDF_Label Label_shape = myShapeTool->NewShape();
      myShapeTool->SetShape(Label_shape, groupe_primitive);
      myWriter->Perform(Doc,nom_fichier_step);
    }
  }
  OCC_IMPORT occimport;
  MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_brep,FICHIEROCC,precision);
  //MG_GEOMETRIE* mggeo=occimport.importer(*gest,nom_fichier_step,FICHIERSTEP,precision);
  if (avecfusion) occimport.fusionne(mggeo);
  if(import_stl==true) occimport.importer(*gest,mggeo,eps,2);  
  return mggeo;
}
 
 
 
 
MG_GESTIONNAIRE* MG_ARBRE::get_gestionnaire(void)
{
    return gest;
}
 
void MG_ARBRE::enregistrer(std::ostream& o,double version)
{
o << "%" << get_id() << "=ARBRE("<< nom.c_str() <<");" << std::endl;  
LISTE_ENTITE::const_iterator i;
for (i=lst_entite.begin();i!=lst_entite.end();i++)
    {
        MG_IDENTIFICATEUR* entite = *i;
        entite->enregistrer(o,version);
    }
 
}
 
void MG_ARBRE::get_fichier_dependant(std::vector<std::string> &liste_fichier)
{
    LISTE_ENTITE::const_iterator i;
    for (i=lst_entite.begin();i!=lst_entite.end();i++)
        (*i)->get_fichier_dependant(liste_fichier);
}