X-Git-Url: http://git.salome-platform.org/gitweb/?a=blobdiff_plain;f=src%2FPythonAddons%2Fmacros%2FmidSurface%2FsurfaceMediane.py;h=666f5b7feae50146f5f1fb4731d8b5aaa4a2ac4a;hb=40949601c4ec555efcc6815c68a6b5e3e71ea3ba;hp=13e493ef5d5b467ac7df967818d62a2b740d05b0;hpb=04e2497fc973f0afc95d0a4a6f95e37fb27f45e8;p=modules%2Fshaper.git

diff --git a/src/PythonAddons/macros/midSurface/surfaceMediane.py b/src/PythonAddons/macros/midSurface/surfaceMediane.py
index 13e493ef5..666f5b7fe 100755
--- a/src/PythonAddons/macros/midSurface/surfaceMediane.py
+++ b/src/PythonAddons/macros/midSurface/surfaceMediane.py
@@ -36,7 +36,7 @@ guillaume.schweitzer@blastsolutions.io
 Gérald NICOLAS
 """
 
-__revision__ = "V10.49"
+__revision__ = "V10.56"
 
 #========================= Les imports - Début ===================================
 
@@ -124,15 +124,21 @@ def import_cao (part_doc, ficcao, nom_objet=None, verbose=False):
 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
 
@@ -166,11 +172,62 @@ Sorties :
       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):
@@ -203,7 +260,7 @@ On sait traiter les faces :
   . 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.
@@ -217,6 +274,22 @@ Options facultatives
 . 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
@@ -260,7 +333,7 @@ Options facultatives
 
 Décodage des arguments
 On cherche ici les arguments généraux : aide, verbeux
-    """
+"""
 
     for option in liste_option :
 
@@ -304,7 +377,7 @@ Entrées :
 
 Sorties :
   :rang: rang du sous-objet
-    """
+"""
 
     nom_fonction = __name__ + "/_nom_sous_objets"
     blabla = "Dans {} :\n".format(nom_fonction)
@@ -377,23 +450,19 @@ Entrées :
 
 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
@@ -403,10 +472,10 @@ Sorties :
     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):
 
@@ -416,8 +485,7 @@ Sorties :
 
 # 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))
@@ -428,128 +496,198 @@ Sorties :
 
 #=========================== 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):
@@ -558,6 +696,7 @@ Sorties :
       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
@@ -572,28 +711,30 @@ Sorties :
 
 #=========================== 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])
@@ -633,10 +774,10 @@ Entrées :
 
 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
@@ -664,10 +805,10 @@ Sorties :
 
 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
@@ -687,6 +828,7 @@ Entrées :
 
     else:
       erreur = 0
+    #print ("erreur = {}".format(erreur))
 
     return erreur
 
@@ -694,26 +836,26 @@ Entrées :
 
 #=========================== 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
@@ -725,24 +867,24 @@ Sorties :
 
 # 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:
@@ -757,7 +899,7 @@ Sorties :
 # 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
 
@@ -765,26 +907,27 @@ Sorties :
 
 #=========================== 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))
@@ -801,32 +944,33 @@ Entrées :
 
 #=========================== 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
 
@@ -836,7 +980,7 @@ Sorties :
 
 #=========================== 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
@@ -845,22 +989,22 @@ 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 :
   :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
@@ -872,17 +1016,17 @@ Sorties :
     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
 
@@ -890,147 +1034,233 @@ Sorties :
 
 #=========================== 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
@@ -1038,28 +1268,26 @@ Entrées :
 
 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
@@ -1081,10 +1309,10 @@ Entrées :
 
 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)
@@ -1107,38 +1335,38 @@ Sorties :
 
 #=========================== 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
@@ -1147,7 +1375,7 @@ Sorties :
 
 #=========================== 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
@@ -1155,6 +1383,7 @@ 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
@@ -1162,16 +1391,15 @@ Sorties :
   :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]
@@ -1184,10 +1412,10 @@ Sorties :
 #   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])
 
@@ -1197,7 +1425,7 @@ Sorties :
 
 #=========================== 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
@@ -1207,62 +1435,112 @@ Entrées :
   :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 )
@@ -1273,28 +1551,28 @@ Sorties :
 
 #=========================== 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 )
@@ -1311,29 +1589,29 @@ Sorties :
 
 #=========================== 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]
@@ -1361,10 +1639,10 @@ Entrées :
 
 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:
@@ -1383,7 +1661,7 @@ Sorties :
     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))
 
@@ -1415,10 +1693,9 @@ Sorties :
 
 #   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 )
@@ -1429,28 +1706,28 @@ Sorties :
 
 #=========================== 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. )
@@ -1467,30 +1744,30 @@ Sorties :
 
 #=========================== 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]
@@ -1523,10 +1800,10 @@ Entrées :
 
 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:
@@ -1552,7 +1829,7 @@ Sorties :
     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)
@@ -1597,29 +1874,29 @@ Sorties :
 
 #=========================== 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. )
@@ -1636,7 +1913,7 @@ Sorties :
 
 #=========================== 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
@@ -1644,23 +1921,23 @@ 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]
@@ -1714,9 +1991,9 @@ Entrées :
 
 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:
@@ -1742,7 +2019,7 @@ Sorties :
     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)
@@ -1797,50 +2074,98 @@ Sorties :
 
 #=========================== 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
 
@@ -1852,17 +2177,17 @@ Sorties :
     """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
@@ -1882,9 +2207,8 @@ Entrées :
 
 #   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
 
@@ -1903,10 +2227,10 @@ Entrées :
 
 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)
@@ -1919,26 +2243,27 @@ Sorties :
 
 #=========================== 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
 
@@ -1949,23 +2274,23 @@ Sorties :
 
 # 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
 
@@ -1990,23 +2315,26 @@ Sorties :
 
 #=========================== 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
 
@@ -2028,7 +2356,7 @@ Sorties :
       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:
@@ -2042,14 +2370,14 @@ Sorties :
             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
 
@@ -2071,10 +2399,10 @@ Entrées :
 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)
@@ -2131,10 +2459,10 @@ Entrées :
 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)
@@ -2178,18 +2506,14 @@ Entrées :
 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 = ""
@@ -2200,20 +2524,20 @@ Sorties :
 
       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):
 
@@ -2223,16 +2547,16 @@ Sorties :
         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:
@@ -2246,19 +2570,81 @@ Sorties :
 
 #=========================== 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
 
@@ -2267,7 +2653,7 @@ Sorties :
         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 ):
@@ -2275,7 +2661,7 @@ Sorties :
 # 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:
@@ -2286,12 +2672,12 @@ Sorties :
       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):
@@ -2305,7 +2691,7 @@ Sorties :
 # 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)
@@ -2317,22 +2703,23 @@ Sorties :
 
 #=========================== 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 = ""
@@ -2341,18 +2728,18 @@ Sorties :
 
       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()
@@ -2370,7 +2757,7 @@ Sorties :
       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)
@@ -2401,10 +2788,10 @@ Entrées :
 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)
@@ -2427,10 +2814,10 @@ Sorties :
 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)
@@ -2452,31 +2839,44 @@ Sorties :
 
 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
-  FIC_CAO = os.path.join(os.getenv("HOME"), "dev", "git", "shaper", "src", "PythonAddons", "macros", "midSurface", "midSurface.stp")
 
-  L_OPTIONS = list()
-  #L_OPTIONS.append("-h")
-  #L_OPTIONS.append("-v")
-  L_OPTIONS.append("-vmax")
-  #L_OPTIONS.append("-export_step")
+    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)