+++ /dev/null
-# -*- coding: utf-8 -*-
-# Copyright (C) 2016-2021 CEA/DEN, EDF R&D
-#
-# This library is free software; you can redistribute it and/or
-# modify it under the terms of the GNU Lesser General Public
-# License as published by the Free Software Foundation; either
-# version 2.1 of the License, or (at your option) any later version.
-#
-# This library is distributed in the hope that it will be useful,
-# but WITHOUT ANY WARRANTY; without even the implied warranty of
-# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
-# Lesser General Public License for more details.
-#
-# You should have received a copy of the GNU Lesser General Public
-# License along with this library; if not, write to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
-#
-# See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
-#
-"""Obtention des surfaces médianes à partir d'un objet GEOM ou SHAPER
-
-On sait traiter les faces :
- . planes
- . cylindriques
- . sphériques
- . toriques
- . coniques
-
-Version initiale par :
-alexandre.prunie@blastsolutions.io
-guillaume.schweitzer@blastsolutions.io
-
-Gérald NICOLAS
-+33.1.78.19.43.52
-"""
-
-__revision__ = "V10.09"
-
-#========================= Les imports - Début ===================================
-
-import os
-import sys
-import tempfile
-
-import salome
-import SALOMEDS
-from salome.shaper import model
-from salome.geom import geomBuilder
-from salome.geom import geomtools
-from salome.kernel.studyedit import getStudyEditor
-
-import numpy as np
-
-#========================== Les imports - Fin ====================================
-
-D_FMT = dict()
-D_FMT["stp"] = ["stp", "step"]
-D_FMT["igs"] = ["igs", "iges"]
-for CLE in ("brep", "xao"):
- D_FMT[CLE] = [CLE]
-
-#========================= Début de la fonction ==================================
-
-def decode_cao (fmt_cao):
- """Décode le format de la cao
-
-Entrées :
- :fmt_cao: format du fichier, step, iges, etc.
-Sorties :
- :fmt_cao_0: format décodé
- """
-
- fmt_cao_0 = ""
-
- fmt_cao_low = fmt_cao.lower()
-
- for cle, l_aux in D_FMT.items():
- if ( fmt_cao_low in l_aux ):
- fmt_cao_0 = cle
- break
-
- return fmt_cao_0
-
-#========================= Fin de la fonction ===================================
-
-#========================= Début de la fonction ==================================
-
-def import_cao (part_doc, ficcao, verbose=False):
- """Importation d'une cao
-
-Entrées :
- :part_doc: part
- :ficcao: le fichier de la CAO
-Sorties :
- :objet: l'objet importé dans SHAPER
- """
-
-
- erreur = 0
- message = "Fichier '{}'\n".format(ficcao)
- if verbose:
- print (message)
-
- objet = None
-
- laux = ficcao.split(".")
- fmt_cao_0 = decode_cao (laux[-1])
-
- if ( fmt_cao_0 not in ("stp", "brep", "igs", "xao") ):
- message += "Le format de CAO est inconnu"
- erreur = 1
-
- elif not ficcao:
- message += "Le fichier de CAO n'a pas été décodé correctement."
- erreur = 2
-
- elif not os.path.isfile(ficcao):
- message += "Le fichier de CAO est inconnu."
- erreur = 3
-
- else:
-
- message = ""
- objet = model.addImport(part_doc, ficcao)
- objet.execute(True)
- model.do()
-
- if verbose:
- texte = "Objet : '{}'\n".format(objet.result().name())
- texte += "De type : '{}'".format(objet.result().shapeType())
- print (texte)
-
-
- return erreur, message, objet
-
-#========================= Fin de la fonction ===================================
-
-#=================================== La classe ===================================
-
-class SurfaceMediane (object):
-
- """Calcul des surfaces médianes de solides minces
-
-L'objectif de ce programme est de créer les surfaces médianes, encore appelées fibres neutres, pour \
-une structure qui est un solide ou un assemblage de solides (compound).
-Pour réaliser l'opération, deux façons de faire :
-
-1. On sélectionne la structure dans l'arbre d'étude ou dans la fenêtre graphique de GEOM, puis on lance le script.
-
-2. On écrit un script python dans lequel on réalise la création ou l'importation d'une CAO. \
-On insère cette classe dans le script, puis on lance surf_fic_cao, surf_objet_shaper ou surf_objet_geom selon le point de départ.
-
-Le programme crée les surfaces sous réserve que pour le solide envisagé, il a réussi à trouver deux faces \
-de taille identique et supérieure aux autres faces du solide pour des polyèdres ou \
-s'il a reconnu des formes canoniques.
-Il crée alors une surface au milieu de ces deux grandes faces. Cette face est coloriée en vert.
-
-Si les 2 faces les plus grandes sont planes mais que leurs tailles ne sont pas identiques, le programme \
-crée néanmoins une face basée sur la plus grande de ces faces. Un message est émis et cette face médiane \
-est coloriée en bleu. Le volume correspondant n'est pas détruit et est colorié en rouge.
-
-On sait traiter les faces :
- . planes
- . cylindriques
- . sphériques
- . toriques
- . coniques
-
-Options obligatoires
-********************
-Aucune
-
-Options facultatives
-********************
-. Suppression des solides et faces créés par l'explosion des objets. Par défaut, la suppression est faite.
--menage/-no_menage
-
-. Retour dans Shaper. Par défaut, les faces restent dans GEOM.
--retour_shaper/-no_retour_shaper
-
- """
-
-# A. La base
-
- message_info = ""
- _verbose = 0
- _verbose_max = 0
- affiche_aide_globale = 0
- _menage = True
-
-# B. Les variables
-
- _choix_objet = 0
- _retour_shaper = False
- nom_solide = None
- epsilon = 5.e-3
- part_doc = None
-
- ficcao = None
- rep_trav = None
- objet_geom = None
-
- l_faces_trans = list()
-
- faces_pb_nb = 0
- faces_pb_msg = ""
-
-#=========================== Début de la méthode =================================
-
- def __init__ ( self, liste_option ):
-
- """Le constructeur de la classe SurfaceMediane
-
-Décodage des arguments
-On cherche ici les arguments généraux : aide, verbeux
- """
-
- for option in liste_option :
-
- #print (option)
- if isinstance(option,str):
- saux = option.upper()
- #print (saux)
- if saux in ( "-H", "-HELP" ):
- self.affiche_aide_globale = 1
- elif saux == "-V" :
- self._verbose = 1
- elif saux == "-VMAX" :
- self._verbose = 1
- self._verbose_max = 1
- elif saux == "-MENAGE" :
- self._menage = True
- elif saux == "-NO_MENAGE" :
- self._menage = False
- elif saux == "-RETOUR_SHAPER":
- self._retour_shaper = True
- elif saux == "-NO_RETOUR_SHAPER":
- self._retour_shaper = False
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def __del__(self):
- """A la suppression de l'instance de classe"""
- if self._verbose_max:
- print ("Suppression de l'instance de la classe.")
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _selection_objet_graphique ( self, geompy ):
- """Sélectionne l'objet dans la fenêtre graphique
-
-Entrées :
- :geompy: environnement de GEOM
-
-Sorties :
- :objet: objet à traiter
- """
-
- nom_fonction = __name__ + "/_selection_objet_graphique"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- erreur = 0
- message = ""
- objet = None
-
- while ( not erreur ):
-
-# 1. Contrôle du nombre d'objets sélectionnés graphiquement
- nb_objet = salome.sg.SelectedCount()
- if self._verbose_max:
- print (blabla+"Nombre d'objets sélectionnés : {}.".format(nb_objet))
-
- if ( nb_objet != 1 ):
- message = "Nombre d'objets sélectionnés : {}.\nIl en faut un et un seul.".format(nb_objet)
- erreur = 1
- break
-
-# 2. Récupération de l'ID de l'objet en cours
- entry = salome.sg.getSelected(0)
-# Récupération de l'objet
- objet = salome.myStudy.FindObjectID( entry ).GetObject()
- if self._verbose_max:
- print (geompy.WhatIs(objet))
-
- break
-
- return erreur, message, objet
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _les_solides ( self, geompy, objet ):
- """Les solides de l'objet à traiter
-
-Entrées :
- :geompy: environnement de GEOM
- :objet: l'objet à traiter
-
-Sorties :
- :l_solides: liste des solides de la sélection
- """
-
- nom_fonction = __name__ + "/_les_solides"
- blabla = "\nDans {} :\n".format(nom_fonction)
- if self._verbose_max:
- print (blabla)
-
- erreur = 0
- message = ""
- l_solides = list()
-
- while ( not erreur ):
-
-# 1. Nombre de solides composant l'objet à traiter
- d_shape_info = geompy.ShapeInfo(objet)
- n_solides = d_shape_info["SOLID"]
- if self._verbose_max:
- print ("Nombre de solides : {}".format(n_solides))
-
- nom_objet = objet.GetName()
- if self._verbose:
- print (". Traitement de l'objet '{}'".format(nom_objet))
-
-# 2. Liste des solides qui composent l'objet
- if ( n_solides == 0 ):
- message = "Aucun solide dans l'objet sélectionné."
- erreur = 1
- break
- elif ( n_solides == 1 ):
- l_solides.append(objet)
- else:
- l_solides = geompy.ExtractShapes(objet, geompy.ShapeType["SOLID"], True)
- for iaux, solide in enumerate(l_solides):
- geompy.addToStudyInFather( objet, solide, "{}_{:03d}".format(nom_objet,iaux+1) )
- if self._verbose_max:
- print ("l_solides : {}.".format(l_solides))
- for iaux, solide in enumerate(l_solides):
- print (geompy.WhatIs(solide))
-
- break
-
- return erreur, message, l_solides
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _faces_du_solide ( self, geompy, solide ):
- """Détermine les faces d'un solide
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: le solide à traiter
-
-Sorties :
- :l_faces: liste des faces du solide
- """
-
- nom_fonction = __name__ + "/_faces_du_solide"
- blabla = "\nDans {} :\n".format(nom_fonction)
- if self._verbose_max:
- print (blabla)
-
- erreur = 0
- message = ""
- l_faces = list()
-
- while ( not erreur ):
-
- self.nom_solide = solide.GetName()
- if self._verbose:
- print (".. Traitement du solide '{}'".format(self.nom_solide))
-
-# 1. Le solide est-il un solide unique ?
- if self._verbose_max:
- print (geompy.WhatIs(solide))
- longueur, aire, volume = geompy.BasicProperties(solide)
- if self._verbose_max:
- print (". longueur, aire, volume : {}, {}, {}".format(longueur,aire,volume))
-# Contrôle du solide
- d_shape_info = geompy.ShapeInfo(solide)
- n_solides = d_shape_info["SOLID"]
- if self._verbose_max:
- print ("Nombre de solides : {}".format(n_solides))
- if ( n_solides != 1 ):
- message = "Nombre de solides : {}.\nIl en faut un et un seul.".format(n_solides)
- erreur = 1
- break
-
-# 2. Liste des faces qui composent le solide
- l_faces = geompy.ExtractShapes(solide, geompy.ShapeType["FACE"], True)
- for iaux, face in enumerate(l_faces):
- geompy.addToStudyInFather( solide, face, "Face_{}".format(iaux+1) )
- if self._verbose_max:
- print ("l_faces : {}".format(l_faces))
- for iaux, face in enumerate(l_faces):
- print (geompy.WhatIs(face))
-
- break
-
- return erreur, message, l_faces
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _calcul_caract_faces ( self, geompy, l_faces ):
- """Calcule les caractéristiques géométriques des faces
-
-Entrées :
- :geompy: environnement de GEOM
- :l_faces: liste des faces du solide
-
-Sorties :
- :tb_caract: tableau des caractéristiques géométriques des faces
- """
-
- nom_fonction = __name__ + "/_calcul_caract_faces"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- nb_faces = len(l_faces)
- if self._verbose_max:
- print (blabla+"Nombre de faces : {}.".format(nb_faces))
-
- tb_caract = np.zeros((nb_faces,3), dtype = 'object')
- for iaux, face in enumerate(l_faces):
- _, aire, _ = geompy.BasicProperties(face)
- #longueur, aire, volume = geompy.BasicProperties(face)
- if self._verbose_max:
- texte = "\t. Face numéro {}".format(iaux)
- #texte += "\n\t. longueur, aire, volume : {}, {}, {}".format(longueur,aire,volume)
- print (texte)
-
- tb_caract [iaux][0] = face
- tb_caract [iaux][1] = aire
- tb_caract [iaux][2] = geompy.KindOfShape(face)
- if self._verbose_max:
- print ("\t. tb_caract : {} {}".format(aire,tb_caract[iaux][2]))
-
- return tb_caract
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _tri_faces ( self, tb_caract ):
- """Trie les faces en fonction de leurs surfaces
-
-Entrées :
- :geompy: environnement de GEOM
-
-Sorties :
- :tb_caract_1[-1], tb_caract_1[-2]: les caractéristiques des 2 faces les plus grandes
- """
-
- erreur = 0
- message = ""
-
- nom_fonction = __name__ + "/_tri_faces"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Tri du tableau en fonction des surfaces
- if self._verbose_max:
- print (blabla+"tb_caract brut : {}".format(tb_caract))
- tb_caract_1 = sorted(tb_caract, key=lambda colonnes: colonnes[1])
- if self._verbose_max:
- print ("tb_caract trié : {}".format(tb_caract_1))
-
- if self._verbose:
- texte = "\tSurface de la plus grande face : {}, de caractéristiques {}\n".format(tb_caract_1[-1][1],tb_caract_1[-1][2])
- texte += "\tSurface de la face suivante : {}, de caractéristiques {}".format(tb_caract_1[-2][1],tb_caract_1[-2][2])
- print (texte)
-
-# La surface suivante doit être différente, sinon ce n'est pas un solide mince
- if ( np.abs((tb_caract_1[-1][1]-tb_caract_1[-3][1])/tb_caract_1[-1][1]) < self.epsilon ):
- message += ". Surface de la plus grande face : {}\n".format(tb_caract_1[-1][1])
- message += ". Surface de la face suivante : {}\n".format(tb_caract_1[-2][1])
- message += ". Surface de la 3ème face suivante : {}\n".format(tb_caract_1[-3][1])
- message += "==> L'écart est trop faible.\n"
- message += "Impossible de créer la face médiane pour le solide '{}' ".format(self.nom_solide)
- message += "car le solide n'est pas assez mince."
- erreur = -1
-
- return erreur, message, tb_caract_1[-1], tb_caract_1[-2]
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _calcul_caract_aretes_face ( self, geompy, caract_face ):
- """Détermine les caractéristiques des arêtes d'une face
-
-Entrées :
- :geompy: environnement de GEOM
- :caract_face: les caractéristiques de la face
-
-Sorties :
- :caract_arete_face: les caractéristiques des arêtes de la face
- """
-
- nom_fonction = __name__ + "/_calcul_caract_aretes_face"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- texte += "face : {}\n".format(caract_face)
- print (texte)
-
-# Détermination des arêtes pour chaque face
- face = caract_face[0]
- l_aretes = geompy.ExtractShapes(face, geompy.ShapeType["EDGE"], True)
- caract_arete_face = list()
- for arete in l_aretes:
- caract_arete_face.append(geompy.KindOfShape(arete))
-
- if self._verbose_max:
- print ("Aretes de la face : {}".format(caract_arete_face))
-
- return caract_arete_face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- erreur = 0
- message = ""
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
- while not erreur:
-
-# 1. Forme de la face
- forme = caract_face_1[2][0]
- if self._verbose_max:
- print ("forme = {}".format(forme) )
-
-# 2. Traitement selon la forme de la face
-# 2.1. Face plane
- if forme in ( geompy.kind.DISK_CIRCLE, geompy.kind.DISK_ELLIPSE, geompy.kind.POLYGON, geompy.kind.PLANE, geompy.kind.PLANAR):
- erreur, message, face = self._cree_face_mediane_polygone ( geompy, caract_face_1, caract_face_2 )
-
-# 2.2. Face cylindrique
- elif forme == geompy.kind.CYLINDER2D:
- face = self._cree_face_mediane_cylindre ( geompy, solide, caract_face_1, caract_face_2 )
-
-# 2.3. Face sphérique
- elif forme == geompy.kind.SPHERE2D:
- face = self._cree_face_mediane_sphere ( geompy, solide, caract_face_1, caract_face_2 )
-
-# 2.4. Face torique
- elif forme == geompy.kind.TORUS2D:
- face = self._cree_face_mediane_tore ( geompy, solide, caract_face_1, caract_face_2 )
-
-# 2.5. Face conique
- elif forme == geompy.kind.CONE2D:
- face = self._cree_face_mediane_cone ( geompy, solide, caract_face_1, caract_face_2 )
-
-# 2.N. Face de forme inconnue
- else:
- self.faces_pb_msg += "Impossible de créer la face médiane pour le solide '{}' ".format(self.nom_solide)
- self.faces_pb_msg += "car sa face la plus grande est de forme : {}\n".format(forme)
- self.faces_pb_nb += 1
-
-# 3. Gestion de la face produite
-
- if face is not None:
- erreur, message = self._cree_face_mediane_0 ( geompy, face )
-
- break
-
- return erreur, message, face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_0 ( self, geompy, face ):
- """Gestion de la face médiane créée entre deux autres
-
-Entrées :
- :geompy: environnement de GEOM
- :face: la face médiane créée
- """
- erreur = 0
- message = ""
-
- nom_fonction = __name__ + "/_cree_face_mediane_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- print (texte)
-
- while not erreur:
-
-# 3.1. Insertion dans l'étude
- nom_face = self.nom_solide+"_M"
- geompy.addToStudy (face,nom_face)
-
-# 3.2. Transfert éventuel de GEOM vers SHAPER
- if self._retour_shaper:
-
-# 3.2.1. Le fichier doit être différent à chaque fois
- #print ("l_faces_trans = {}".format(self.l_faces_trans))
- nom_fic = nom_face
- iaux = 0
- while True:
- if nom_fic in self.l_faces_trans:
- nom_fic = "{}_{}".format(nom_face,iaux)
- iaux += 1
- else:
- break
- self.l_faces_trans.append(nom_fic)
- fichier = os.path.join(self.rep_trav, "{}.stp".format(nom_fic))
-
-# 3.2.2. Exportation depuis GEOM
- if self._verbose_max:
- texte = "Exportation depuis GEOM de la face médiane '{}' dans le fichier {}".format(nom_face,fichier)
- print (texte)
- try:
- geompy.ExportSTEP (face, fichier)
- except OSError as err:
- print (err)
- message += "Impossible d'exporter la face médiane '{}' dans le fichier {}".format(nom_face,fichier)
- erreur = 1
- break
-
-# 3.2.3. Importation dans SHAPER
- if self._verbose_max:
- texte = "Importation dans SHAPER de la face médiane '{}' depuis le fichier {}".format(nom_face,fichier)
- print (texte)
- face_mediane = model.addImportSTEP(self.part_doc, fichier, False, False, False)
- face_mediane.execute(True)
- model.do()
-
-# Le nom
- face_mediane.setName(nom_face)
- face_mediane.result().setName(nom_face)
-
-# La couleur. Attention aux conventions différents entr GEOM et SHAPER
- while True:
- tbaux = np.array(face.GetColor()._tuple())
- np_aux = (tbaux<0.).nonzero()
- if np.any(np_aux):
- break
- np_aux = (tbaux>1.).nonzero()
- if np.any(np_aux):
- break
- tbaux *= 255.
- face_mediane.result().setColor(int(tbaux[0]), int(tbaux[1]), int(tbaux[2]))
- break
-
- break
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_polygone ( self, geompy, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des polygones
-
-Entrées :
- :geompy: environnement de GEOM
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- erreur = 0
- message = ""
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_polygone"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- while not erreur:
-
-# Les deux faces
- face_1 = caract_face_1[0]
- face_2 = caract_face_2[0]
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Les 2 surfaces doivent être les mêmes, sinon c'est qu'elles ne sont pas similaires
- ecart = np.abs((caract_face_1[1]-caract_face_2[1])/caract_face_1[1])
- if ( ecart > self.epsilon ):
- if self._verbose:
- message += ". Surface de la plus grande face : {}\n".format(caract_face_1[1])
- message += ". Surface de la face suivante : {}\n".format(caract_face_2[1])
-
-# Distance entre les deux faces
- d_face_1_2 = geompy.MinDistance(face_1, face_2)
- if self._verbose:
- print ("\tDistance entre les deux faces = {}".format(d_face_1_2))
-
-# Copie de la plus grande face
- face_1_copie= geompy.MakeCopy(face_1)
- if self._verbose_max:
- geompy.addToStudy(face_1_copie, face_1.GetName()+"_copie" )
-
-# On la translate d'une demi épaisseur
-# Attention : les normales des faces issues de l'explosion du solide sont dirigées vers l'extérieur.
-# Comme il faut translater la face vers l'intérieur, on le fait avec une distance négative.
- vnorm_face_1_copie = geompy.GetNormal(face_1_copie)
- face = geompy.TranslateVectorDistance (face_1_copie, vnorm_face_1_copie, -0.5*d_face_1_2)
-
-# Si les 2 surfaces ne sont pas similaires, on a quand même tenté la création mais on le signale
- if ( ecart > self.epsilon ):
- face.SetColor(SALOMEDS.Color(0,0,1))
- message += "Problème pour créer la face médiane pour le solide '{}' : ".format(self.nom_solide)
- message += "ce n'est pas un véritable polyèdre."
- if self._verbose:
- message += "\nL'écart de surface entre les 2 plus grandes faces est trop grand : {:5.2f}%.\n".format(ecart*100.)
- message += "Tentative de création à partir de la plus grande des faces du solide."
- erreur = -2
- else:
- face.SetColor(SALOMEDS.Color(0,1,0))
-
- break
-
- return erreur, message, face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cylindre ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des cylindres
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_cylindre"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Caractéristiques des cylindres
- coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur = self._cree_face_mediane_cylindre_0 ( geompy, solide, caract_face_1, caract_face_2 )
-
-# Création de la face
- centre, axe, cylindre = self._cree_face_mediane_cylindre_1 ( geompy, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur )
-
-# Gestion de l'intersection avec le solide initial
- face = self._cree_face_mediane_cylindre_2 ( geompy, solide, centre, axe, cylindre )
-
-# Couleur verte
- face.SetColor(SALOMEDS.Color(0,1,0))
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cylindre_0 ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des cylindres
-
-Décodage des caractéristiques
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :coo_x, coo_y, coo_z: coordonnées du centre de la base
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon: rayon moyen entre les deux faces
- :hauteur: hauteur du cylindre
- """
-
- nom_fonction = __name__ + "/_cree_face_mediane_cylindre_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Coordonnées du centre de la base
- coo_x = caract_face_1[2][1]
- coo_y = caract_face_1[2][2]
- coo_z = caract_face_1[2][3]
-# Coordonnées de l'axe
- axe_x = caract_face_1[2][4]
- axe_y = caract_face_1[2][5]
- axe_z = caract_face_1[2][6]
-# Rayons
- rayon = (caract_face_2[2][7]+caract_face_1[2][7])/2.
-# Hauteur : la diagonale de la boîte englobante permet d'être certain de tout prendre
- hauteur = self._calcul_hauteur_englobante ( geompy, solide )
-
- return coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cylindre_1 ( self, geompy, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur ):
- """Crée la face médiane entre deux autres - cas des cylindres
-
-Création des objets temporaires et de la face externe du cylindre support
-
-Entrées :
- :geompy: environnement de GEOM
- :coo_x, coo_y, coo_z: coordonnées du centre de la base
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon: rayon moyen entre les deux faces
- :hauteur: hauteur du cylindre
-
-Sorties :
- :centre: le centre de la base du cylindre médian
- :axe: l'axe des cylindres
- :cylindre: le cylindre support
- """
- nom_fonction = __name__ + "/_cree_face_mediane_cylindre_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "Centre : ({}, {}, {})\n".format(coo_x, coo_y, coo_z)
- texte += "Axe : ({}, {}, {})\n".format(axe_x, axe_y, axe_z)
- texte += "Rayon : {}\n".format(rayon)
- texte += "Hauteur : {}".format(hauteur)
- print (texte)
-
-# Création du point central
- centre = geompy.MakeVertex(coo_x, coo_y, coo_z)
- #geompy.addToStudy( centre, "centre" )
-
-# Création de l'axe
- axe = geompy.MakeVectorDXDYDZ(axe_x, axe_y, axe_z)
- #geompy.addToStudy( axe, "axe" )
-
-# Création d'un cylindre
- cylindre = geompy.MakeCylinder(centre, axe, rayon, hauteur)
- if self._verbose_max:
- geompy.addToStudy( cylindre, "cylindre médian" )
-
- return centre, axe, cylindre
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cylindre_2 ( self, geompy, solide, centre, axe, cylindre ):
- """Crée la face médiane entre deux autres - cas des cylindres
-
-Intersection de la face cylindrique avec le solide initial
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :centre: le centre de la base du cylindre médian
- :axe: l'axe des cylindres
- :cylindre: le cylindre support
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_cylindre_2"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
-# Récupération de la bonne face après intersection du cylindre avec le solide initial
- face = self._creation_face_inter ( geompy, solide, cylindre, 1 )
-
-# Pour des raisons inconnues de moi, il arrive que l'axe donné par les caractéristiques soit dans le mauvais sens.
-# Dans ce cas l'intersection est vide, et il faut retourner la face créée précédemment et recalculer l'intersection.
- tb_caract = geompy.KindOfShape(face)
- if ( tb_caract[1] == 0 ):
- if self._verbose_max:
- print ("On opère un retournement du cylindre.")
- plan_de_base = geompy.MakePlane(centre, axe, 100)
- #geompy.addToStudy( plan_de_base, "plan_de_base" )
- geompy.MirrorByPlane(cylindre, plan_de_base)
-# Récupération de la bonne face après intersection du cylindre retourné avec le solide initial
- face = self._creation_face_inter ( geompy, solide, cylindre, 1 )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_sphere ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des sphères
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_sphere"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Caractéristiques des sphères
- coo_x, coo_y, coo_z, rayon = self._cree_face_mediane_sphere_0 ( caract_face_1, caract_face_2 )
-
-# Création de la face
- face = self._cree_face_mediane_sphere_1 ( geompy, solide, coo_x, coo_y, coo_z, rayon )
-
-# Couleur verte
- face.SetColor(SALOMEDS.Color(0,1,0))
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_sphere_0 ( self, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des sphères
-
-Décodage des caractéristiques
-
-Entrées :
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :coo_x, coo_y, coo_z: coordonnées du centre de la sphère
- :rayon: rayon moyen entre les deux faces
- """
-
- nom_fonction = __name__ + "/_cree_face_mediane_sphere_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Coordonnées du centre de la sphère
- coo_x = caract_face_1[2][1]
- coo_y = caract_face_1[2][2]
- coo_z = caract_face_1[2][3]
-# Rayons
- rayon = (caract_face_2[2][4]+caract_face_1[2][4])/2.
-
- return coo_x, coo_y, coo_z, rayon
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_sphere_1 ( self, geompy, solide, coo_x, coo_y, coo_z, rayon ):
- """Crée la face médiane entre deux autres - cas des sphères
-
-Création des objets temporaires et de la face externe de la sphère support
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :coo_x, coo_y, coo_z: coordonnées du centre de la sphère
- :rayon: rayon moyen entre les deux faces
-
-Sorties :
- :face: la face externe de la sphère support
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_sphere_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "Centre : ({}, {}, {})\n".format(coo_x, coo_y, coo_z)
- texte += "Rayon : {}".format(rayon)
- print (texte)
-
-# Création du point central
- centre = geompy.MakeVertex(coo_x, coo_y, coo_z)
- #geompy.addToStudy( centre, "centre" )
-
-# Création d'une sphère médiane
- sphere = geompy.MakeSpherePntR(centre, rayon)
- if self._verbose_max:
- geompy.addToStudy( sphere, "sphère médiane" )
-
-# Récupération de la bonne face après intersection avec le solide initial
- face = self._creation_face_inter ( geompy, solide, sphere, 0 )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_tore ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des tores
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_tore"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Caractéristiques des tores
- coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2 = self._cree_face_mediane_tore_0 ( caract_face_1, caract_face_2 )
-
-# Création de la face
- face = self._cree_face_mediane_tore_1 ( geompy, solide, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2 )
-
-# Couleur verte
- face.SetColor(SALOMEDS.Color(0,1,0))
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_tore_0 ( self, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des tores
-
-Décodage des caractéristiques
-
-Entrées :
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :coo_x, coo_y, coo_z: coordonnées du centre du tore
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon_1 : rayon principal
- :rayon_2 : rayon secondaire
- """
-
- nom_fonction = __name__ + "/_cree_face_mediane_tore_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Coordonnées du centre du tore
- coo_x = caract_face_1[2][1]
- coo_y = caract_face_1[2][2]
- coo_z = caract_face_1[2][3]
-# Coordonnées de l'axe
- axe_x = caract_face_1[2][4]
- axe_y = caract_face_1[2][5]
- axe_z = caract_face_1[2][6]
-# Rayons
- rayon_1 = caract_face_2[2][7]
- rayon_2 = (caract_face_2[2][8]+caract_face_1[2][8])/2.
-
- return coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_tore_1 ( self, geompy, solide, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2 ):
- """Crée la face médiane entre deux autres - cas des tores
-
-Création des objets temporaires et de la face externe du tore support
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :coo_x, coo_y, coo_z: coordonnées du centre du tore
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon_1 : rayon principal
- :rayon_2 : rayon secondaire
-
-Sorties :
- :face: la face externe du tore support
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_tore_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "Centre : ({}, {}, {})\n".format(coo_x, coo_y, coo_z)
- texte += "Axe : ({}, {}, {})\n".format(axe_x, axe_y, axe_z)
- texte += "Rayon principal : {}\n".format(rayon_1)
- texte += "Rayon secondaire : {}".format(rayon_2)
- print (texte)
-
-# Création du point central
- centre = geompy.MakeVertex(coo_x, coo_y, coo_z)
- #geompy.addToStudy( centre, "centre" )
-
-# Création de l'axe
- axe = geompy.MakeVectorDXDYDZ(axe_x, axe_y, axe_z)
- #geompy.addToStudy( axe, "axe" )
-
-# Création d'un tore médian
- tore = geompy.MakeTorus(centre, axe, rayon_1, rayon_2)
- if self._verbose_max:
- geompy.addToStudy( tore, "tore médian" )
-
-# Récupération de la bonne face après intersection avec le solide initial
- face = self._creation_face_inter ( geompy, solide, tore, 0 )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cone ( self, geompy, solide, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des cones
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_cone"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Caractéristiques des cones
- coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2, hauteur = self._cree_face_mediane_cone_0 ( geompy, caract_face_1, caract_face_2 )
-
-# Création de la face
- centre, axe, cone = self._cree_face_mediane_cone_1 ( geompy, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2, hauteur )
-
-# Gestion de l'intersection avec le solide initial
- face = self._cree_face_mediane_cone_2 ( geompy, solide, centre, axe, cone )
-
-# Couleur verte
- face.SetColor(SALOMEDS.Color(0,1,0))
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cone_0 ( self, geompy, caract_face_1, caract_face_2 ):
- """Crée la face médiane entre deux autres - cas des cones
-
-Décodage des caractéristiques
-
-Entrées :
- :geompy: environnement de GEOM
- :caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
-
-Sorties :
- :coo_x, coo_y, coo_z: coordonnées du centre de la base
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon_1, rayon_2: rayons moyens du côté de la base et à l'opposé
- :hauteur: hauteur du cone
- """
-
- nom_fonction = __name__ + "/_cree_face_mediane_cone_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "face_1 : {}\n".format(caract_face_1)
- texte += "face_2 : {}".format(caract_face_2)
- print (texte)
-
-# Coordonnées du centre de la base
- coo_x = caract_face_1[2][1]
- coo_y = caract_face_1[2][2]
- coo_z = caract_face_1[2][3]
-# Coordonnées de l'axe
- axe_x = caract_face_1[2][4]
- axe_y = caract_face_1[2][5]
- axe_z = caract_face_1[2][6]
-# Rayons
-# Pour un cone complet, les caractéristiques forunies par GEOM sont correctes
-# Mais s'il est découpé, malheureusement,bug dans GEOM et caract_face_2[2][8] est toujours nul !
-# Alors on passe par le décodage des arêtes
- #rayon_1 = (caract_face_2[2][7]+caract_face_1[2][7])/2.
- #rayon_2 = (caract_face_2[2][8]+caract_face_1[2][8])/2.
- caract_arete_face_1 = self._calcul_caract_aretes_face ( geompy, caract_face_1 )
- caract_arete_face_2 = self._calcul_caract_aretes_face ( geompy, caract_face_2 )
- rayon_1 = 0.
- rayon_2 = 0.
- for caract_aretes_face in [caract_arete_face_1,caract_arete_face_2]:
- prem = True
- for l_aux in caract_aretes_face:
- if ( l_aux[0] in ( geompy.kind.CIRCLE, geompy.kind.ARC_CIRCLE ) ):
- #print ("R =",l_aux[7])
- if prem:
- rayon_1 += l_aux[7]
- prem = False
- else:
- rayon_2 += l_aux[7]
- rayon_1 *= 0.5
- rayon_2 *= 0.5
-# Hauteur
- hauteur = caract_face_1[2][9]
-
- return coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2, hauteur
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cone_1 ( self, geompy, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon_1, rayon_2, hauteur ):
- """Crée la face médiane entre deux autres - cas des cones
-
-Création des objets temporaires et de la face externe du cone support
-
-Entrées :
- :geompy: environnement de GEOM
- :coo_x, coo_y, coo_z: coordonnées du centre de la base
- :axe_x, axe_y, axe_z: coordonnées de l'axe
- :rayon_1, rayon_2: rayons moyens du côté de la base et à l'opposé
- :hauteur: hauteur du cone
-
-Sorties :
- :centre: le centre de la base du cone médian
- :axe: l'axe des cones
- :cone: le cone support
- """
- nom_fonction = __name__ + "/_cree_face_mediane_cone_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- texte = blabla
- texte += "Centre : ({}, {}, {})\n".format(coo_x, coo_y, coo_z)
- texte += "Axe : ({}, {}, {})\n".format(axe_x, axe_y, axe_z)
- texte += "Rayons : {}, {}\n".format(rayon_1, rayon_2)
- texte += "Hauteur : {}".format(hauteur)
- print (texte)
-
-# Création du point central
- centre = geompy.MakeVertex(coo_x, coo_y, coo_z)
- #geompy.addToStudy( centre, "centre" )
-
-# Création de l'axe
- axe = geompy.MakeVectorDXDYDZ(axe_x, axe_y, axe_z)
- #geompy.addToStudy( axe, "axe" )
-
-# Création d'un cone
- cone = geompy.MakeCone(centre, axe, rayon_1, rayon_2, hauteur)
- if self._verbose_max:
- geompy.addToStudy( cone, "cone médian" )
-
- return centre, axe, cone
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_cone_2 ( self, geompy, solide, centre, axe, cone ):
- """Crée la face médiane entre deux autres - cas des cones
-
-Intersection de la face cylindrique avec le solide initial
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :centre: le centre de la base du cone médian
- :axe: l'axe des cones
- :cone: le cone support
-
-Sorties :
- :face: la face médiane
- """
- face = None
-
- nom_fonction = __name__ + "/_cree_face_mediane_cone_2"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
-# Récupération de la bonne face après intersection du cone avec le solide initial
- face = self._creation_face_inter ( geompy, solide, cone, 1 )
-
-# Pour des raisons inconnues de moi, il arrive que l'axe donné par les caractéristiques soit dans le mauvais sens.
-# Dans ce cas l'intersection est vide, et il faut retourner la face créée précédemment et recalculer l'intersection.
- tb_caract = geompy.KindOfShape(face)
- if ( tb_caract[1] == 0 ):
- if self._verbose_max:
- print ("On opère un retournement du cone.")
- plan_de_base = geompy.MakePlane(centre, axe, 100)
- #geompy.addToStudy( plan_de_base, "plan_de_base" )
- geompy.MirrorByPlane(cone, plan_de_base)
-# Récupération de la bonne face après intersection du cone retourné avec le solide initial
- face = self._creation_face_inter ( geompy, solide, cone, 1 )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _calcul_hauteur_englobante ( self, geompy, solide ):
- """Crée la hauteur englobant à coup sûr le solide
-
-Décodage des caractéristiques
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
-
-Sorties :
- :hauteur: hauteur englobante
- """
-
- nom_fonction = __name__ + "/_calcul_hauteur_englobante"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- print (blabla[:-1])
-
-# Hauteur : la diagonale de la boîte englobante permet d'être certain de tout prendre
- bounding_box = geompy.BoundingBox(solide)
- if self._verbose_max:
- texte = "Boîte englobante du solide '{}'\n".format(self.nom_solide)
- texte += "\tXmin = {}, Xmax = {}\n".format(bounding_box[0],bounding_box[1])
- texte += "\tYmin = {}, Ymax = {}\n".format(bounding_box[2],bounding_box[3])
- texte += "\tZmin = {}, Zmax = {}".format(bounding_box[4],bounding_box[5])
- print(texte)
-
- coo_1 = np.array([bounding_box[0],bounding_box[2],bounding_box[4]])
- coo_2 = np.array([bounding_box[1],bounding_box[3],bounding_box[5]])
- longueur = np.linalg.norm(coo_2-coo_1)
- if self._verbose_max:
- print ("Longueur de la diagonale {}".format(longueur))
- hauteur = 1.2*longueur
-
- return hauteur
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _creation_face_inter ( self, geompy, solide, objet, numero ):
- """Crée la face
-
-. Repère la face principale de l'objet support
-. Réalise l'intersection avec le solide initial
-
-Entrées :
- :geompy: environnement de GEOM
- :solide: l'objet solide à traiter
- :objet: l'objet support de la face
- :numero: numero de la face dans l'explosion de l'objet support
-
-Sorties :
- :face: la face externe de l'objet support intersecté avec le solide initial
- """
-
- nom_fonction = __name__ + "/_creation_face_inter"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
-# Les deux faces
- if self._verbose_max:
- print (blabla[:-1])
-
-# Récupération de la bonne face
- l_aux = geompy.ExtractShapes(objet, geompy.ShapeType["FACE"], True)
- face_1 = geompy.MakeShell([l_aux[numero]])
- #geompy.addToStudy( face_1, "face externe" )
-
-# Intersection entre la face externe du solide médian et le solide initial
- face = geompy.MakeCommonList([solide, face_1], True)
- #geompy.addToStudy( face, "face" )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _menage_faces ( self, gst, l_faces ):
- """Fait le ménage des faces dans l'étude
-
-Entrées :
- :gst: environnement de GeomStudyTools
- :l_faces: liste des faces du solide
- """
-
- nom_fonction = __name__ + "/_menage_faces"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- texte += "Nombre de faces à supprimer : {}\n".format(len(l_faces))
- print (texte)
-
-# Suppression des faces incluses dans l'étude
- if self._menage:
- for face in l_faces:
- if self._verbose_max:
- print ("\tSuppression de {}".format(face.GetName()))
- gst.deleteShape(face.GetStudyEntry())
-
-# Rafraichissement de l'affichage
- salome.sg.updateObjBrowser()
-
- return
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def face_mediane_solide (self, geompy, gst, solide):
-
- """Calcul de la face médiane pour un solide
-
-Entrées :
- :geompy: environnement de GEOM
- :gst: environnement de GeomStudyTools
- :solide: l'objet solide à traiter
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/face_mediane_solide"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
- if self._verbose:
- print ("Traitement du solide '{}'".format(solide.GetName()))
-
-# 1. Préalables
-
- erreur = 0
- message = ""
-
- while not erreur :
-
-# 2. Explosion du solide en faces
-
- erreur, message, l_faces = self._faces_du_solide ( geompy, solide )
- if erreur:
- break
-
-# 3. Calcul des caractéristiques géométriques des faces
-
- tb_caract = self._calcul_caract_faces ( geompy, l_faces )
-
-# 4. Tri des faces en fonction de leurs caractéristiques géométriques
-
- erreur, message, caract_face_1, caract_face_2 = self._tri_faces ( tb_caract )
- if erreur:
- break
-
-# 5. Création de la face médiane
-
- erreur, message, face = self._cree_face_mediane ( geompy, solide, caract_face_1, caract_face_2 )
- if erreur:
- break
-
-# 6. Ménage des faces
-
- if salome.sg.hasDesktop():
- if self._retour_shaper:
- l_faces.append(face)
- self._menage_faces ( gst, l_faces )
-
- break
-
-# 7. La fin
-
- if ( erreur and self._verbose_max ):
- print (blabla, message)
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _menage_solides ( self, gst, l_solides, l_solides_m, type_selection, objet ):
- """Fait le ménage des solides dans l'étude
-
-Entrées :
- :gst: environnement de GeomStudyTools
- :l_solides: liste des solides de l'objet
- :l_solides_m: liste des solides de l'objet dont on veut le ménage
- :type_selection: type de sélection de l'objet à traiter (0: graphique, 1: GEOM, 2;SHAPER)
- :objet: l'objet à traiter
- """
-
- nom_fonction = __name__ + "/_menage_solides"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- texte += "Nombre de solides de l'objet : {}\n".format(len(l_solides))
- texte += "Nombre de solides à supprimer : {}".format(len(l_solides_m))
- print (texte)
-
- if self._menage:
-
-# Suppression des solides inclus dans l'étude dans le cas d'un assemblage explosé
- if ( len(l_solides) > 1 ):
- for solide in l_solides_m:
- if self._verbose_max:
- print ("\tSuppression de {}".format(solide.GetName()))
- gst.deleteShape(solide.GetStudyEntry())
-
-# Suppression de l'objet initial quand il vient d'une exportation depuis SHAPER si ça s'est mal passé
- if ( type_selection == 2 ):
- if ( len(l_solides) != len(l_solides_m) ):
- pass
- else:
- if self._verbose_max:
- print ("\tSuppression de {}".format(objet.GetName()))
- gst.deleteShape(objet.GetStudyEntry())
-
-# Mise en évidence des solides non détruits
- for solide in l_solides:
- if solide not in l_solides_m:
- solide.SetColor(SALOMEDS.Color(1,0,0))
-
-# Rafraichissement de l'affichage
- salome.sg.updateObjBrowser()
-
- return
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _traitement_objet (self, type_selection=0, objet=None ):
- """Traitement d'un objet
-
-Entrées :
- :type_selection: type de sélection de l'objet à traiter (0: graphique, 1: GEOM, 2;SHAPER)
- :objet: l'objet à traiter quand il passe par argument
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/_traitement_objet"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- texte = blabla
- texte += "type_selection = {}".format(type_selection)
- print (texte)
-
-# 1. Préalables
-
- erreur = 0
- message = ""
-
- while not erreur :
-
-# 2. L'aide
-
- if self.affiche_aide_globale :
- break
-
-# 3. Les imports pour salomé
- geompy = geomBuilder.New()
- gst = geomtools.GeomStudyTools(getStudyEditor())
-
-# 4. Sélection de l'objet
- if ( type_selection == 0 ):
- erreur, message, objet = self._selection_objet_graphique ( geompy )
- elif ( type_selection in (1,2) ):
- pass
- else:
- message = "Le type d'objet {} est inconnu.".format(type_selection)
- erreur = 4
- if erreur:
- break
-
-# 5. En cas de retour vers shaper, répertoire de travail associé à l'éventuel fichier de départ
- if self._retour_shaper:
- if self.ficcao is None:
- self.rep_trav = tempfile.mkdtemp(prefix="{}_".format(objet.GetName()))
- else:
- self.rep_trav = os.path.join(os.path.dirname(self.ficcao),"{}_M".format(objet.GetName()))
- if not os.path.isdir(self.rep_trav):
- os.mkdir(self.rep_trav)
- if self._verbose_max:
- print ("Les fichiers CAO des surfaces seront dans le répertoire {}".format(self.rep_trav))
-
-# 6. Liste des solides qui composent l'objet
- erreur, message, l_solides = self._les_solides ( geompy, objet )
- if erreur:
- break
-
-# 7. Calcul des surfaces médianes pour chaque solide
- l_solides_m = list()
- for solide in l_solides:
- erreur, message = self.face_mediane_solide (geompy, gst, solide)
- if erreur:
- break
- l_solides_m.append(solide)
- if erreur:
- break
-
-# 8. Ménage des solides
-
- if salome.sg.hasDesktop():
- self._menage_solides ( gst, l_solides, l_solides_m, type_selection, objet )
-
-# 9. Informations sur les faces à problème
- if self.faces_pb_nb:
- if ( self.faces_pb_nb == 1 ):
- texte = "1 face pose"
- else:
- texte = "{} faces posent".format(self.faces_pb_nb)
- print ("{} problème.\n{}".format(texte,self.faces_pb_msg))
-
-# 10. Final
- print ("Les fichiers CAO des surfaces sont dans le répertoire {}".format(self.rep_trav))
-
- break
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def surf_fic_cao (self, ficcao):
- """Calcule la surface médiane pour un objet dans un fichier passé en argument
-
-Entrées :
- :ficcao: fichier de l'objet à traiter
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/surf_fic_cao"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
- erreur = 0
- message = ""
-
- while not erreur :
-
-# 1. Définition de la pièce
-
- self.part_doc = model.activeDocument()
-
-# 2. Import de la CAO
-
- self.ficcao = ficcao
- print ("Traitement du fichier {}".format(self.ficcao))
-
- erreur, message, objet = import_cao (self.part_doc, self.ficcao, self._verbose_max)
- if erreur:
- break
-
-# 3. Calcul des surfaces
-
- erreur, message = self.surf_objet_shaper ( objet.result().name(), objet.result().shapeType() )
-
- if ( erreur and self._verbose_max ):
- print (blabla, message)
-
- break
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def surf_objet_shaper (self, nom_objet, type_objet):
- """Calcule la surface médiane pour un objet SHAPER passé en argument
-
-Entrées :
- :nom_objet: nom de l'objet à traiter
- :type_objet: type de l'objet à traiter "SOLID"/"COMPOUND"
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/surf_objet_shaper"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
- erreur = 0
- message = ""
-
- while not erreur :
-
-# 1. Transfert vers GEOM
-# 1.1. Le départ est-il un fichier au format step ?
- deja_step = False
- if self.ficcao is not None:
- laux = self.ficcao.split(".")
- fmt_cao_0 = decode_cao (laux[-1])
- if ( fmt_cao_0 == "stp" ):
- deja_step = True
- if self._verbose_max:
- print ("deja_step = {}".format(deja_step))
-
-# 1.1. Exportation si le fichier de départ n'est pas au format step
- if deja_step:
- fichier = self.ficcao
- else:
- fichier = tempfile.mkstemp(suffix=".stp")[1]
- if self._verbose_max:
- print ('fichier = {}'.format(fichier))
- print ('nom_objet = {}'.format(nom_objet))
- print ('type_objet = {}'.format(type_objet))
- export = model.exportToFile(self.part_doc, fichier, [model.selection(type_objet, nom_objet)])
- export.execute(True)
- model.do()
- taille = os.path.getsize(fichier)
- if ( taille <= 0 ):
- message = "Export de SHAPER vers GEOM impossible pour l'objet '{}' de type '{}'\n".format(nom_objet, type_objet)
- message += "Le fichier {} est de taille {}".format(fichier,taille)
- erreur = 2
- break
-
-# 1.2. Importation
- geompy = geomBuilder.New()
- objet = geompy.ImportSTEP(fichier, False, True)
- geompy.addToStudy( objet, nom_objet )
- if not deja_step:
- os.remove(fichier)
-
-# 2. Traitement de l'objet GEOM correspondant
- erreur, message = self._traitement_objet ( 2, objet )
-
- if ( erreur and self._verbose_max ):
- print (blabla, message)
-
- break
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def surf_objet_geom (self, objet):
- """Calcule la surface médiane pour un objet GEOM passé en argument
-
-Entrées :
- :objet: l'objet à traiter
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/surf_objet_geom"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
- erreur, message = self._traitement_objet ( 1, objet )
-
- if ( erreur and self._verbose_max ):
- print (blabla, message)
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def lancement (self):
-
- """Lancement
-
-Sorties :
- :erreur: code d'erreur
- :message: message d'erreur
- """
-
- nom_fonction = __name__ + "/lancement"
- blabla = "\nDans {} :\n".format(nom_fonction)
-
- if self._verbose_max:
- print (blabla)
-
- erreur, message = self._traitement_objet ( )
-
- if ( erreur and self._verbose_max ):
- print (blabla, message)
-
- return erreur, message
-
-#=========================== Fin de la méthode ==================================
-
-#========================== Fin de la classe ====================================
-
-#==================================================================================
-# Lancement
-#==================================================================================
-
-if __name__ == "__main__" :
-
-# 1. Options
-
- L_OPTIONS = list()
- #L_OPTIONS.append("-h")
- #L_OPTIONS.append("-v")
- #L_OPTIONS.append("-vmax")
- #L_OPTIONS.append("-no_menage")
- #L_OPTIONS.append("-retour_shaper")
-
-# 2. Lancement de la classe
-
- #print ("L_OPTIONS :", L_OPTIONS)
- SURFACE_MEDIANE = SurfaceMediane(L_OPTIONS)
- if SURFACE_MEDIANE.affiche_aide_globale:
- sys.stdout.write(SURFACE_MEDIANE.__doc__+"\n")
- else:
- ERREUR, MESSAGE_ERREUR = SURFACE_MEDIANE.lancement()
- if ERREUR:
- MESSAGE_ERREUR += "\n Code d'erreur : %d\n" % ERREUR
- sys.stderr.write(MESSAGE_ERREUR)
-
- del SURFACE_MEDIANE
-
- #sys.exit(0)
