Gérald NICOLAS
"""
-__revision__ = "V10.52"
+__revision__ = "V10.56"
#========================= Les imports - Début ===================================
"""
nom_fonction = __name__ + "/import_cao"
- blabla = "\nDans {} :\n".format(nom_fonction)
+ blabla = "Dans {} :\n".format(nom_fonction)
message_0 = "Fichier : {}\n".format(ficcao)
if verbose:
message = blabla + message_0
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 ===================================
. 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.
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))
Sorties :
:objet: le solide isolé
:recover: la fonction de récupération
- """
+"""
nom_fonction = __name__ + "/_isole_solide"
- blabla = "\nDans {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ 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 ( solide.name() != self.objet_principal.name() ):
+ objet, recover = self._isole_solide_a ( solide, n_recur )
- if self._verbose_max:
- print_tab (n_recur, ". 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_tab (n_recur, ". Mise en place du solide")
+#=========================== Début de la méthode =================================
- objet = solide
- self.nom_solide_aux = self.objet_principal.name()
- self.fonction_0 = None
- recover = None
+ 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
+"""
+ nom_fonction = __name__ + "/_isole_solide_b"
+ blabla = "Dans {} :".format(nom_fonction)
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)
+ 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)
- return objet, recover
+ if self._verbose_max:
+ print_tab (n_recur, ". Mise en place du solide")
+
+ self.nom_solide_aux = self.objet_principal.name()
+ self.fonction_0 = None
+
+ return solide, None
#=========================== Fin de la méthode ==================================
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 = ""
#=========================== 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):
_, aire, _ = geompy.BasicProperties(face)
#longueur, aire, volume = geompy.BasicProperties(face)
- if self._verbose_max or True:
+ 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)
#=========================== 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
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:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : " ,caract_face_1)
print_tab (n_recur, "face_2 : " ,caract_face_2)
# 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):
+ 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
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:
- print (blabla)
+ 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))
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, n_recur )
# 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), taille, d_face_1_2, n_recur )
else:
face = None
: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 {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_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, n_recur ):
+ 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 {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
- print_tab (n_recur, "Centre : ({}, {}, {})".format(coo_x, coo_y, coo_z))
- print_tab (n_recur, "Normale : ({}, {}, {})".format(vnor_x, vnor_y, vnor_z))
+ 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_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)
- # 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:
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_2 ( self, nom_sketch, nom_normal, nom_solide, distance, icpt=0 ):
+ 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, 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)
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:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
# 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
: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:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
#=========================== 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 )
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_sphere"
- blabla = "\nDans {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
: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 {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
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 )
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_tore"
- blabla = "\nDans {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
: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 {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
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)
Sorties :
:face: la face médiane
- """
+"""
nom_fonction = __name__ + "/_cree_face_mediane_cone"
- blabla = "\nDans {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ 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. )
: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 {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
# Les deux faces
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
print_tab (n_recur, "face_1 : ", caract_face_1)
print_tab (n_recur, "face_2 : ", caract_face_2)
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)
#=========================== Fin de la méthode ==================================
+#=========================== Début de la méthode =================================
+
+ 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 ):
Sorties :
:l_diag: longueur de la diagonale de la boîte englobante
- """
+"""
nom_fonction = __name__ + "/_calcul_boite_englobante"
- blabla = "\nDans {} :".format(nom_fonction)
+ blabla = "Dans {} :".format(nom_fonction)
if self._verbose_max:
- print (blabla)
+ print_tab (n_recur, blabla)
# Hauteur : la diagonale de la boîte englobante permet d'être certain de tout prendre
if self._verbose_max:
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:
"""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)
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_tab (n_recur, "Traitement du solide ", solide.name())
# 3. Calcul des caractéristiques géométriques des faces
- tb_caract = self._calcul_caract_faces ( geompy, l_faces_geom )
+ 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
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/_traitement_objet"
- blabla = "\nDans {} :".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)
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)
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_objet_shaper"
blabla = "Dans {} :".format(nom_fonction)
- if self._verbose_max or True:
+ if self._verbose_max:
print (blabla)
# 1. Acquisition de la liste des noms des sous-objets solides
# 3. Gestion des faces créées
- #self._surf_objet_shaper_1 ( )
+ self._surf_objet_shaper_1 ( )
# 4. Futur message pour le résultat
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 or True:
- prefixe = ""
- for _ in range(n_recur):
- prefixe += "\t"
- texte = "\n{}{}".format(prefixe,blabla)
- texte += "{}n_recur = {}".format(prefixe,n_recur)
- print (texte)
+ if self._verbose_max:
+ 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_bis = objet.defaultResult().shape()
- print_tab (n_recur, "Examen de l'objet ", objet.result().name(), saut_av=True)
- print_tab (n_recur, "Type python : ", type(objet))
- print_tab (n_recur, "Type {} / {} ; volume = ".format(objet_bis.shapeType(),objet_bis.shapeTypeStr()), GeomAlgoAPI_ShapeTools.volume(objet_bis))
- l_volumes = list()
- exp = GeomAPI_ShapeExplorer(objet_bis, GeomAPI_Shape.SOLID)
- while exp.more():
- l_volumes.append(exp.current().solid())
- exp.next()
-
- for ivolume, volume in enumerate(l_volumes):
- print_tab (n_recur+1, "Type python : ", type(volume))
- print_tab (n_recur+1, "Volume n°{} ; volume = ".format(ivolume), GeomAlgoAPI_ShapeTools.volume(volume))
- print_tab (n_recur+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()
-
- for iface, face in enumerate(l_faces):
- print_tab (n_recur+2, "Face n°{} ; surface = ".format(iface), GeomAlgoAPI_ShapeTools.area(face))
+ 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)
nb_sub_results = objet_0.numberOfSubs()
- if self._verbose_max or True:
- print_tab (n_recur, "Examen de l'objet '{}' de type ".format(objet_0.name()), objet_0.shapeType())
+ if self._verbose_max:
+ 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" ):
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)
Sorties :
:erreur: code d'erreur
:message: message d'erreur
- """
+"""
nom_fonction = __name__ + "/surf_solide_shaper"
blabla = "Dans {} :".format(nom_fonction)
- if self._verbose_max or True:
- print (blabla)
+ if self._verbose_max:
+ print_tab (n_recur, blabla, saut_av=True)
erreur = 0
message = ""
while not erreur :
self.nom_solide = solide.name()
- if self._verbose_max or True:
- print_tab (n_recur, "solide", self.nom_solide)
+ if self._verbose_max:
+ print_tab (n_recur, "solide : ", self.nom_solide)
# 1. Isolement du solide
solide_aux, recover = self._isole_solide ( solide, n_recur )
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)
#L_OPTIONS.append("-h")
#L_OPTIONS.append("-v")
L_OPTIONS.append("-vmax")
- #L_OPTIONS.append("-export_step")
+ L_OPTIONS.append("-export_step")
# 2. Lancement de la classe
