guillaume.schweitzer@blastsolutions.io
Gérald NICOLAS
-+33.1.78.19.43.52
"""
-__revision__ = "V10.48"
+__revision__ = "V10.56"
#========================= Les imports - Début ===================================
Entrées :
:part_doc: part
:ficcao: le fichier de la CAO
+ :nom_objet: nom à donner à l'objet lu, éventuellement
Sorties :
:objet: l'objet importé dans SHAPER
"""
-
- erreur = 0
- message = "Fichier '{}'\n".format(ficcao)
+ nom_fonction = __name__ + "/import_cao"
+ blabla = "Dans {} :\n".format(nom_fonction)
+ message_0 = "Fichier : {}\n".format(ficcao)
if verbose:
+ message = blabla + message_0
+ message += "nom_objet : {}".format(nom_objet)
print (message)
+ message = message_0
+
+ erreur = 0
objet = None
texte += "De type : '{}'".format(objet.result().shapeType())
print (texte)
-
return erreur, message, objet
#========================= Fin de la fonction ===================================
+#========================= Début de la fonction ==================================
+
+def print_tab (nb_tab, message, argu=None, saut_av=False, saut_ap=False):
+ """Imprime avec des tabulations
+
+Entrées :
+ :nb_tab: nombre de tabulations à appliquer
+ :message: message principal
+ :argu: argument du format
+ :saut_av: saut de ligne avant le texte
+ :saut_ap: saut de ligne après le texte
+ """
+
+ texte = ""
+
+ if saut_av:
+ texte += "\n"
+
+ for _ in range(nb_tab):
+ texte += "\t"
+
+ texte += message
+ if ( argu is not None ):
+ texte += "{}".format(argu)
+
+ if saut_ap:
+ texte += "\n"
+
+ print (texte)
+
+#========================= Fin de la fonction ===================================
+
+#========================= Début de la fonction ==================================
+
+def nommage (objet, nom, couleur=None):
+ """Nomme un objet et son résultat
+
+Entrées :
+ :objet: objet à traiter
+ :nom: nom à attribuer
+ :couleur: éventuellement couleur
+ """
+
+ objet.setName(nom)
+ objet.result().setName(nom)
+
+ if ( couleur is not None ):
+ objet.result().setColor(couleur[0], couleur[1], couleur[2])
+
+#========================= Fin de la fonction ===================================
+
+
#=================================== La classe ===================================
class SurfaceMediane (object):
. toriques
. coniques
-Si la création n'a pas eu lieu, un message est émis et les solides sont mise en couleur :
+Si la création n'a pas eu lieu, un message est émis et les solides sont mis en couleur :
. Rouge : le solide n'est pas assez mince.
. Bleu : le solide est trop mince, vis-à-vis de la précision de SHAPER.
. Orange : la forme de la face n'est pas reconnue.
. Exportation finale dans un fichier step. Par défaut, pas d'export.
-export_step/-no_export_step
+Arborescence :
+surf_fic_cao --> import_cao
+ --> surf_objet_shaper (récursif) --> _nom_sous_objets
+ --> _surf_objet_shaper_0
+ --> surf_solide_shaper --> _isole_solide
+ --> _traitement_objet --> face_mediane_solide --> _faces_du_solide
+ --> _tri_faces
+ --> _cree_face_mediane
+
+_cree_face_mediane --> _cree_face_mediane_plane
+ --> _cree_face_mediane_cylindre
+ --> _cree_face_mediane_sphere
+ --> _cree_face_mediane_tore
+ --> _cree_face_mediane_cone
+ --> _cree_face_mediane_0
+
"""
# A. La base
Décodage des arguments
On cherche ici les arguments généraux : aide, verbeux
- """
+"""
for option in liste_option :
Sorties :
:rang: rang du sous-objet
- """
+"""
nom_fonction = __name__ + "/_nom_sous_objets"
blabla = "Dans {} :\n".format(nom_fonction)
Sorties :
:rang: rang du sous-objet
- """
+"""
nom_fonction = __name__ + "/_couleur_objet"
- blabla = "Dans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- prefixe = ""
- for _ in range(n_recur):
- prefixe += "\t"
- texte = "\n{}{}".format(prefixe,blabla)
- texte += "{}n_recur = {}".format(prefixe,n_recur)
- texte += "\n{}RGB = ({},{},{})".format(prefixe,coul_r,coul_g,coul_b)
- print (texte)
+ print (blabla)
+ print_tab(n_recur, "objet : ", objet.name())
+ print_tab(n_recur, "RGB = ({},{},{})".format(coul_r,coul_g,coul_b))
# 1. Au premier passage, il faut garder la référence au résultat principal
- if ( n_recur == 0 ):
+ if ( n_recur == 0 ):
objet_0 = objet.result()
else:
objet_0 = objet
nb_sub_results = objet_0.numberOfSubs()
if self._verbose_max:
- texte = "{}Examen de l'objet '{}' ".format(prefixe,objet_0.name())
- texte += "de type '{}' ".format(objet_0.shapeType())
+ print_tab(n_recur, "Examen de l'objet ",objet_0.name())
+ texte = "de type '{}' ".format(objet_0.shapeType())
texte += "et de {} sous-objets".format(nb_sub_results)
- print (texte)
+ print_tab(n_recur, texte)
for n_sobj in range(nb_sub_results):
# 2.2. Cet objet n'a pas de sous-objets : on le colore
if self._verbose_max:
- texte = "{}Couleur affectée à l'objet '{}' ".format(prefixe,objet_0.name())
- print (texte)
+ print_tab(n_recur, "Couleur affectée à l'objet ",objet_0.name())
objet_0.setColor (int(coul_r),int(coul_g),int(coul_b))
#print ("sortie de {}".format(nom_fonction))
#=========================== Début de la méthode =================================
- def _isole_solide ( self, solide ):
+ def _isole_solide ( self, solide, n_recur ):
"""Isole le solide de son arboresence
Entrées :
:solide: le solide à traiter
+ :n_recur: numéro de la récurrence
Sorties :
:objet: le solide isolé
:recover: la fonction de récupération
- """
+"""
nom_fonction = __name__ + "/_isole_solide"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- texte = blabla
- texte += "Pour le solide '{}' ".format(solide.name())
+ print_tab (n_recur, blabla)
+ texte = "Pour le solide '{}' ".format(solide.name())
texte += "de l'objet principal '{}'".format(self.objet_principal.name())
- print (texte)
+ print_tab (n_recur, texte)
if ( solide.name() != self.objet_principal.name() ):
+ objet, recover = self._isole_solide_a ( solide, n_recur )
- if self._verbose_max:
- print (". Extraction du solide")
+ else:
+ objet, recover = self._isole_solide_b ( solide, n_recur )
+
+ if self._verbose_max:
+ print_tab (n_recur, "objet final : ", objet.name())
+ print_tab (n_recur, "fonction_0 : ", self.fonction_0)
+ print_tab (n_recur, "recover : ", recover)
+
+ return objet, recover
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _isole_solide_a ( self, solide, n_recur ):
+ """Isole le solide de son arboresence
+
+Entrées :
+ :solide: le solide à traiter
+ :n_recur: numéro de la récurrence
+
+Sorties :
+ :objet: le solide isolé
+ :recover: la fonction de récupération
+"""
+
+ nom_fonction = __name__ + "/_isole_solide_a"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ texte = "Pour le solide '{}' ".format(solide.name())
+ texte += "de l'objet principal '{}'".format(self.objet_principal.name())
+ print_tab (n_recur, texte)
+
+ if self._verbose_max:
+ print_tab (n_recur, ". Extraction du solide '{}'".format(self.objet_principal.name()))
# 1. Extraction du solide
- remove_subshapes = model.addRemoveSubShapes(self.part_doc, model.selection("COMPOUND", self.objet_principal.name()))
- remove_subshapes.setSubShapesToKeep([model.selection("SOLID", solide.name())])
+ remove_subshapes = model.addRemoveSubShapes(self.part_doc, model.selection("COMPOUND", self.objet_principal.name()))
+ remove_subshapes.setSubShapesToKeep([model.selection("SOLID", solide.name())])
- self.nom_solide_aux = "{}_S".format(solide.name())
- remove_subshapes.result().setName(self.nom_solide_aux)
+ self.nom_solide_aux = "{}_S".format(solide.name())
+ if self._verbose_max:
+ print_tab (n_recur, "\tAttribution à remove_subshapes.result() du nom '{}'".format(self.nom_solide_aux))
+ remove_subshapes.result().setName(self.nom_solide_aux)
- self.fonction_0 = remove_subshapes
+ self.fonction_0 = remove_subshapes
# 2. Récupération de l'objet principal
- recover = model.addRecover(self.part_doc, remove_subshapes, [self.objet_principal])
- recover.result().setName(self.objet_principal.name())
+ recover = model.addRecover(self.part_doc, remove_subshapes, [self.objet_principal])
+ if self._verbose_max:
+ print_tab (n_recur, "\tAttribution à recover du nom '{}'".format(self.objet_principal.name()))
+ recover.result().setName(self.objet_principal.name())
- objet = remove_subshapes.result()
+ return remove_subshapes.result(), recover
- else:
+#=========================== Fin de la méthode ==================================
- if self._verbose_max:
- print (". Mise en place du solide")
+#=========================== Début de la méthode =================================
+
+ def _isole_solide_b ( self, solide, n_recur ):
+ """Isole le solide de son arboresence
+
+Entrées :
+ :solide: le solide à traiter
+ :n_recur: numéro de la récurrence
+
+Sorties :
+ :objet: le solide isolé
+ :recover: la fonction de récupération
+"""
- objet = solide
- self.nom_solide_aux = self.objet_principal.name()
- self.fonction_0 = None
- recover = None
+ nom_fonction = __name__ + "/_isole_solide_b"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ texte = "Pour le solide '{}' ".format(solide.name())
+ texte += "de l'objet principal '{}'".format(self.objet_principal.name())
+ print_tab (n_recur, texte)
if self._verbose_max:
- texte = "objet final : '{}'\n".format(objet.name())
- texte += "fonction_0 : {}".format(self.fonction_0)
- texte += "recover : {}".format(recover)
- print (texte)
+ print_tab (n_recur, ". Mise en place du solide")
- return objet, recover
+ self.nom_solide_aux = self.objet_principal.name()
+ self.fonction_0 = None
+
+ return solide, None
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
- def _faces_du_solide ( self, geompy, solide ):
+ def _faces_du_solide ( self, geompy, objet_geom, solide, n_recur=0 ):
"""Détermine les faces d'un solide
Entrées :
:geompy: environnement de GEOM
- :solide: le solide à traiter
+ :objet_geom: l'objet solide à traiter au format GEOM
+ :solide: solide SHAPER à traiter
+ :n_recur: niveau de récursivité
Sorties :
+ :l_faces_geom: liste des faces du solide au format GEOM
:l_faces: liste des faces du solide
- """
+"""
nom_fonction = __name__ + "/_faces_du_solide"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla, saut_av=True)
erreur = 0
message = ""
+ l_faces_geom = list()
l_faces = list()
while ( not erreur ):
if self._verbose_max:
- print (".. Traitement du solide '{}'".format(self.nom_solide))
- longueur, aire, volume = geompy.BasicProperties(solide)
- texte = "{}".format(geompy.WhatIs(solide))
+ print_tab (n_recur, ".. Traitement du solide ", self.nom_solide)
+ longueur, aire, volume = geompy.BasicProperties(objet_geom)
+ texte = "{}".format(geompy.WhatIs(objet_geom))
texte += ". longueur, aire, volume : {}, {}, {}".format(longueur,aire,volume)
print (texte)
# Liste des faces qui composent le solide
- l_faces = geompy.ExtractShapes(solide, geompy.ShapeType["FACE"], True)
+ l_faces_geom = geompy.ExtractShapes(objet_geom, geompy.ShapeType["FACE"], True)
#if self._verbose_max:
- #print ("Liste des {} faces qui composent le solide :".format(len(l_faces)))
- #for iaux, face in enumerate(l_faces):
+ #print ("Liste des {} faces qui composent le solide :".format(len(l_faces_geom)))
+ #for iaux, face in enumerate(l_faces_geom):
#print ("Face n° {} :\n {}".format(iaux,geompy.WhatIs(face)))
+ print_tab (n_recur, "Type python : ", type(solide))
+ print_tab (n_recur, "Type ", solide.shapeType())
+ #print ("Type {}".format(solide.shapeTypeStr()))
+ #print ("volume = {}".format(GeomAlgoAPI_ShapeTools.volume(solide)))
+ l_faces = list()
+ #exp = GeomAPI_ShapeExplorer(solide, GeomAPI_Shape.FACE)
+ #while exp.more():
+ #l_faces.append(exp.current().face())
+ #exp.next()
+
break
- return erreur, message, l_faces
+ return erreur, message, l_faces_geom, l_faces
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
- def _calcul_caract_faces ( self, geompy, l_faces ):
+ def _calcul_caract_faces ( self, geompy, l_faces, n_recur ):
"""Calcule les caractéristiques géométriques des faces
Entrées :
:geompy: environnement de GEOM
:l_faces: liste des faces du solide
+ :n_recur: niveau de récursivité
Sorties :
:tb_caract: tableau des caractéristiques géométriques des faces
- """
+"""
nom_fonction = __name__ + "/_calcul_caract_faces"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
nb_faces = len(l_faces)
if self._verbose_max:
- print (blabla+"Nombre de faces : {}.".format(nb_faces))
+ print_tab (n_recur, blabla, saut_av=True)
+ print_tab (n_recur, "Nombre de faces : ", nb_faces)
tb_caract = np.zeros((nb_faces,3), dtype = 'object')
for iaux, face in enumerate(l_faces):
if self._verbose_max:
texte = "\t. Face numéro {}".format(iaux)
#texte += "\n\t. longueur, aire, volume : {}, {}, {}".format(longueur,aire,volume)
+ texte += ", surface : {}".format(aire)
print (texte)
tb_caract [iaux][0] = face
#=========================== Début de la méthode =================================
- def _tri_faces ( self, tb_caract ):
+ def _tri_faces ( self, tb_caract, n_recur ):
"""Trie les faces en fonction de leurs surfaces
Entrées :
:tb_caract: tableau des caractéristiques géométriques des faces
+ :n_recur: niveau de récursivité
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)
+ blabla = "Dans {} :".format(nom_fonction)
# Tri du tableau en fonction des surfaces
if self._verbose_max:
- print (blabla+"tb_caract brut : {}".format(tb_caract))
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "tb_caract brut : ", 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))
+ print_tab (n_recur, "tb_caract trié :", tb_caract_1)
if self._verbose_max:
texte = "\tSurface de la plus grande face : {}, de caractéristiques {}\n".format(tb_caract_1[-1][1],tb_caract_1[-1][2])
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)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
texte = blabla
Entrées :
:epaisseur: épaisseur du solide
- """
+"""
nom_fonction = __name__ + "/_verif_epaisseur"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
texte = blabla
else:
erreur = 0
+ #print ("erreur = {}".format(erreur))
return erreur
#=========================== Début de la méthode =================================
- def _cree_face_mediane ( self, solide, geompy, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane ( self, solide, geompy, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres
Entrées :
:solide: solide SHAPER à traiter
:geompy: environnement de GEOM
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane créée
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : " ,caract_face_1)
+ print_tab (n_recur, "face_2 : " ,caract_face_2)
erreur = 0
face = None
# 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, face = self._cree_face_mediane_plane ( geompy, solide, caract_face_1, caract_face_2 )
+ if forme in ( geompy.kind.DISK_CIRCLE, geompy.kind.DISK_ELLIPSE, geompy.kind.POLYGON, geompy.kind.PLANE, geompy.kind.PLANAR ):
+ erreur, face = self._cree_face_mediane_plane ( geompy, solide, caract_face_1, caract_face_2, n_recur )
# 2.2. Face cylindrique
elif forme == geompy.kind.CYLINDER2D:
- erreur, face = self._cree_face_mediane_cylindre ( solide, caract_face_1, caract_face_2 )
+ erreur, face = self._cree_face_mediane_cylindre ( solide, caract_face_1, caract_face_2, n_recur )
# 2.3. Face sphérique
elif forme == geompy.kind.SPHERE2D:
- erreur, face = self._cree_face_mediane_sphere ( caract_face_1, caract_face_2 )
+ erreur, face = self._cree_face_mediane_sphere ( caract_face_1, caract_face_2, n_recur )
# 2.4. Face torique
elif forme == geompy.kind.TORUS2D:
- erreur, face = self._cree_face_mediane_tore ( caract_face_1, caract_face_2 )
+ erreur, face = self._cree_face_mediane_tore ( caract_face_1, caract_face_2, n_recur )
# 2.5. Face conique
elif forme == geompy.kind.CONE2D:
- erreur, face = self._cree_face_mediane_cone ( geompy, caract_face_1, caract_face_2 )
+ erreur, face = self._cree_face_mediane_cone ( geompy, caract_face_1, caract_face_2, n_recur )
# 2.N. Face de forme inconnue
else:
# 3. Gestion de la face produite
if face is not None:
- self._cree_face_mediane_0 ( face )
+ self._cree_face_mediane_0 ( face, n_recur )
return erreur, face
#=========================== Début de la méthode =================================
- def _cree_face_mediane_0 ( self, face ):
+ def _cree_face_mediane_0 ( self, face, n_recur ):
"""Gestion de la face médiane créée entre deux autres
Entrées :
:face: la face médiane créée
- """
+ :n_recur: niveau de récursivité
+"""
nom_fonction = __name__ + "/_cree_face_mediane_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- texte = blabla
- print (texte)
+ print_tab (n_recur, blabla)
# 1. Nom de la face
nom_face = self.nom_solide+"_M"
+ if self._verbose_max:
+ print_tab (n_recur,"Nom de la face créée : ", nom_face)
#if ( self.nom_solide_aux != self.objet_principal.name() ):
#nom_face += "S"
- face.setName(nom_face)
- face.result().setName(nom_face)
+ nommage (face, nom_face)
# 2. Mémorisation de la face et de la fonction initiale
self.l_faces_m.append((face, self.fonction_0))
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane ( self, geompy, solide, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_plane ( self, geompy, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
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
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_plane"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
# Caractéristiques des surfaces
- coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, taille, d_face_1_2 = self._cree_face_mediane_plane_0 ( geompy, solide, caract_face_1, caract_face_2 )
+ coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, taille, d_face_1_2 = self._cree_face_mediane_plane_0 ( geompy, solide, caract_face_1, caract_face_2, n_recur )
# Contrôle de la validité de l'épaisseur
erreur = self._verif_epaisseur ( d_face_1_2 )
# Création de la face
if not erreur:
- face = self._cree_face_mediane_plane_1 ( solide, coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, taille, d_face_1_2 )
+ face = self._cree_face_mediane_plane_1 ( solide, (coo_x, coo_y, coo_z),(vnor_x, vnor_y, vnor_z), taille, d_face_1_2, n_recur )
else:
face = None
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_0 ( self, geompy, solide, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_plane_0 ( self, geompy, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
Décodage des caractéristiques
:geompy: environnement de GEOM
:solide: l'objet solide à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:coo_x, coo_y, coo_z: coordonnées du centre de la base
:vnor_x, vnor_y, vnor_z: coordonnées du vecteur normal
:taille: estimation de la taille de la future face
:d_face_1_2: la distance entre les deux faces
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_plane_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# 1. Caractéristiques de la base
# Coordonnées du centre de la base
vnor_y = caract_face_1[2][5]
vnor_z = caract_face_1[2][6]
# taille : la diagonale de la boîte englobante permet d'être certain de tout prendre
- l_diag = self._calcul_boite_englobante ( solide )
+ l_diag = self._calcul_boite_englobante ( solide, n_recur )
taille = 10.*l_diag
if self._verbose_max:
- print ("Taille englobante : {}".format(taille))
+ print_tab (n_recur, "Taille englobante : ",taille)
# 2. Distance entre les deux faces
face_1 = caract_face_1[0]
face_2 = caract_face_2[0]
d_face_1_2 = geompy.MinDistance(face_1, face_2)
if self._verbose_max:
- print ("Distance entre les deux faces = {}".format(d_face_1_2))
+ print_tab (n_recur, "Distance entre les deux faces = ", d_face_1_2)
return coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, taille, d_face_1_2
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_1 ( self, solide, coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, taille, d_face_1_2 ):
+ def _cree_face_mediane_plane_1 ( self, solide, coo_c, vnor, taille, d_face_1_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
Création des objets temporaires et de la face médiane
Entrées :
:solide: l'objet solide à traiter
- :coo_x, coo_y, coo_z: coordonnées du centre de la base
- :vnor_x, vnor_y, vnor_z: coordonnées du vecteur normal
+ :coo_c: coordonnées du centre de la base
+ :vnor: coordonnées du vecteur normal
:taille: estimation de la taille de la future face
:d_face_1_2: la distance entre les deux faces
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_plane_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- texte = blabla
- texte += "Centre : ({}, {}, {})\n".format(coo_x, coo_y, coo_z)
- texte += "Normale : ({}, {}, {})\n".format(vnor_x, vnor_y, vnor_z)
- texte += "Taille : {}\n".format(taille)
- texte += "Distance entre les deux faces : {}".format(d_face_1_2)
- print (texte)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Centre : ({}, {}, {})".format(coo_c[0], coo_c[1], coo_c[2]))
+ print_tab (n_recur, "Normale : ({}, {}, {})".format(vnor[0], vnor[1], vnor[2]))
+ print_tab (n_recur, "Taille : ", taille)
+ print_tab (n_recur, "Distance entre les deux faces : ", d_face_1_2)
-# Création de paramètres
+# 1. Objets préalables
nom_par_1 = "{}_taille".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_1), "{}".format(taille))
-# Création du point central
- centre = model.addPoint(self.part_doc, coo_x, coo_y, coo_z)
- nom_centre = "{}_centre".format(self.nom_solide)
- centre.result().setName(nom_centre)
+ centre, v_norm, plan = self._cree_centre_axe_plan ( coo_c, vnor, self.nom_solide, n_recur )
-# Création du vecteur normal
- v_norm = model.addAxis(self.part_doc, vnor_x, vnor_y, vnor_z)
- nom_normal = "{}_normale".format(self.nom_solide)
- v_norm.result().setName(nom_normal)
+# 2. Création de l'esquisse
+ sketch = self._cree_face_mediane_plane_1_a ( plan, centre, nom_par_1, taille, n_recur )
-# Création du plan perpendiculaire au vecteur normal
- plan = model.addPlane(self.part_doc, model.selection("EDGE", nom_normal), model.selection("VERTEX", nom_centre), True)
- nom_plan = "{}_plan".format(self.nom_solide)
- plan.result().setName(nom_plan)
+# 3. La face
+ face = self._cree_face_mediane_plane_1_b ( solide, sketch, v_norm, d_face_1_2, n_recur )
-# Création d'un sketch
- sketch = model.addSketch(self.part_doc, model.selection("FACE", nom_plan))
+ print ("fin de {}".format(nom_fonction))
- SketchProjection_1 = sketch.addProjection(model.selection("VERTEX", nom_centre), False)
- SketchPoint_1 = SketchProjection_1.createdFeature()
+ return face
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _cree_face_mediane_plane_1_a ( self, plan, centre, nom_par_1, taille, n_recur ):
+ """Crée la face médiane entre deux autres - cas des surfaces planes - l'esquisse
+
+Entrées :
+ :plan: plan
+ :centre: centre
+ :nom_par_1: nom du paramètre
+ :taille: estimation de la taille de la future face
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :sketch: l'esquisse
+"""
+
+ nom_fonction = __name__ + "/_cree_face_mediane_plane_1_a"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Plan : {}".format(plan.name()))
+ print_tab (n_recur, "Centre : {}".format(centre.name()))
+ print_tab (n_recur, "Paramètre : {}".format(nom_par_1))
+ print_tab (n_recur, "taille : {}".format(taille))
+
+ sketch = model.addSketch(self.part_doc, model.selection("FACE", plan.name()))
### Create SketchLine
SketchLine_1 = sketch.addLine(-taille/2., taille/2., taille/2., taille/2.)
+ sketch.setHorizontal(SketchLine_1.result())
### Create SketchLine
SketchLine_2 = sketch.addLine(taille/2., taille/2., taille/2., -taille/2.)
+ sketch.setVertical(SketchLine_2.result())
+ sketch.setCoincident(SketchLine_1.endPoint(), SketchLine_2.startPoint())
### Create SketchLine
SketchLine_3 = sketch.addLine(taille/2., -taille/2., -taille/2., -taille/2.)
+ sketch.setHorizontal(SketchLine_3.result())
+ sketch.setCoincident(SketchLine_2.endPoint(), SketchLine_3.startPoint())
+ sketch.setLength(SketchLine_3.result(), nom_par_1)
### Create SketchLine
SketchLine_4 = sketch.addLine(-taille/2., -taille/2., -taille/2., taille/2.)
+ sketch.setVertical(SketchLine_4.result())
sketch.setCoincident(SketchLine_4.endPoint(), SketchLine_1.startPoint())
- sketch.setCoincident(SketchLine_1.endPoint(), SketchLine_2.startPoint())
- sketch.setCoincident(SketchLine_2.endPoint(), SketchLine_3.startPoint())
sketch.setCoincident(SketchLine_3.endPoint(), SketchLine_4.startPoint())
+ sketch.setEqual(SketchLine_3.result(), SketchLine_4.result())
+
+ SketchProjection_1 = sketch.addProjection(model.selection("VERTEX", centre.name()), False)
+ SketchPoint_1 = SketchProjection_1.createdFeature()
### Create SketchLine
SketchLine_5 = sketch.addLine(-taille/2., taille/2., taille/2., -taille/2.)
SketchLine_5.setAuxiliary(True)
+ sketch.setCoincident(SketchLine_1.startPoint(), SketchLine_5.startPoint())
+ sketch.setCoincident(SketchLine_3.startPoint(), SketchLine_5.endPoint())
+ sketch.setCoincident(SketchAPI_Point(SketchPoint_1).coordinates(), SketchLine_5.result())
### Create SketchLine
SketchLine_6 = sketch.addLine(taille/2., taille/2., -taille/2., -taille/2.)
SketchLine_6.setAuxiliary(True)
- sketch.setCoincident(SketchLine_1.startPoint(), SketchLine_5.startPoint())
sketch.setCoincident(SketchLine_2.startPoint(), SketchLine_6.startPoint())
- sketch.setCoincident(SketchLine_3.startPoint(), SketchLine_5.endPoint())
sketch.setCoincident(SketchLine_4.startPoint(), SketchLine_6.endPoint())
- sketch.setCoincident(SketchAPI_Point(SketchPoint_1).coordinates(), SketchLine_5.result())
sketch.setCoincident(SketchAPI_Point(SketchPoint_1).coordinates(), SketchLine_6.result())
- sketch.setHorizontal(SketchLine_1.result())
- sketch.setVertical(SketchLine_2.result())
- sketch.setHorizontal(SketchLine_3.result())
- sketch.setVertical(SketchLine_4.result())
- sketch.setLength(SketchLine_3.result(), nom_par_1)
- sketch.setEqual(SketchLine_3.result(), SketchLine_4.result())
model.do()
+
nom_sketch = "{}_esquisse".format(self.nom_solide)
- sketch.setName(nom_sketch)
- sketch.result().setName(nom_sketch)
+ nommage (sketch, nom_sketch)
+
+ print ("fin de {}".format(nom_fonction))
+
+ return sketch
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _cree_face_mediane_plane_1_b ( self, solide, sketch, v_norm, d_face_1_2, n_recur ):
+ """Crée la face médiane entre deux autres - cas des surfaces planes
+
+Création de la face médiane
+
+Entrées :
+ :solide: l'objet solide à traiter
+ :sketch: l'esquisse
+ :v_norm: vecteur normal
+ :d_face_1_2: la distance entre les deux faces
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :face: la face médiane
+"""
+
+ nom_fonction = __name__ + "/_cree_face_mediane_plane_1_b"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Esquisse : ", sketch.name())
+ print_tab (n_recur, "Distance entre les deux faces : ", d_face_1_2)
### Create LinearCopy
LinearCopy_1 = model.addMultiTranslation(self.part_doc, [model.selection("SOLID", self.nom_solide_aux)], model.selection("EDGE", "PartSet/OX"), 0, 1, keepSubResults = True)
- LinearCopy_1.result().subResult(0).setName("{}_0".format(self.nom_solide_aux))
+ nom = "{}_0".format(self.nom_solide_aux)
+ nommage (LinearCopy_1, nom)
### Create Recover
Recover_1 = model.addRecover(self.part_doc, LinearCopy_1, [solide])
- Recover_1.result().setName("{}_1".format(self.nom_solide_aux))
+ nom = "{}_1".format(self.nom_solide_aux)
+ nommage (Recover_1, nom)
# Création d'une face ; on la translate d'une demi-épaisseur.
for iaux in range(2):
distance = -0.5*d_face_1_2*float(2*iaux-1)
nom_solide = "{}_{}".format(self.nom_solide_aux,iaux)
- face = self._cree_face_mediane_plane_2 ( nom_sketch, nom_normal, nom_solide, distance, iaux )
+ face = self._cree_face_mediane_plane_2 ( sketch.name(), v_norm.name(), nom_solide, distance, iaux, n_recur )
if face.results():
- # Si on traite un objet solide unique, on le récupère
- if ( self.nom_solide_aux == self.objet_principal.name() ):
- if self._verbose_max:
- print ("On traite un objet solide unique ==> on le récupère.")
- Recover_2 = model.addRecover(self.part_doc, face, [Recover_1.result()])
- Recover_2.result().setName("{}_S".format(self.nom_solide_aux))
- nb_inter = face.result().numberOfSubs()
- if self._verbose_max:
- print ("Nombre d'intersections : {}".format(nb_inter))
- # Une seule intersection : c'est la bonne
- # Sinon, c'est que le solide est trop mince. On fusionnerait les faces.
- if (nb_inter > 1 ):
- face = self._cree_face_mediane_plane_3 ( face )
+ face = self._cree_face_mediane_plane_11 ( face, Recover_1, n_recur )
break
# Si l'intersection est vide, on la translate dans l'autre sens
else:
if self._verbose_max:
- print ("L'intersection est vide.")
+ print_tab (n_recur, "L'intersection est vide.")
face = None
+ print ("fin de {}".format(nom_fonction))
+
+ return face
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _cree_face_mediane_plane_11 ( self, face, Recover_1, n_recur ):
+ """Crée la face médiane entre deux autres - cas des surfaces planes
+
+Création des objets temporaires et de la face médiane
+
+Entrées :
+ :face: la face médiane
+ :Recover_1: la récupératiuon du solide
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :face: la face médiane
+"""
+
+ nom_fonction = __name__ + "/_cree_face_mediane_plane_11"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face : ", face.name())
+
+ # Si on traite un objet solide unique, on le récupère
+ if ( self.nom_solide_aux == self.objet_principal.name() ):
+ if self._verbose_max:
+ print_tab (n_recur, "On traite un objet solide unique ==> on le récupère.")
+ Recover_2 = model.addRecover(self.part_doc, face, [Recover_1.result()])
+ Recover_2.result().setName("{}_S".format(self.nom_solide_aux))
+
+ nb_inter = face.result().numberOfSubs()
+ if self._verbose_max:
+ print_tab (n_recur, "Nombre d'intersections : ", nb_inter)
+
+ if (nb_inter > 1 ):
+ face = self._cree_face_mediane_plane_3 ( face )
+
return face
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_2 ( self, nom_sketch, nom_normal, nom_solide, distance, icpt=0 ):
+ def _cree_face_mediane_plane_2 ( self, nom_sketch, nom_normal, nom_solide, distance, icpt, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
Intersection de la face avec le solide
Entrées :
- :nom_sketch: nom du sketch
+ :nom_sketch: nom de l'esquisse
:nom_normal: nom du vecteur normal
:nom_solide: nom du solide à intersecter
:distance: la distance de translation
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_plane_2"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
- texte = blabla
- texte += "nom_sketch : {}\n".format(nom_sketch)
- texte += "nom_normal : {}\n".format(nom_normal)
- texte += "nom_solide : {}\n".format(nom_solide)
- texte += "distance : {}".format(distance)
- print (texte)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "nom_sketch : ", nom_sketch)
+ print_tab (n_recur, "nom_normal : ", nom_normal)
+ print_tab (n_recur, "nom_solide : ", nom_solide)
+ print_tab (n_recur, "distance : ", distance)
# Création d'une face
Face_1 = model.addFace(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(nom_sketch))])
nom_face_1 = "{}_face_1_{}".format(self.nom_solide_aux,icpt)
- Face_1.result().setName(nom_face_1)
+ nommage (Face_1, nom_face_1)
# On la translate
Translation_1 = model.addTranslation(self.part_doc, [model.selection("FACE", nom_face_1)], axis = model.selection("EDGE", nom_normal), distance = distance, keepSubResults = True)
nom_trans = "{}_trans_{}".format(self.nom_solide_aux,icpt)
- Translation_1.setName(nom_trans)
- Translation_1.result().setName(nom_trans)
+ nommage (Translation_1, nom_trans)
Translation_1.result().setColor(85, 0, 255)
# Intersection de cette face avec le solide initial
Sorties :
:face_m: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_plane_3"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
texte = blabla
print (texte)
#=========================== Début de la méthode =================================
- def _cree_face_mediane_cylindre ( self, solide, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_cylindre ( self, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des cylindres
Entrées :
:solide: solide SHAPER à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cylindre"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Caractéristiques des cylindres
- coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur, epaisseur = self._cree_face_mediane_cylindre_0 ( solide, caract_face_1, caract_face_2 )
+ coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur, epaisseur = self._cree_face_mediane_cylindre_0 ( solide, caract_face_1, caract_face_2, n_recur )
# Contrôle de la validité de l'épaisseur
erreur = self._verif_epaisseur ( epaisseur )
# Création de la face
if not erreur:
- face = self._cree_face_mediane_cylindre_1 ( coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur )
+ face = self._cree_face_mediane_cylindre_1 ( (coo_x, coo_y, coo_z), (axe_x, axe_y, axe_z), rayon, hauteur, n_recur )
else:
- self._couleur_objet (solide, coul_r=0, coul_g=0, coul_b=255)
+ self._couleur_objet (solide, n_recur, coul_r=0, coul_g=0, coul_b=255)
face = None
return erreur, face
#=========================== Début de la méthode =================================
- def _cree_face_mediane_cylindre_0 ( self, solide, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_cylindre_0 ( self, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des cylindres
Décodage des caractéristiques
Entrées :
:solide: l'objet solide à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:coo_x, coo_y, coo_z: coordonnées du centre de la base
:rayon: rayon moyen entre les deux faces
:hauteur: hauteur du cylindre
:epaisseur: épaisseur de l'interface entre les deux faces
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cylindre_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Coordonnées du centre de la base
coo_x = caract_face_1[2][1]
# 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
- l_diag = self._calcul_boite_englobante ( solide )
+ l_diag = self._calcul_boite_englobante ( solide, n_recur )
hauteur = 10.*l_diag
if self._verbose_max:
- print ("Hauteur englobante : {}".format(hauteur))
+ print_tab (n_recur, "Hauteur englobante : ", hauteur)
# Epaisseur
epaisseur = np.abs(caract_face_2[2][7]-caract_face_1[2][7])
#=========================== Début de la méthode =================================
- def _cree_face_mediane_cylindre_1 ( self, coo_x, coo_y, coo_z, axe_x, axe_y, axe_z, rayon, hauteur ):
+ def _cree_face_mediane_cylindre_1 ( self, coo_c, v_axe, rayon, hauteur, n_recur ):
"""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
:axe_x, axe_y, axe_z: coordonnées de l'axe
:rayon: rayon moyen entre les deux faces
:hauteur: hauteur du cylindre
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cylindre_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
# Les caractéristiques du cylindre à créer
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 = model.addPoint(self.part_doc, coo_x, coo_y, coo_z)
- nom_centre = "{}_centre".format(self.nom_solide)
- centre.result().setName(nom_centre)
-
-# Création de l'axe
- axe = model.addAxis(self.part_doc, axe_x, axe_y, axe_z)
- nom_axe = "{}_axe".format(self.nom_solide)
- axe.result().setName(nom_axe)
-
-# Création du plan perpendiculaire à l'axe
- plan = model.addPlane(self.part_doc, model.selection("EDGE", nom_axe), model.selection("VERTEX", nom_centre), True)
- nom_plan = "{}_plan".format(self.nom_solide)
- plan.result().setName(nom_plan)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Centre : ({}, {}, {})".format(coo_c[0], coo_c[1], coo_c[2]))
+ print_tab (n_recur, "Axe : ({}, {}, {})".format(v_axe[0], v_axe[1], v_axe[2]))
+ print_tab (n_recur, "Rayon : ", rayon)
+ print_tab (n_recur, "Hauteur : ", hauteur)
-# Création d'un sketch
+# 1. Objets préalables
nom_par_1 = "{}_R".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_1), "{}".format(rayon))
nom_par_2 = "{}_H".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_2), "{}".format(hauteur))
- sketch = model.addSketch(self.part_doc, model.selection("FACE", nom_plan))
+ centre, axe, plan = self._cree_centre_axe_plan ( coo_c, v_axe, self.nom_solide, n_recur )
- SketchProjection_1 = sketch.addProjection(model.selection("VERTEX", nom_centre), False)
+# 2. Création de l'esquisse
+ sketch = self._cree_face_mediane_cylindre_1_a ( plan, centre, rayon, nom_par_1, n_recur )
+
+# 3. La face
+ face = self._cree_face_mediane_cylindre_1_b ( sketch, nom_par_2, n_recur )
+
+ return face
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _cree_face_mediane_cylindre_1_a ( self, plan, centre, rayon, nom_par_1, n_recur ):
+ """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 :
+ :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
+ :nom_par_1: nom_par_1
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :face: la face médiane
+"""
+ nom_fonction = __name__ + "/_cree_face_mediane_cylindre_1_a"
+ blabla = "Dans {} :\n".format(nom_fonction)
+
+# Les caractéristiques du cylindre à créer
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Plan : {}".format(plan.name()))
+ print_tab (n_recur, "Centre : {}".format(centre.name()))
+ print_tab (n_recur, "Rayon : ", rayon)
+
+ sketch = model.addSketch(self.part_doc, model.selection("FACE", plan.name()))
+
+ SketchProjection_1 = sketch.addProjection(model.selection("VERTEX", centre.name()), False)
SketchPoint_1 = SketchProjection_1.createdFeature()
SketchCircle_1 = sketch.addCircle(0., 0., rayon)
sketch.setCoincident(SketchPoint_1.result(), SketchCircle_1.center())
sketch.setRadius(SketchCircle_1.results()[1], nom_par_1)
model.do()
+
nom_sketch = "{}_esquisse".format(self.nom_solide)
- sketch.setName(nom_sketch)
- sketch.result().setName(nom_sketch)
+ nommage (sketch, nom_sketch)
+
+ return sketch
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _cree_face_mediane_cylindre_1_b ( self, sketch, nom_par_2, n_recur ):
+ """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 :
+ :sketch: l'esquisse
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :face: la face médiane
+"""
+ nom_fonction = __name__ + "/_cree_face_mediane_cylindre_1_b"
+ blabla = "Dans {} :\n".format(nom_fonction)
+
+# Les caractéristiques du cylindre à créer
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Esquisse : ", sketch.name())
+ print_tab (n_recur, "nom_par_2 : ", nom_par_2)
# Création du cylindre complet
- cylindre = model.addExtrusion(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(nom_sketch))], model.selection(), nom_par_2, nom_par_2, "Edges")
+ cylindre = model.addExtrusion(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(sketch.name()))], model.selection(), nom_par_2, nom_par_2, "Edges")
+
nom_cylindre = "{}_cylindre".format(self.nom_solide)
- cylindre.setName(nom_cylindre)
- cylindre.result().setName(nom_cylindre)
- cylindre.result().setColor(85, 0, 255)
+ nommage (cylindre, nom_cylindre, (85, 0, 255))
# Intersection de la face cylindrique avec le solide initial
face = self._creation_face_inter ( nom_cylindre )
#=========================== Début de la méthode =================================
- def _cree_face_mediane_sphere ( self, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_sphere ( self, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des sphères
Entrées :
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_sphere"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Caractéristiques des sphères
- coo_x, coo_y, coo_z, rayon, epaisseur = self._cree_face_mediane_sphere_0 ( caract_face_1, caract_face_2 )
+ coo_x, coo_y, coo_z, rayon, epaisseur = self._cree_face_mediane_sphere_0 ( caract_face_1, caract_face_2, n_recur )
# Contrôle de la validité de l'épaisseur
erreur = self._verif_epaisseur ( epaisseur )
#=========================== Début de la méthode =================================
- def _cree_face_mediane_sphere_0 ( self, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_sphere_0 ( self, caract_face_1, caract_face_2, n_recur ):
"""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
+ :n_recur: niveau de récursivité
Sorties :
:coo_x, coo_y, coo_z: coordonnées du centre de la sphère
:rayon: rayon moyen entre les deux faces
:epaisseur: épaisseur de l'interface entre les deux faces
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_sphere_0"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Coordonnées du centre de la sphère
coo_x = caract_face_1[2][1]
Sorties :
:face: la face externe de la sphère support
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_sphere_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
# Les caractéristiques de la sphère à créer
if self._verbose_max:
nom_plan = "{}_plan".format(self.nom_solide)
plan.result().setName(nom_plan)
-# Création d'un sketch
+# Création de l'esquisse
nom_par_1 = "{}_R".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_1), "{}".format(rayon))
# Création de la sphère complète
sphere = model.addRevolution(self.part_doc, [model.selection("COMPOUND", nom_sketch)], model.selection("EDGE", "{}/{}".format(nom_sketch,nom_ligne)), 360, 0, "Edges")
+
nom_sphere = "{}_sphere".format(self.nom_solide)
- sphere.setName(nom_sphere)
- sphere.result().setName(nom_sphere)
- sphere.result().setColor(85, 0, 255)
+ nommage (sphere, nom_sphere, (85, 0, 255))
# Intersection de la face sphérique avec le solide initial
face = self._creation_face_inter ( nom_sphere )
#=========================== Début de la méthode =================================
- def _cree_face_mediane_tore ( self, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_tore ( self, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des tores
Entrées :
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_tore"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# 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 )
+ 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, n_recur )
# Contrôle de la validité de l'épaisseur (bidon)
erreur = self._verif_epaisseur ( EP_MIN*10. )
#=========================== Début de la méthode =================================
- def _cree_face_mediane_tore_0 ( self, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_tore_0 ( self, caract_face_1, caract_face_2, n_recur ):
"""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
+ :n_recur: niveau de récursivité
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)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Coordonnées du centre du tore
coo_x = caract_face_1[2][1]
Sorties :
:face: la face externe du tore support
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_tore_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
# Les deux faces
if self._verbose_max:
nom_plan = "{}_plan".format(self.nom_solide)
plan.result().setName(nom_plan)
-# Création d'un sketch
+# Création de l'esquisse
nom_par_1 = "{}_R_1".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_1), "{}".format(rayon_1))
nom_par_2 = "{}_R_2".format(self.nom_solide)
#=========================== Début de la méthode =================================
- def _cree_face_mediane_cone ( self, geompy, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_cone ( self, geompy, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des cones
Entrées :
:geompy: environnement de GEOM
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
+ :n_recur: niveau de récursivité
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cone"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# 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 )
+ 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, n_recur )
# Contrôle de la validité de l'épaisseur (bidon)
erreur = self._verif_epaisseur ( EP_MIN*10. )
#=========================== Début de la méthode =================================
- def _cree_face_mediane_cone_0 ( self, geompy, caract_face_1, caract_face_2 ):
+ def _cree_face_mediane_cone_0 ( self, geompy, caract_face_1, caract_face_2, n_recur ):
"""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
+ :n_recur: niveau de récursivité
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)
+ blabla = "Dans {} :".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)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "face_1 : ", caract_face_1)
+ print_tab (n_recur, "face_2 : ", caract_face_2)
# Coordonnées du centre de la base
coo_x = caract_face_1[2][1]
Sorties :
:face: la face externe du cone support
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cone_1"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
# Les deux faces
if self._verbose_max:
nom_plan = "{}_plan".format(self.nom_solide)
plan.result().setName(nom_plan)
-# Création d'un sketch
+# Création de l'esquisse
nom_par_1 = "{}_R_1".format(self.nom_solide)
model.addParameter(self.part_doc, "{}".format(nom_par_1), "{}".format(rayon_1))
nom_par_2 = "{}_R_2".format(self.nom_solide)
#=========================== Début de la méthode =================================
- def _calcul_boite_englobante ( self, objet ):
+ def _cree_centre_axe_plan ( self, coo_c, vnor, prefixe, n_recur ):
+ """Crée un centre, un axe, un plan
+
+Préparatifs
+
+Entrées :
+ :coo_c: coordonnées du centre de la base
+ :vnor: coordonnées du vecteur normal
+ :prefix: prefixe du nom des objets
+ :n_recur: niveau de récursivité
+
+Sorties :
+ :centre: centre
+ :normal: vecteur normal
+ :plan: plan
+"""
+
+ nom_fonction = __name__ + "/_cree_centre_axe_plan"
+ blabla = "Dans {} :".format(nom_fonction)
+ if self._verbose_max:
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "Centre : ({}, {}, {})".format(coo_c[0], coo_c[1], coo_c[2]))
+ print_tab (n_recur, "Normale : ({}, {}, {})".format(vnor[0], vnor[1], vnor[2]))
+
+# Création du point central
+ centre = model.addPoint(self.part_doc, coo_c[0], coo_c[1], coo_c[2])
+ nom_centre = "{}_centre".format(prefixe)
+ nommage (centre, nom_centre)
+ model.do()
+
+# Création du vecteur normal
+ v_norm = model.addAxis(self.part_doc, vnor[0], vnor[1], vnor[2])
+ nom_vnorm = "{}_normale".format(prefixe)
+ nommage (v_norm, nom_vnorm)
+
+# Création du plan perpendiculaire au vecteur normal
+ plan = model.addPlane(self.part_doc, model.selection("EDGE", v_norm.name()), model.selection("VERTEX", centre.name()), True)
+ nom_plan = "{}_plan".format(prefixe)
+ nommage (plan, nom_plan)
+
+ print ("fin de {}".format(nom_fonction))
+
+ return centre, v_norm, plan
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _calcul_boite_englobante ( self, objet, n_recur ):
"""Crée la hauteur englobant à coup sûr l'objet
Entrées :
:objet: l'objet à traiter
+ :n_recur: niveau de récursivité
Sorties :
:l_diag: longueur de la diagonale de la boîte englobante
- """
+"""
nom_fonction = __name__ + "/_calcul_boite_englobante"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- texte = blabla[:-1]
- print (texte)
+ print_tab (n_recur, blabla)
# Hauteur : la diagonale de la boîte englobante permet d'être certain de tout prendre
if self._verbose_max:
- texte = "Création de la boite englobante pour l'objet '{}' ".format(objet.name())
- texte += "de type '{}'".format(objet.shapeType())
- print (texte)
+ print_tab (n_recur, "Création de la boite englobante pour l'objet ", objet.name())
+ print_tab (n_recur, "de type ", objet.shapeType())
+ #print ('bbox = model.getBoundingBox(self.part_doc, model.selection("{}", "{}"))'.format(objet.shapeType(),objet.name()))
bbox = model.getBoundingBox(self.part_doc, model.selection("{}".format(objet.shapeType()), "{}".format(objet.name())))
+ bbox.execute(True)
bbox_nom = bbox.name()
if self._verbose_max:
- print ("Boîte englobante : '{}' '{}'".format(bbox.name(), bbox.result().name()))
+ print_tab (n_recur, "Boîte englobante : '{}' '{}'".format(bbox.name(), bbox.result().name()))
if self._verbose_max:
coo_min = model.getPointCoordinates(self.part_doc, \
model.selection("VERTEX", "[{}_1/Back][{}_1/Left][{}_1/Bottom]".format(bbox_nom,bbox_nom,bbox_nom)))
coo_max = model.getPointCoordinates(self.part_doc, \
model.selection("VERTEX", "[{}_1/Front][{}_1/Right][{}_1/Top]".format(bbox_nom,bbox_nom,bbox_nom)))
- texte = "\tXmin = {}, Xmax = {}\n".format(coo_min[0],coo_max[0])
+ texte = "Xmin = {}, Xmax = {}\n".format(coo_min[0],coo_max[0])
texte += "\tYmin = {}, Ymax = {}\n".format(coo_min[1],coo_max[1])
texte += "\tZmin = {}, Zmax = {}".format(coo_min[2],coo_max[2])
- print(texte)
+ print_tab (n_recur, texte)
l_diag = model.measureDistance(self.part_doc, \
model.selection("VERTEX", "[{}_1/Back][{}_1/Left][{}_1/Bottom]".format(bbox_nom,bbox_nom,bbox_nom)), \
model.selection("VERTEX", "[{}_1/Front][{}_1/Right][{}_1/Top]".format(bbox_nom,bbox_nom,bbox_nom)) )
if self._verbose_max:
- print ("Longueur de la diagonale : {}".format(l_diag))
+ print_tab (n_recur, "Longueur de la diagonale : ", l_diag)
return l_diag
"""Crée un volume de révolution
Entrées :
- :nom_sketch: nom du sketch à révolutionner
+ :nom_sketch: nom de l'esquisse à révolutionner
:nom_centre: nom du point associé au centre du volume de révolution
: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_objet: nom de l'objet 2D créé
- """
+"""
nom_fonction = __name__ + "/_cree_revolution"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
texte = blabla
# Création de l'objet complet
objet = model.addRevolution(self.part_doc, [model.selection("COMPOUND", nom_sketch)], model.selection("EDGE", nom_axe_r), 360, 0, "Edges")
- objet.setName(nom_objet)
- objet.result().setName(nom_objet)
- objet.result().setColor(85, 0, 255)
+
+ nommage (objet, nom_objet, (85, 0, 255))
return
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)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
print (blabla)
#=========================== Début de la méthode =================================
- def face_mediane_solide (self, solide, geompy, objet_geom):
+ def face_mediane_solide (self, solide, geompy, objet_geom, n_recur=0):
"""Calcul de la face médiane pour un solide
Entrées :
:solide: solide SHAPER à traiter
:geompy: environnement de GEOM
- :objet_geom: l'objet solide au format GEOM à traiter
+ :objet_geom: l'objet solide à traiter au format GEOM
+ :n_recur: niveau de récursivité
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/face_mediane_solide"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla, saut_av=True)
if self._verbose:
- print ("Traitement du solide '{}'".format(solide.name()))
+ print_tab (n_recur, "Traitement du solide ", solide.name())
# 1. Préalables
# 2. Explosion du solide en faces
- erreur, message, l_faces = self._faces_du_solide ( geompy, objet_geom )
+ erreur, message, l_faces_geom, l_faces = self._faces_du_solide ( geompy, objet_geom, solide, n_recur )
if erreur:
break
# 3. Calcul des caractéristiques géométriques des faces
- tb_caract = self._calcul_caract_faces ( geompy, l_faces )
+ tb_caract = self._calcul_caract_faces ( geompy, l_faces_geom, n_recur )
# 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 )
+ erreur, message, caract_face_1, caract_face_2 = self._tri_faces ( tb_caract, n_recur )
if erreur:
break
# 5. Création de la face médiane
- erreur, face = self._cree_face_mediane ( solide, geompy, caract_face_1, caract_face_2 )
+ erreur, face = self._cree_face_mediane ( solide, geompy, caract_face_1, caract_face_2, n_recur )
if erreur:
break
#=========================== Début de la méthode =================================
- def _traitement_objet (self, solide=None, objet_geom=None):
+ def _traitement_objet (self, solide=None, objet_geom=None, n_recur=0):
"""Traitement d'un objet
Entrées :
:solide: solide SHAPER à traiter
:objet_geom: l'objet GEOM équivalent
+ :n_recur: niveau de récursivité
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/_traitement_objet"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla, saut_av=True)
+ print_tab (n_recur, "solide = " , solide)
+ print_tab (n_recur, "objet_geom = ", objet_geom)
# 1. Préalables
if self._export_step:
if self._verbose_max:
- print ("Préparation de l'export STEP")
+ print_tab (n_recur, "Préparation de l'export STEP")
if self.rep_step is None:
if self.ficcao is None:
else:
os.mkdir(self.rep_step)
if self._verbose_max:
- print ("Les fichiers CAO des surfaces seront dans le répertoire {}".format(self.rep_step))
+ print_tab (n_recur, "Les fichiers CAO des surfaces seront dans le répertoire {}".format(self.rep_step))
# 5. Calcul réel de la face médiane
if solide is None:
self.nom_solide = objet_geom.GetName()
- erreur, message = self.face_mediane_solide (solide, geompy, objet_geom)
+ erreur, message = self.face_mediane_solide (solide, geompy, objet_geom, n_recur)
if erreur:
break
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_fic_cao"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
print (blabla)
# 1. Définition de la pièce
self.part_doc = model.activeDocument()
+ if ( self.part_doc.kind() == "PartSet" ):
+ part = model.addPart(self.part_doc)
+ self.part_doc = part.document()
# 2. Import de la CAO
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_objet_shaper"
- blabla = "Dans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
print (blabla)
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/_surf_objet_shaper_0"
blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
- prefixe = ""
- for _ in range(n_recur):
- prefixe += "\t"
- texte = "\n{}{}".format(prefixe,blabla)
- texte += "{}n_recur = {}".format(prefixe,n_recur)
- print (texte)
+ print_tab (n_recur, blabla)
+ print_tab (n_recur, "n_recur = ", n_recur)
erreur = 0
message = ""
if ( n_recur == 0 ):
self.part_doc = model.activeDocument()
- objet_0 = objet.result()
- self.objet_principal = objet_0
+ objet_0, l_faces = self._surf_objet_shaper_00 (objet)
else:
objet_0 = objet
+ print_tab (n_recur, "Examen de l'objet ", objet.name(), saut_av=True)
+ print_tab (n_recur, "Type python : ", type(objet))
+ print_tab (n_recur, "Type ", objet.shapeType())
# 2. On descend dans l'arborescence des sous-objets jusqu'à en trouver un qui n'en n'a pas
nb_sub_results = objet_0.numberOfSubs()
if self._verbose_max:
- texte = "Examen de l'objet '{}' ".format(objet_0.name())
- texte += "de type '{}'".format(objet_0.shapeType())
- texte += "\nobjet.result().numberOfSubs() : {}".format(nb_sub_results)
- print (texte)
+ print_tab (n_recur, "Examen de l'objet '{}' de type ".format(objet_0.name()), objet_0.shapeType(), saut_av=True)
+ print_tab (n_recur, "objet.result().numberOfSubs() : ", nb_sub_results)
for n_sobj in range(nb_sub_results):
if erreur:
break
+ if erreur:
+ break
+
# 2.2. Cet objet n'a pas de sous-objets. Si c'est un solide, on le traite
if ( objet_0.shapeType() == "SOLID" ):
- erreur, message = self.surf_solide_shaper ( objet_0 )
+ erreur, message = self.surf_solide_shaper ( objet_0, n_recur )
if erreur:
break
- if erreur:
- break
-
# 3. Futur message pour le résultat
if self._export_step:
#=========================== Début de la méthode =================================
- def _surf_objet_shaper_1 (self):
+ def _surf_objet_shaper_00 (self, objet):
+ """Liste les faces d'un objet SHAPER passé en argument
+
+Entrées :
+ :objet: objet à traiter
+
+Sorties :
+ :objet_0: le résultat associé à l'objet
+ :l_faces: liste des faces
+"""
+
+ nom_fonction = __name__ + "/_surf_objet_shaper_00"
+ blabla = "Dans {} :\n".format(nom_fonction)
+
+ if self._verbose_max:
+ print (blabla)
+
+# 1. Objet principal
+ objet_0 = objet.result()
+ self.objet_principal = objet_0
+ objet_bis = objet.defaultResult().shape()
+ if self._verbose_max:
+ print_tab (0, "Examen de l'objet initial ", objet.result().name(), saut_av=True)
+ print_tab (0, "Type python : ", type(objet))
+ print_tab (0, "Type {} / {} ; volume = ".format(objet_bis.shapeType(),objet_bis.shapeTypeStr()), GeomAlgoAPI_ShapeTools.volume(objet_bis))
+
+# 2. Décomposition
+# 2.1. En volumes
+ l_volumes = list()
+ exp = GeomAPI_ShapeExplorer(objet_bis, GeomAPI_Shape.SOLID)
+ while exp.more():
+ l_volumes.append(exp.current().solid())
+ exp.next()
+
+# 2.2. Chaque volume en faces
+ for ivolume, volume in enumerate(l_volumes):
+
+ if self._verbose_max:
+ print_tab (1, "Volume n°{} ; volume = ".format(ivolume), GeomAlgoAPI_ShapeTools.volume(volume))
+ print_tab (1, "Type python : ", type(volume))
+ print_tab (1, "Type {} / ".format(volume.shapeType()), volume.shapeTypeStr())
+ #print ("\tInformations : {}".format(volume.shapeInfo()))
+
+ l_faces = list()
+ exp = GeomAPI_ShapeExplorer(volume, GeomAPI_Shape.FACE)
+ while exp.more():
+ l_faces.append(exp.current().face())
+ exp.next()
+
+ if self._verbose_max:
+ for iface, face in enumerate(l_faces):
+ print_tab (2, "Face n°{} ; surface = ".format(iface), GeomAlgoAPI_ShapeTools.area(face))
+
+ return objet_0, l_faces
+
+#=========================== Fin de la méthode ==================================
+
+#=========================== Début de la méthode =================================
+
+ def _surf_objet_shaper_1 (self, n_recur=0):
"""Gestion des surfaces médianes créées
+Entrées :
+ :n_recur: niveau de récursivité
+
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/_surf_objet_shaper_1"
blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
# 1. Informations sur les faces à problème
texte = "1 face pose"
else:
texte = "{} faces posent".format(self.faces_pb_nb)
- print ("\n{} problème.\n{}".format(texte,self.faces_pb_msg))
+ print_tab (n_recur, "{} problème.".format(texte), self.faces_pb_msg, saut_av=True)
# 2. Si plus d'une face a été créée
if ( len(self.l_faces_m) > 1 ):
# 2.1. Partition du paquet de faces
if self._verbose_max:
- print ("Partitionnnement des faces créées.")
+ print_tab (n_recur, "Partitionnnement des faces créées.")
l_objets = list()
for (face,_) in self.l_faces_m:
Partition_1.result().setName("{}_M".format(self.objet_principal.name()))
for iaux, (face,_) in enumerate(self.l_faces_m):
Partition_1.result().subResult(iaux).setName("{}".format(face.name()))
- self._couleur_objet (Partition_1, coul_r=0, coul_g=170, coul_b=0)
+ self._couleur_objet (Partition_1, n_recur, coul_r=0, coul_g=170, coul_b=0)
# 2.2. Récupération des faces individuelles
if self._verbose_max:
- print ("Récupération des faces individuelles.")
+ print_tab (n_recur, "Récupération des faces individuelles.")
l_objets = list()
for iaux, (face,_) in enumerate(self.l_faces_m):
# 2.3. Mise en dossier
if self._verbose_max:
- print ("Mise en dossier.")
+ print_tab (n_recur, "Mise en dossier.")
for (face,fonction_0) in self.l_faces_m:
dossier = model.addFolder(self.part_doc, fonction_0, face)
#=========================== Début de la méthode =================================
- def surf_solide_shaper (self, solide):
+ def surf_solide_shaper (self, solide, n_recur):
"""Calcule les surfaces médianes pour un solide SHAPER solide passé en argument
Entrées :
:solide: solide SHAPER à traiter
+ :n_recur: numéro de la récurrence
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_solide_shaper"
blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla, saut_av=True)
erreur = 0
message = ""
self.nom_solide = solide.name()
if self._verbose_max:
- print ("solide '{}'".format(self.nom_solide))
+ print_tab (n_recur, "solide : ", self.nom_solide)
# 1. Isolement du solide
- solide_aux, recover = self._isole_solide ( solide )
+ solide_aux, recover = self._isole_solide ( solide, n_recur )
# 2. Exportation dans un fichier step pour traitement dans GEOM
fichier = tempfile.mkstemp(suffix=".stp")[1]
if self._verbose_max:
- print ("fichier = {}".format(fichier))
- print ("solide = {}".format(solide_aux.name()))
- print ("de type = {}".format(solide_aux.shapeType()))
+ print_tab (n_recur, "fichier = ", fichier)
+ print_tab (n_recur, "solide = ", solide_aux.name())
+ print_tab (n_recur, "de type = ", solide_aux.shapeType())
export = model.exportToFile(self.part_doc, fichier, [model.selection(solide_aux.shapeType(), solide_aux.name())])
export.execute(True)
model.do()
os.remove(fichier)
# 4. Traitement de l'objet correspondant
- erreur, message = self._traitement_objet ( solide=solide_aux, objet_geom=objet_geom )
+ erreur, message = self._traitement_objet ( solide=solide_aux, objet_geom=objet_geom, n_recur=n_recur )
if ( erreur and self._verbose_max ):
print (blabla, message)
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_objet_geom"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
print (blabla)
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/lancement"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
if self._verbose_max:
print (blabla)
if __name__ == "__main__" :
+ HOME_SH_SM_EXCHANGE = os.environ["HOME_SH_SM_EXCHANGE"]
+ L_FIC_CAO = list()
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "Solid_7.step"))
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Objet_1.stp"))
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Naval_007.stp"))
+ ##L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Naval.stp"))
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Partition_2.step"))
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Partition_2_1_22.step"))
+ #L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Partition_2_1_5.step"))
+ L_FIC_CAO.append(os.path.join(HOME_SH_SM_EXCHANGE, "SHAPER", "SurfaceMediane", "CAO_STEP", "Observatoire.stp"))
+
+ for FIC_CAO in L_FIC_CAO:
+
# 1. Options
- L_OPTIONS = list()
- L_OPTIONS.append("-vmax")
- #L_OPTIONS.append("-export_step")
- FIC_CAO = os.path.join(os.getenv("SHAPER_ROOT_DIR"), "bin", "salome", "macros", "midSurface", "midSurface.stp")
- #FIC_CAO = os.path.join(os.getenv("HOME"), "salome-dev", "DEV_package", "modules", "src", "SHAPER", "src", "PythonAddons", "macros", "midSurface", "Objet_1.stp")
+ L_OPTIONS = list()
+ #L_OPTIONS.append("-h")
+ #L_OPTIONS.append("-v")
+ L_OPTIONS.append("-vmax")
+ L_OPTIONS.append("-export_step")
# 2. Lancement de la classe
- #print ("L_OPTIONS :", L_OPTIONS)
+ #print ("L_OPTIONS :", L_OPTIONS)
- SURFACE_MEDIANE = SurfaceMediane(L_OPTIONS)
- if SURFACE_MEDIANE.affiche_aide_globale:
- sys.stdout.write(SURFACE_MEDIANE.__doc__+"\n")
- else:
- model.begin()
- PARTSET = model.moduleDocument()
- _ = model.addPart(PARTSET)
- ERREUR, MESSAGE_ERREUR = SURFACE_MEDIANE.surf_fic_cao(FIC_CAO)
- if ERREUR:
- MESSAGE_ERREUR += "\n Code d'erreur : %d\n" % ERREUR
- sys.stderr.write(MESSAGE_ERREUR)
-
- del SURFACE_MEDIANE
+ SURFACE_MEDIANE = SurfaceMediane(L_OPTIONS)
+ if SURFACE_MEDIANE.affiche_aide_globale:
+ sys.stdout.write(SURFACE_MEDIANE.__doc__+"\n")
+ else:
+ model.begin()
+ PARTSET = model.moduleDocument()
+ _ = model.addPart(PARTSET)
+ ERREUR, MESSAGE_ERREUR = SURFACE_MEDIANE.surf_fic_cao(FIC_CAO)
+ if ERREUR:
+ MESSAGE_ERREUR += "\n Code d'erreur : %d\n" % ERREUR
+ sys.stderr.write(MESSAGE_ERREUR)
+ break
+
+ del SURFACE_MEDIANE
#sys.exit(0)
