Gérald NICOLAS
"""
-__revision__ = "V11.27"
+__revision__ = "V11.28"
#========================= Les imports - Début ===================================
def exec_nom (fonction, nom=None, couleur=None):
"""Exécute la fonction puis éventuellement la nomme et nomme son résultat ; Couleur éventuelle
-Attention : il faut commencer par exécuter la fonction sinon l enommage n'est pas cohérent en mode macro. Mystère...
+Attention : il faut commencer par exécuter la fonction sinon le nommage n'est pas cohérent en mode macro. Mystère...
Entrées :
:fonction: fonction à traiter
#=========================== Début de la méthode =================================
- def _cree_face_mediane ( self, solide, caract_face_1, caract_face_2, tb_caract, n_recur ):
+ def _cree_face_mediane ( self, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres
Entrées :
:solide: solide SHAPER à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
- :tb_caract: tableau des caractéristiques géométriques des faces
:n_recur: niveau de récursivité
Sorties :
# 2. Traitement selon la forme de la face
# 2.1. Face plane
if forme in ( "Disk", "Plane", "Rectangle" ):
- erreur, face = self._cree_face_mediane_plane ( solide, caract_face_1, caract_face_2, tb_caract, n_recur )
+ erreur, face = self._cree_face_mediane_plane ( solide, caract_face_1, caract_face_2, n_recur )
# 2.2. Face cylindrique
elif ( forme == "Cylinder" ):
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane ( self, solide, caract_face_1, caract_face_2, tb_caract, n_recur ):
+ def _cree_face_mediane_plane ( self, solide, caract_face_1, caract_face_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
Entrées :
:solide: l'objet solide à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
- :tb_caract: tableau des caractéristiques géométriques des faces
:n_recur: niveau de récursivité
Sorties :
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 ( solide, caract_face_1, caract_face_2, tb_caract, n_recur )
+ coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, d_face_1_2 = self._cree_face_mediane_plane_0 ( 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, n_recur )
+ face = self._cree_face_mediane_plane_1 ( solide, (coo_x, coo_y, coo_z),(vnor_x, vnor_y, vnor_z), d_face_1_2, n_recur )
else:
face = None
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_0 ( self, solide, caract_face_1, caract_face_2, tb_caract, n_recur ):
+ def _cree_face_mediane_plane_0 ( self, 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
Entrées :
- :solide: l'objet solide à traiter
:caract_face_1, caract_face_2: les caractéristiques des 2 faces les plus grandes
- :tb_caract: tableau des caractéristiques géométriques des faces
: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
"""
vnor_y = caract_face_1[2][5]
vnor_z = caract_face_1[2][6]
-# 2. Taille
-
-# taille : une longueur caractéristique pour être certain de tout prendre
- l_diag = self._calcul_lg_caract_0 ( solide, tb_caract, n_recur )
- taille = 10.*l_diag
- if self._verbose_max:
- print_tab (n_recur, "Taille englobante : ", taille)
-
-# 3. Distance entre les deux faces
+# 2. Distance entre les deux faces
face_1 = caract_face_1[0]
face_2 = caract_face_2[0]
d_face_1_2 = GeomAlgoAPI_ShapeTools.minimalDistance(face_1, face_2)
if self._verbose_max:
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
+ return coo_x, coo_y, coo_z, vnor_x, vnor_y, vnor_z, d_face_1_2
#=========================== Fin de la méthode ==================================
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_1 ( self, solide, coo_c, vnor, taille, d_face_1_2, n_recur ):
+ def _cree_face_mediane_plane_1 ( self, solide, coo_c, vnor, d_face_1_2, n_recur ):
"""Crée la face médiane entre deux autres - cas des surfaces planes
Création des objets de construction et de la face médiane
:solide: l'objet solide à traiter
: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é
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)
# 1. Préalables
- _, v_norm, plan = self._cree_centre_axe_plan ( coo_c, vnor, self.nom_solide, n_recur )
+ _, _, plan = self._cree_centre_axe_plan ( coo_c, vnor, self.nom_solide, n_recur )
-# 2. Création de l'esquisse
- sketch = self._cree_face_mediane_plane_1_a ( plan, taille, n_recur )
-
-# 3. La face
- face = self._cree_face_mediane_plane_1_b ( solide, sketch, v_norm, d_face_1_2, n_recur )
+# 2. La face
+ face = self._cree_face_mediane_plane_1_a ( solide, plan, d_face_1_2, n_recur )
#print ("fin de {}".format(nom_fonction))
#=========================== Début de la méthode =================================
- def _cree_face_mediane_plane_1_a ( self, plan, taille, n_recur ):
- """Crée la face médiane entre deux autres - cas des surfaces planes - l'esquisse
-
-Entrées :
- :plan: plan
- :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, "taille : {}".format(taille))
-
- sketch = model.addSketch(self.part_doc, model.selection("FACE", plan.name()))
- sketch.execute(True)
-
- ### Create SketchLine
- SketchLine_1 = sketch.addLine(-taille/2., taille/2., taille/2., taille/2.)
- SketchLine_1.execute(True)
-
- ### Create SketchLine
- SketchLine_2 = sketch.addLine(taille/2., taille/2., taille/2., -taille/2.)
- SketchLine_2.execute(True)
-
- ### Create SketchLine
- SketchLine_3 = sketch.addLine(taille/2., -taille/2., -taille/2., -taille/2.)
- SketchLine_3.execute(True)
-
- ### Create SketchLine
- SketchLine_4 = sketch.addLine(-taille/2., -taille/2., -taille/2., taille/2.)
- SketchLine_4.execute(True)
-
- model.do()
-
- nom_sketch = "{}_esquisse".format(self.nom_solide)
- exec_nom (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 ):
+ def _cree_face_mediane_plane_1_a ( self, solide, plan, 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
+ :plan: plan de l'une des grandes faces
:d_face_1_2: la distance entre les deux faces
:n_recur: niveau de récursivité
:face: la face médiane
"""
- nom_fonction = __name__ + "/_cree_face_mediane_plane_1_b"
+ 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, "Esquisse : ", sketch.name())
print_tab (n_recur, "Distance entre les deux faces : ", d_face_1_2)
# 1. Copie du solide pour gérer les intersections
- #Copy_1 = model.addCopy(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(self.nom_solide_aux))], 1)
Copy_1 = model.addMultiTranslation(self.part_doc, [model.selection("SOLID", self.nom_solide_aux)], model.selection("EDGE", "PartSet/OX"), 0, 1, keepSubResults = True)
nom = "{}_Copy_1".format(self.nom_solide_aux)
exec_nom (Copy_1,nom)
# 2. Création d'une face ; on la translate d'une demi-épaisseur.
for iaux in range(2):
-# 2.1. Création d'une face à partir du sketch et translation perpendiculaire au plan de la face
+# 2.1. Création d'un nouveau plan par translation perpendiculaire au plan de la face
# On essaie les 2 côtés alternativement car on ne sait pas lequel sera le bon
+ d_trans = 0.5*d_face_1_2*float(2*iaux-1)
- d_trans = -0.5*d_face_1_2*float(2*iaux-1)
+ planbis = model.addPlane(self.part_doc, model.selection("FACE", "all-in-{}".format(plan.name())), d_trans, False)
+ nom = "{}_plan_{}".format(self.nom_solide_aux,iaux)
+ exec_nom (planbis,nom)
- face = self._cree_face_mediane_plane_2 ( sketch.name(), v_norm.name(), nom_solide, d_trans, iaux, n_recur )
+# 2.2. Intersection de ce plan avec le solide initial
+ face = model.addCommon(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(nom_solide))], [model.selection("FACE", "all-in-{}".format(planbis.name()))], keepSubResults = True)
+ nom = "{}_face_{}".format(self.nom_solide_aux,iaux)
+ exec_nom (face,nom)
-# 2.2. Si on est du bon côté, alors on intersecte la face avec le solide et c'est bon
+# 2.3. Si on est du bon côté, c'est bon
if face.results():
- face = self._cree_face_mediane_plane_11 ( face, Recover_1, n_recur )
break
-# 2.3. Si l'intersection est vide, on crée une nouvelle copie du solide avant de tester l'autre côté
+# 2.4. Si l'intersection est vide, on crée une nouvelle copie du solide avant de tester l'autre côté
else:
if self._verbose_max:
print_tab (n_recur, "L'intersection est vide. On essaie l'autre côté")
#=========================== 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 de construction 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()])
- nom = "{}_Recover_2".format(self.nom_solide_aux)
- exec_nom (Recover_2,nom)
-
- 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, d_trans, 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 de l'esquisse
- :nom_normal: nom du vecteur normal
- :nom_solide: nom du solide à intersecter
- :d_trans: la distance de translation
- :icpt: numéro de la tentative
-
-Sorties :
- :face: la face médiane
-"""
-
- nom_fonction = __name__ + "/_cree_face_mediane_plane_2"
- blabla = "Dans {} :".format(nom_fonction)
- if self._verbose_max:
- 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, "d_trans : ", d_trans)
-
- # Création d'une face
- Face_1 = model.addFace(self.part_doc, [model.selection("COMPOUND", "all-in-{}".format(nom_sketch))])
- nom = "{}_Face_1_{}".format(self.nom_solide_aux,icpt)
- exec_nom (Face_1,nom)
- if self._verbose_max:
- print_tab (n_recur, "Après addFace pour Face_1 de nom ", nom)
-
-# On la translate
- Translation_1 = model.addTranslation(self.part_doc, [model.selection("FACE", Face_1.result().name())], axis = model.selection("EDGE", nom_normal), distance = d_trans, keepSubResults = True)
- nom = "{}_trans_{}".format(self.nom_solide_aux,icpt)
- exec_nom (Translation_1,nom)
- if self._verbose_max:
- print_tab (n_recur, "Après addTranslation pour Translation_1 de nom ", nom)
- Translation_1.result().setColor(85, 0, 255)
-
-# Intersection de cette face avec le solide initial
- face = self._creation_face_inter ( Translation_1.result().name(), nom_solide )
-
- return face
-
-#=========================== Fin de la méthode ==================================
-
-#=========================== Début de la méthode =================================
-
- def _cree_face_mediane_plane_3 ( self, face ):
- """Crée la face médiane entre deux autres - cas des surfaces planes
-
-Fusion des 2 intersections
-
-Entrées :
- :face: la face médiane composée de plusieurs intersections
-
-Sorties :
- :face_m: la face médiane
-"""
-
- nom_fonction = __name__ + "/_cree_face_mediane_plane_3"
- blabla = "Dans {} :\n".format(nom_fonction)
- if self._verbose_max:
- texte = blabla
- print (texte)
-
-# Nommage des sous-objets
- l_fuse = list()
- for iaux in range(face.result().numberOfSubs()):
- nom = "{}_common_{}".format(self.nom_solide_aux,iaux)
- face.result().subResult(iaux).setName(nom)
- l_fuse.append(model.selection("FACE", '{}'.format(nom)))
-
-# Fusion
- if self._verbose_max:
- print ("Fusion de {} faces.".format(len(l_fuse)))
- face_m = model.addFuse(self.part_doc, l_fuse, keepSubResults = True)
- face_m.execute(True)
-
- return face_m
-
-#=========================== Fin de la méthode ==================================
-
#=========================== Début de la méthode =================================
def _cree_face_mediane_cylindre ( self, solide, caract_face_1, caract_face_2, n_recur ):
# 4. Création de la face médiane
- erreur, face = self._cree_face_mediane ( solide, caract_face_1, caract_face_2, tb_caract, n_recur )
+ erreur, face = self._cree_face_mediane ( solide, caract_face_1, caract_face_2, n_recur )
if ( erreur or ( face is None ) ):
break
