occ_cg_op_inclusion_matrice.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/
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//
//####//       occ_cg_op_inclusion_matrice.cpp
//####//
//####//------------------------------------------------------------
//####//------------------------------------------------------------
//####//    COPYRIGHT 2000-2024
//####//  jeu 13 jun 2024 11:58:53 EDT
//####//------------------------------------------------------------
//####//------------------------------------------------------------
#ifdef ALL_OCC
#include "occ_cg_op_inclusion_matrice.h"
#include "occ_ot_cg.h"
#include "mg_definition.h"
#include "occ_fonction_v2017.h"
#include "mg_cg_modele.h"
#include "mg_cg_forme.h"
#include <BRepAlgoAPI_BuilderAlgo.hxx>
OCC_CG_OP_INCLUSION_MATRICE::OCC_CG_OP_INCLUSION_MATRICE(MG_CG_MODELE* mgcg_modele,
                                                         int semantique,
                                                         MG_CG_FORME* mgcg_forme_inclusion_entree,
                                                         MG_CG_FORME* mgcg_forme_matrice_entree): MG_CG_OP_INCLUSION_MATRICE(mgcg_modele,semantique,mgcg_forme_inclusion_entree,mgcg_forme_matrice_entree)
{
 
}
 
OCC_CG_OP_INCLUSION_MATRICE::OCC_CG_OP_INCLUSION_MATRICE(MG_CG_MODELE* mgcg_modele,
                                                         int semantique,
                                                         int etat,
                                                         long unsigned int num,
                                                         MG_CG_FORME* mgcg_forme_inclusion_entree,
                                                         MG_CG_FORME* mgcg_forme_matrice_entree,
                                                         long int id_mgcg_forme_inclusion_sortie,
                                                         long int id_mgcg_forme_matrice_sortie): MG_CG_OP_INCLUSION_MATRICE(mgcg_modele,
                                                                                                                            semantique,
                                                                                                                            etat,
                                                                                                                            num,
                                                                                                                            mgcg_forme_inclusion_entree,
                                                                                                                            mgcg_forme_matrice_entree,
                                                                                                                            id_mgcg_forme_inclusion_sortie,
                                                                                                                            id_mgcg_forme_matrice_sortie)
{
 
}
 
OCC_CG_OP_INCLUSION_MATRICE::OCC_CG_OP_INCLUSION_MATRICE(OCC_CG_OP_INCLUSION_MATRICE& mdd): MG_CG_OP_INCLUSION_MATRICE(mdd)
{
 
}
 
OCC_CG_OP_INCLUSION_MATRICE::~OCC_CG_OP_INCLUSION_MATRICE(void)
{
 
}
 
int OCC_CG_OP_INCLUSION_MATRICE::construire(void)
{
  if(m_mgcg_modele==NULL)
  {
    std::cerr << "*** ERREUR : OCC_CG_OP_INCLUSION_MATRICE::construire_forme -> MG_CG_MODELE NULL ***" << std::endl;
    return FAIL;
  }
  return construire(m_mgcg_modele->get_fusionner_entite_similaire(),
                    m_mgcg_modele->get_precision(),
                    m_mgcg_modele->get_importer_triangulation(),
                    m_mgcg_modele->get_epsilon_triangulation());
}
 
int OCC_CG_OP_INCLUSION_MATRICE::construire(bool fusionner_entite_similaire,
                                            double precision,
                                            bool importer_triangulation,
                                            double epsilon_triangulation)
{
  
  if(m_mgcg_modele==NULL)
  {
    std::cerr << "*** ERREUR : OCC_CG_OP_INCLUSION_MATRICE::construire_forme -> MG_CG_MODELE NULL ***" << std::endl;
    return FAIL;
  }
  BRepAlgoAPI_BuilderAlgo brep_fragment;
  TopTools_ListOfShape list_of_shape_arguments;
  TopTools_ListOfShape list_of_shape_inclusion;
  TopTools_ListOfShape list_of_shape_matrice;
  OCC_OT_CG::get_listofTopoDS_Shape(get_mgcg_forme_inclusion_entree(),list_of_shape_arguments);
  OCC_OT_CG::get_listofTopoDS_Shape(get_mgcg_forme_inclusion_entree(),list_of_shape_inclusion);
  OCC_OT_CG::get_listofTopoDS_Shape(get_mgcg_forme_matrice_entree(),list_of_shape_arguments);
  OCC_OT_CG::get_listofTopoDS_Shape(get_mgcg_forme_matrice_entree(),list_of_shape_matrice);
  brep_fragment.SetArguments(list_of_shape_arguments);
  brep_fragment.Build();
  if(!brep_fragment.IsDone())
  {
    std::cout << "*** ERREUR : OCC_CG_OP_INCLUSION_MATRICE::construire_forme -> ECHEC de BRepAlgoAPI_BuilderAlgo  ***" << std::endl;
    return FAIL;
  }
  TopoDS_Shape shape_resultat = brep_fragment.Shape();
  Bnd_Box box_inclusion;
  Bnd_Box box_matrice;
  TopTools_ListOfShape::Iterator it_shape;
  for(it_shape.Init(list_of_shape_inclusion);it_shape.More();it_shape.Next())
  {
    BRepBndLib::AddOptimal(it_shape.Value(),box_inclusion,false);
  }
  for(it_shape.Init(list_of_shape_matrice);it_shape.More();it_shape.Next())
  {
    BRepBndLib::AddOptimal(it_shape.Value(),box_matrice,false);
  }
  OCC_FONCTION_V2017* occ_fonction_v2017=(OCC_FONCTION_V2017*)&m_mgcg_modele->get_mg_geometrie()->get_occ_fonction();
    
  BRep_Builder brep_builder;
  TopoDS_Compound Compound_inclusion;
  TopoDS_Compound Compound_matrice;
  brep_builder.MakeCompound(Compound_inclusion);
  brep_builder.MakeCompound(Compound_matrice);
  if(shape_resultat.ShapeType()==TopAbs_COMPOUND)
  {
    TopTools_DataMapOfShapeShape map_TopoDS_Solid;
    TopTools_DataMapOfShapeShape map_TopoDS_Shell;
    TopTools_DataMapOfShapeShape map_TopoDS_Face;
    TopTools_DataMapOfShapeShape map_TopoDS_Wire;
    TopTools_DataMapOfShapeShape map_TopoDS_Edge;
    TopTools_DataMapOfShapeShape map_TopoDS_Vertex;
    occ_fonction_v2017->decompose_TopoDS_Compound(TopoDS::Compound(shape_resultat),
                                                  map_TopoDS_Solid,
                                                  map_TopoDS_Shell,
                                                  map_TopoDS_Face,
                                                  map_TopoDS_Wire,
                                                  map_TopoDS_Edge,
                                                  map_TopoDS_Vertex);
    TopTools_DataMapOfShapeShape::Iterator it_solid;
    for(it_solid.Initialize(map_TopoDS_Solid);it_solid.More();it_solid.Next())
    {
      if(est_compris_dans(it_solid.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_solid.Value());
      }
      else brep_builder.Add(Compound_matrice,it_solid.Value());
    }
    TopTools_DataMapOfShapeShape::Iterator it_shell;
    for(it_shell.Initialize(map_TopoDS_Shell);it_shell.More();it_shell.Next())
    {
      if(est_compris_dans(it_shell.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_shell.Value());
      }
      else brep_builder.Add(Compound_matrice,it_shell.Value());
    }
    TopTools_DataMapOfShapeShape::Iterator it_face;
    for(it_face.Initialize(map_TopoDS_Face);it_face.More();it_face.Next())
    {
      if(est_compris_dans(it_face.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_face.Value());
      }
      else brep_builder.Add(Compound_matrice,it_face.Value());
    }
    TopTools_DataMapOfShapeShape::Iterator it_wire;
    for(it_wire.Initialize(map_TopoDS_Wire);it_wire.More();it_wire.Next())
    {
      if(est_compris_dans(it_wire.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_wire.Value());
      }
      else brep_builder.Add(Compound_matrice,it_wire.Value());
    }
    TopTools_DataMapOfShapeShape::Iterator it_edge;
    for(it_edge.Initialize(map_TopoDS_Edge);it_edge.More();it_edge.Next())
    {
      if(est_compris_dans(it_edge.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_edge.Value());
      }
      else brep_builder.Add(Compound_matrice,it_edge.Value());
    }
    TopTools_DataMapOfShapeShape::Iterator it_vertex;
    for(it_vertex.Initialize(map_TopoDS_Vertex);it_vertex.More();it_vertex.Next())
    {
      if(est_compris_dans(it_vertex.Value(),box_inclusion,precision))
      {
        brep_builder.Add(Compound_inclusion,it_vertex.Value());
      }
      else brep_builder.Add(Compound_matrice,it_vertex.Value());
    }    
  }
  else std::cout << "*** ERREUR : OCC_CG_OP_INCLUSION_MATRICE::construire_forme -> ShapeType!=TopAbs_COMPOUND  ***" << std::endl;
  MG_CG_FORME* forme_inclusion_sortie = OCC_OT_CG::creer_MG_CG_FORME(m_mgcg_modele,
                                                                      Compound_inclusion,
                                                                      occ_fonction_v2017,
                                                                      m_mgcg_modele->get_mg_geometrie(),
                                                                      fusionner_entite_similaire,
                                                                      precision,
                                                                      importer_triangulation,
                                                                      epsilon_triangulation);
  m_mgcg_modele->ajouter_mgcg_forme(forme_inclusion_sortie);
  change_mgcg_forme_inclusion_sortie(forme_inclusion_sortie);
  m_mgcg_modele->mise_a_jout_lien_mg_element_mgcg_forme(forme_inclusion_sortie);
  MG_CG_FORME* forme_matrice_sortie = OCC_OT_CG::creer_MG_CG_FORME(m_mgcg_modele,
                                                                    Compound_matrice,
                                                                    occ_fonction_v2017,
                                                                    m_mgcg_modele->get_mg_geometrie(),
                                                                    fusionner_entite_similaire,
                                                                    precision,
                                                                    importer_triangulation,
                                                                    epsilon_triangulation);
  m_mgcg_modele->ajouter_mgcg_forme(forme_matrice_sortie);
  change_mgcg_forme_matrice_sortie(forme_matrice_sortie);
  m_mgcg_modele->mise_a_jout_lien_mg_element_mgcg_forme(forme_matrice_sortie);
  get_mgcg_forme_inclusion_sortie()->change_mgcg_operateur_parent(this);
  get_mgcg_forme_matrice_sortie()->change_mgcg_operateur_parent(this);
  change_etat(MG_CG_OPERATEUR::ETAT_OPERATEUR::CONSTRUIT);
  return OK;
}
 
bool OCC_CG_OP_INCLUSION_MATRICE::est_compris_dans(TopoDS_Shape shape_objet,Bnd_Box box_comparateur,double precision)
{
  Bnd_Box box_objet;
  BRepBndLib::AddOptimal(shape_objet,box_objet,false);
  double x0_obj,y0_obj,z0_obj,x1_obj,y1_obj,z1_obj;
  double x0_comp,y0_comp,z0_comp,x1_comp,y1_comp,z1_comp;
  box_objet.Get(x0_obj,y0_obj,z0_obj,x1_obj,y1_obj,z1_obj);
  box_comparateur.Get(x0_comp,y0_comp,z0_comp,x1_comp,y1_comp,z1_comp);
  if((x0_obj>=(x0_comp-precision)) && (x1_obj<=(x1_comp+precision)))
    if((y0_obj>=(y0_comp-precision)) && (y1_obj<=(y1_comp+precision)))
      if((z0_obj>=(z0_comp-precision)) && (z1_obj<=(z1_comp+precision)))
        return true;
  return false;
  
  
  
}
 
 
#endif