]> SALOME platform Git repositories - modules/shaper.git/blob - src/PythonAddons/macros/pipeNetwork/feature.py
Salome HOME
e857f7e483141984fecd00bbfcccb7ddf0d875cb
[modules/shaper.git] / src / PythonAddons / macros / pipeNetwork / feature.py
1 # -*- coding: utf-8 -*-
2 # Copyright (C) 2016-2020  CEA/DEN, EDF R&D
3 #
4 # This library is free software; you can redistribute it and/or
5 # modify it under the terms of the GNU Lesser General Public
6 # License as published by the Free Software Foundation; either
7 # version 2.1 of the License, or (at your option) any later version.
8 #
9 # This library is distributed in the hope that it will be useful,
10 # but WITHOUT ANY WARRANTY; without even the implied warranty of
11 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
12 # Lesser General Public License for more details.
13 #
14 # You should have received a copy of the GNU Lesser General Public
15 # License along with this library; if not, write to the Free Software
16 # Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA
17 #
18 # See http://www.salome-platform.org/ or email : webmaster.salome@opencascade.com
19 #
20
21 """pipeNetwork Feature
22 Author: Nathalie GORE - Gérald NICOLAS
23 Remarque : la fonction de partitionnement pour un futur maillage en hexa est désactivée.
24 """
25
26 __revision__ = "V02.17"
27
28 from salome.shaper import model
29 import ModelAPI
30 from GeomAPI import *
31
32 import numpy as np
33
34 # Si erreur :
35
36 def raiseException(texte):
37     """En cas d'erreur"""
38     print (texte)
39
40 def printverbose (texte, nb=0, verbose=False):
41     """Impression controlée"""
42     if verbose:
43         if nb:
44             texte_a = ""
45             for _ in range(nb):
46                 texte_a += "="
47             print (texte_a)
48         print (texte)
49
50 class pipeNetwork(model.Feature):
51     """Creation of a network of pipes"""
52     lfeatures = list()
53     ledges = list()
54     folder = None
55     isHexa = False
56     twopartwo = "2par2"
57     parligne = "par_ligne"
58     radius = 0.5
59     infoPoints = dict()
60     connectivities = dict()
61
62     _verbose = False
63     _verbose_max = False
64
65 # Feature initializations
66
67     def __init__(self):
68         """x.__init__(...) initializes x; see x.__class__.__doc__ for signature"""
69         model.Feature.__init__(self)
70
71     @staticmethod
72     def ID():
73         """Return Id of the Feature."""
74         return "pipeNetwork"
75
76     @staticmethod
77     def FILE_ID():
78         """Returns ID of the file select parameter."""
79         return "file_path"
80
81     #@staticmethod
82     #def HEXAS_ID():
83         #"""Returns ID of the radius parameter."""
84         #return "blocking"
85
86     def getKind(self):
87         """Override Feature.getKind()"""
88         return pipeNetwork.ID()
89
90
91 #====================================================================================
92 # Initialization of the dialog panel
93
94     def initAttributes(self):
95         """Override Feature.initAttributes()"""
96         # Creating the input argument of the feature
97         self.data().addAttribute(self.FILE_ID(), ModelAPI.ModelAPI_AttributeString_typeId())
98         #self.data().addAttribute(self.HEXAS_ID(), ModelAPI.ModelAPI_AttributeBoolean_typeId())
99
100 #====================================================================================
101 # Retrieve parent pipe
102
103     def decodingCode(self, code):
104         """decodingCode"""
105         splitCode = code.split(".")
106         if len(splitCode) <= 1:
107             previousCode = ""
108         else:
109             previousCode = code[:len(code)-len(splitCode[-1])-1]
110         return previousCode
111
112 #====================================================================================
113
114     def readNodeInfo(self, line):
115         """Lecture des noeuds
116
117 La ligne à décoder est formée des informations :
118 . l'identifiant du noeud
119 . si les coordonnées sont données en absolu : "-" suivi des 3 coordonnées
120 . si les coordonnées sont données en relatif : l'identifiant du noeud de départ, suivi des 3 coordonnées de la translation
121 Par défaut, on supposera que la connection est angulaire et que ce n'est pas une extrémité.
122         """
123         #print(line)
124         texte = line
125         splitLine = line.split()
126         if ( len(splitLine) != 5 ):
127             diagno = 1
128         elif splitLine[0] in self.infoPoints:
129             texte += "\nThis node was already declared."
130             diagno = 2
131         elif ( splitLine[1] not in self.infoPoints ) and ( splitLine[1] != "-" ):
132             texte += "\nThe starting point was not seen before."
133             diagno = 3
134         else:
135             diagno = 0
136             self.infoPoints[splitLine[0]] = dict()
137             self.infoPoints[splitLine[0]]["Ref"] = splitLine[1]
138             if splitLine[1] == "-":
139                 self.infoPoints[splitLine[0]]["X"] = float(splitLine[2])
140                 self.infoPoints[splitLine[0]]["Y"] = float(splitLine[3])
141                 self.infoPoints[splitLine[0]]["Z"] = float(splitLine[4])
142             else :
143                 self.infoPoints[splitLine[0]]["X"] = self.infoPoints[splitLine[1]]["X"] + float(splitLine[2])
144                 self.infoPoints[splitLine[0]]["Y"] = self.infoPoints[splitLine[1]]["Y"] + float(splitLine[3])
145                 self.infoPoints[splitLine[0]]["Z"] = self.infoPoints[splitLine[1]]["Z"] + float(splitLine[4])
146             printverbose ("Enregistrement du point ({},{},{})".format(self.infoPoints[splitLine[0]]["X"],self.infoPoints[splitLine[0]]["Y"],self.infoPoints[splitLine[0]]["Z"]), verbose=self._verbose)
147             self.infoPoints[splitLine[0]]["Fillet"] = "angular_connection"
148             self.infoPoints[splitLine[0]]["isEnd"] = False
149         #print ("Retour de readNodeInfo = {}".format(diagno))
150         return diagno, texte
151
152 #====================================================================================
153
154     def readConnectivity(self, line, method):
155         """Lecture des connectivités
156
157 La ligne à décoder est formée des informations :
158 . si la méthode est par ligne : la liste des identifiants des noeuds formant le trajet
159 . si la méthode est 2 par 2 : chaque tronçon est décrit par les identifiants des 2 noeuds
160 Par défaut, on supposera que la méthode est par ligne.
161         """
162         splitLine = line.split()
163         printverbose ("Enregistrement du tronçon : {}".format(splitLine),verbose=self._verbose)
164         diagno = 0
165         if ( method == self.twopartwo ):
166             if self.connectivities:
167                 # Recherche si le tronçon existe déjà ou s'il est nouveau
168                 existe = False
169                 for key, val in self.connectivities.items():
170                     #print(key, " ******* {}".format(val))
171                     if val['chainage'][-1] == splitLine[0]:
172                         # Le tronçon existe
173                         val['chainage'].append(splitLine[1])
174                         #print("On complète le tronçon")
175                         existe = True
176                         break
177                 # Le tronçon n'existe pas
178                 if not existe:
179                     #print("On démarre un nouveau tronçon - Cas 2")
180                     self.newConnectivity(splitLine[0], splitLine)
181             else :
182                 #print("On démarre un nouveau tronçon - Cas 1")
183                 self.newConnectivity(splitLine[0], splitLine)
184         else :
185             self.newConnectivity(splitLine[0], splitLine)
186         #print ("Retour de readConnectivity = {}".format(diagno))
187
188         return diagno
189
190 #====================================================================================
191
192     def correctConnectivity(self):
193         """Correction des connectivités pour tenir compte de points alignés
194
195 Si 3 points sont alignés sur une ligne et qu'aucune ligne ne part du point central,
196 il faut scinder la ligne au niveau de ce point pour traiter correctement la suite : on se mettrait
197 à créer un plan avec ces 3 points alignés et tout s'effondre ensuite.
198         """
199         while True:
200             # On explore toutes les lignes et on cherche un cas où sur une ligne 3 points consécutifs sont alignés
201             for _, value in self.connectivities.items():
202                 # Sur cette ligne, a-t-on 3 points consécutifs alignés ?
203                 modif = self.correctConnectivity_a(value["chainage"])
204                 # Si on a modifié la description des connectivités, on recommence l'analyse
205                 if modif:
206                     break
207             # Si plus rien n'a été modifié, c'est fini
208             if not modif:
209                 break
210
211     def correctConnectivity_a(self, l_noeuds):
212         """On explore toutes les lignes et on cherche un cas où sur une ligne 3 points consécutifs sont alignés
213
214 Entrées :
215   :l_noeuds: liste des noeuds de la ligne
216
217 Sorties :
218   :modif: on a modifié ou non la description des lignes
219         """
220         modif = False
221         nb_points = len(l_noeuds)
222         printverbose ("Analyse de {}".format(l_noeuds), verbose=self._verbose_max)
223         #print ("nb_points = {}".format(nb_points))
224
225         indice = 0
226         nb_test = nb_points - 2
227         for iaux in range(nb_test):
228             # Calcul de l'angle entre les 3 points de la séquence
229             vect = list()
230             #print ("({},{},{}".format(l_noeuds[iaux],l_noeuds[iaux+1],l_noeuds[iaux+2]))
231             for jaux in range(3):
232                 coox = self.infoPoints[l_noeuds[iaux+jaux]]["X"]
233                 cooy = self.infoPoints[l_noeuds[iaux+jaux]]["Y"]
234                 cooz = self.infoPoints[l_noeuds[iaux+jaux]]["Z"]
235                 vect.append(np.array((coox,cooy,cooz),np.float))
236             cosinus = np.dot(vect[1]-vect[0],vect[1]-vect[2])/(np.linalg.norm(vect[1]-vect[0])* np.linalg.norm(vect[1]-vect[2]))
237             #print ("cosinus = {}".format(cosinus))
238             # Si l'angle est plat, c'est que les 3 points sont alignés : on arrête... sauf si ce point est un départ d'une autre !
239             if ( (1.-np.abs(cosinus)) < 1.e-4 ):
240                 indice = iaux+1
241                 if l_noeuds[indice] not in self.connectivities:
242                     break
243                 else:
244                     indice = 0
245         # Si un angle plat a été trouvé, on scinde la ligne
246         if indice:
247             #print ("id_noeud_debut = {}, {}".format(l_noeuds[0], l_noeuds[:indice+1]))
248             #print ("id_noeud_new   = {}, {}".format(l_noeuds[indice], l_noeuds[indice:]))
249             self.newConnectivity(l_noeuds[0], l_noeuds[:indice+1])
250             self.newConnectivity(l_noeuds[indice], l_noeuds[indice:])
251             modif = True
252
253         return modif
254
255 #====================================================================================
256
257     def newConnectivity(self, key, value):
258         """newConnectivity"""
259         self.connectivities[key] = dict()
260         self.connectivities[key]['chainage'] = value
261
262 #====================================================================================
263
264     def readFillet(self, line):
265         """Décodage des caractéristiques de la connection entre deux tuyaux
266
267 La ligne est formée de deux informations :
268 . l'identifiant du noeud
269 . la caractérisation de la connection : "angular_connection" ou "radius=xxx"
270         """
271         splitLine = line.split()
272         if len(splitLine) != 2:
273             print(line)
274             diagno = 1
275         elif not splitLine[0] in self.infoPoints:
276             print(line)
277             diagno = 2
278         elif splitLine[1] == "angular_connection":
279             self.infoPoints[splitLine[0]]["Fillet"] = "angular_connection"
280             diagno = 0
281         elif splitLine[1][:7] == "radius=":
282             self.infoPoints[splitLine[0]]["Fillet"] = "radius"
283             self.infoPoints[splitLine[0]]["Radius"] = float(splitLine[1][7:])
284             diagno = 0
285         else:
286             print(line)
287             diagno = 3
288         #print ("Retour de readFillet = {}".format(diagno))
289         return diagno
290
291 #====================================================================================
292
293     def retrieveSubshapesforWire(self, copy, key, ind):
294         """retrieveSubshapesforWire"""
295         exp = GeomAPI_ShapeExplorer(copy.defaultResult().shape(), GeomAPI_Shape.EDGE)
296
297         end = False
298         subshapesForWire = list()
299         currentInd = 0
300         isPipe = True
301         #print("Current chainage : {}".format(self.connectivities[key]['chainage'][ind:]))
302         #print("Indice de démarrage = {}".format(ind))
303
304         while exp.more() and not end :
305             #print("Analyse Edge n°", currentInd)
306             #print(" => ", self.connectivities[key]['chainage'][currentInd], " - ", self.connectivities[key]['chainage'][currentInd+1])
307             #print(" ==> ", self.infoPoints[self.connectivities[key]['chainage'][currentInd]]["isAngular"], " - ", self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["isAngular"])
308             cur = exp.current().edge()
309             if currentInd < ind:
310                 #print("Edge non prise en compte")
311                 #print("test si fillet : ", currentInd+1, ind, self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["Fillet"])
312                 if currentInd+1 <= ind and self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["Fillet"] == "radius" and not self.infoPoints[self.connectivities[key]['chainage'][currentInd]]["isAngular"]:
313                     #print("Fillet à ne pas prendre en compte")
314                     exp.next()
315                     cur = exp.current().edge()
316             else :
317                 subshapesForWire.append(model.selection(copy.defaultResult(), cur))
318                 #print("Mode normal - Nb segments dans le wire : {}".format(len(subshapesForWire)))
319                 # Cas du fillet : on récupère l'edge suivante
320                 if self.infoPoints[self.connectivities[key]['chainage'][currentInd]]["isAngular"] or self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["isAngular"]:
321                     end = True
322                     #print("Nb segments dans le wire : {}".format(len(subshapesForWire)))
323                     if ( len(subshapesForWire) == 1 ):
324                         #print("Coude droit en cours")
325                         currentInd += 1
326                         isPipe = False
327                     else :
328                         #print("Coude droit à venir")
329                         subshapesForWire = subshapesForWire[:-1]
330                 elif self.infoPoints[self.connectivities[key]['chainage'][currentInd]]["Fillet"] == "radius":
331                     #print("Ajout edge start Fillet")
332                     exp.next()
333                     cur = exp.current().edge()
334                     subshapesForWire.append(model.selection(copy.defaultResult(), cur))
335                     #currentInd = currentInd+1
336                     #print("Mode Fillet - Nb segments dans le wire : {}".format(len(subshapesForWire)))
337                 elif self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["Fillet"] == "radius":
338                     #print("Ajout edge end Fillet")
339                     exp.next()
340                     cur = exp.current().edge()
341                     subshapesForWire.append(model.selection(copy.defaultResult(), cur))
342                     #print("Mode Fillet - Nb segments dans le wire : {}".format(len(subshapesForWire)))
343                 else :
344                     if self.infoPoints[self.connectivities[key]['chainage'][currentInd+1]]["isEnd"]:
345                         #print("Fin détecte")
346                         currentInd = currentInd+1
347                         end = True
348                     #else :
349                         #print("Branchement")
350             if not end:
351                 currentInd = currentInd+1
352             exp.next()
353             #print("End = {} {}".format(end,self.connectivities[key]['chainage'][currentInd]))
354
355         return subshapesForWire, currentInd, isPipe, self.connectivities[key]['chainage'][currentInd]
356
357 #====================================================================================
358
359     def retrieveLastElement(self, obj, typeOfElement):
360         """retrieveLastElement"""
361         exp = GeomAPI_ShapeExplorer(obj.defaultResult().shape(), typeOfElement)
362         while exp.more():
363             cur = None
364             if typeOfElement == GeomAPI_Shape.VERTEX :
365                 cur = exp.current().vertex()
366             elif typeOfElement == GeomAPI_Shape.EDGE :
367                 cur = exp.current().edge()
368             elif typeOfElement == GeomAPI_Shape.FACE :
369                 cur = exp.current().face()
370             elif typeOfElement == GeomAPI_Shape.SOLID :
371                 cur = exp.current().solid()
372             if cur is not None:
373                 exp.next()
374                 cur = model.selection(obj.defaultResult(), cur)
375         return cur
376
377 #====================================================================================
378
379     def retrieveFirstElement(self, obj, typeOfElement):
380         """retrieveFirstElement"""
381         exp = GeomAPI_ShapeExplorer(obj.defaultResult().shape(), typeOfElement)
382         cur = None
383         if typeOfElement == GeomAPI_Shape.VERTEX :
384             cur = exp.current().vertex()
385         elif typeOfElement == GeomAPI_Shape.EDGE :
386             cur = exp.current().edge()
387         elif typeOfElement == GeomAPI_Shape.FACE :
388             cur = exp.current().face()
389         elif typeOfElement == GeomAPI_Shape.SOLID :
390             cur = exp.current().solid()
391         if cur is not None:
392             exp.next()
393             cur = model.selection(obj.defaultResult(), cur)
394         return cur
395
396 #====================================================================================
397
398     def createPipe(self, part, connectivityInfos):
399         """createPipe"""
400         lPipes = list()
401         startFace = None
402         fuse = None
403         for ind in range(len(connectivityInfos['paths'])):
404             printverbose ("Step = {}".format(ind), 80, verbose=self._verbose_max)
405             if ind == 0:
406                 startFace = connectivityInfos['sketch']
407             if connectivityInfos['isPipe'][ind] :
408                 pipe = model.addPipe(part, [startFace], connectivityInfos['paths'][ind].result())
409             else :
410                 # recherche du plan
411                 if self.infoPoints[connectivityInfos['ends'][ind]]['isAngular']:
412                     pipe = model.addExtrusion(part, [startFace], model.selection(), self.infoPoints[connectivityInfos['ends'][ind]]['plane'], 0, model.selection(), 0, "Faces|Wires")
413                 else :
414                     # le plan cible n'existe pas
415                     edge = model.addAxis(part, self.infoPoints[connectivityInfos['starts'][ind]]['point'], self.infoPoints[connectivityInfos['ends'][ind]]['point'])
416                     edge.execute(True)
417                     self.lfeatures.append(edge)# self.retrieveFirstElement(connectivityInfos['paths'][ind], GeomAPI_Shape.EDGE)
418                     self.ledges.append(edge)
419                     point = self.retrieveLastElement(connectivityInfos['paths'][ind], GeomAPI_Shape.VERTEX)
420                     plane = model.addPlane(part, edge.result(), point, True)
421                     plane.execute(True)
422                     self.lfeatures.append(plane)
423                     pipe = model.addExtrusion(part, [startFace], edge.result(), plane.result(), 0, model.selection(), 0, "Faces|Wires")
424             pipe.execute(True)
425             self.lfeatures.append(pipe)
426             lPipes.append(pipe.result())
427             if ( ind < len(connectivityInfos['paths'])-1 ):
428                 copy = model.addCopy(part, [model.selection(pipe.defaultResult())], 1)
429                 copy.execute(True)
430                 self.lfeatures.append(copy)
431                 startFace = self.retrieveLastElement(copy, GeomAPI_Shape.FACE)
432
433         if len(lPipes) > 1 :
434             fuse = model.addFuse(part, lPipes, False)
435             fuse.execute(True)
436             self.lfeatures.append(fuse)
437         else :
438             return pipe
439         return fuse
440
441 #==========================================================
442
443 #==========================================================
444 # Création des différents éléments
445     def createPoints(self, part):
446         """Création des points
447
448 Le point est créé en tant qu'objet de construction avec ses coordonnées.
449 Il est nommé conformément au texte donné dans le fichier de données. Cela n'a qu'un intérêt graphique mais agréable en débogage.
450 """
451         print("========================= Création des noeuds ============================")
452         for key, value in self.infoPoints.items():
453             printverbose ("Noeud : '{}'".format(key), verbose=self._verbose)
454             point = model.addPoint(part, value['X'], value['Y'], value['Z'])
455             point.execute(True)
456             point.setName(key)
457             point.result().setName(key)
458             self.lfeatures.append(point)
459             value["point"] = point.result()
460
461     def createPolylines(self, part):
462         """Création des polylines
463
464 La polyligne est créée en tant que résultat en enchaînant ses points.
465 Elle est nommée conformément aux 1er et dernier noeud. Cela n'a qu'un intérêt graphique mais agréable en débogage.
466 """
467         print("========================= Création des polylines =========================")
468         for key, value in self.connectivities.items():
469             printverbose ("Ligne : {}".format(value['chainage']), verbose=self._verbose)
470             lPoints = list()
471             for id_noeud in value['chainage']:
472                 lPoints.append(self.infoPoints[id_noeud]["point"])
473                 id_noeud_fin = id_noeud
474             polyline = model.addPolyline3D(part, lPoints, False)
475             polyline.execute(True)
476             nom = "L_{}_{}".format(key,id_noeud_fin)
477             polyline.setName(nom)
478             polyline.result().setName(nom)
479             self.lfeatures.append(polyline)
480             value["polyline"] = polyline
481
482     def createFillets(self, part):
483         """Création des fillets
484
485 Le fillet est créé en tant que résultat.
486 Il est nommé conformément au noeud d'application. Cela n'a qu'un intérêt graphique mais agréable en débogage.
487 """
488         print("========================= Création des fillets ===========================")
489         for key, value in self.connectivities.items():
490             printverbose ("Examen de la ligne démarrant sur le noeud '{}'".format(key), verbose=self._verbose)
491             # recherche des noeuds fillets
492             value["fillet"] = value["polyline"]
493             for id_noeud in value['chainage']:
494                 if self.infoPoints[id_noeud]["Fillet"] == "radius" :
495                     printverbose ("\tFillet sur le noeud '{}'".format(id_noeud), verbose=self._verbose)
496                     fillet1D = model.addFillet(part, [model.selection("VERTEX", (self.infoPoints[id_noeud]["X"],self.infoPoints[id_noeud]["Y"],self.infoPoints[id_noeud]["Z"]))], self.infoPoints[id_noeud]["Radius"])
497                     fillet1D.execute(True)
498                     nom = "F_{}".format(id_noeud)
499                     fillet1D.setName(nom)
500                     fillet1D.result().setName(nom)
501                     self.lfeatures.append(fillet1D)
502                     value["fillet"] = fillet1D
503
504 #==========================================================
505
506     def searchRightConnections(self, part):
507         """Recherche des coudes droits"""
508         print("========================= Recherche des coudes droits ====================")
509         for key, value in self.connectivities.items():
510             printverbose ("Examen de la ligne démarrant sur le noeud '{}'".format(key), verbose=self._verbose)
511             # recherche des noeuds fillets
512             for ind, id_noeud in enumerate(value['chainage']):
513                 printverbose ("\tNoeud '{}' : {}".format(id_noeud,self.infoPoints[id_noeud]["Fillet"]), verbose=self._verbose)
514                 if ( ( ind == 0 ) or ( ind == len(value['chainage'])-1 ) ):
515                     self.infoPoints[id_noeud]["isAngular"] = False
516                 else :
517                     if self.infoPoints[id_noeud]["Fillet"] == "radius" :
518                         self.infoPoints[id_noeud]["isAngular"] = False
519                     else :
520                         if id_noeud in self.connectivities:
521                             self.infoPoints[id_noeud]["isAngular"] = False
522                         else :
523                             self.infoPoints[id_noeud]["isAngular"] = True
524                             # Axe d'extrusion
525                             #print(ind-1, ind, ind+1)
526                             printverbose ("\t\tCréation du plan passant par les points : ('{}','{}','{}')".format(value["chainage"][ind-1], id_noeud, value["chainage"][ind+1]), verbose=self._verbose)
527                             #print(self.infoPoints[value["chainage"][ind-1]]["point"])
528
529                             tmpPlane = model.addPlane(part, self.infoPoints[value["chainage"][ind-1]]["point"], self.infoPoints[id_noeud]["point"], self.infoPoints[value["chainage"][ind+1]]["point"])
530                             tmpPlane.execute(True)
531                             self.lfeatures.append(tmpPlane)
532                             axis =  model.addAxis(part, tmpPlane.result(), self.infoPoints[id_noeud]["point"])
533                             axis.execute(True)
534                             self.lfeatures.append(axis)
535                             self.infoPoints[id_noeud]["axis"] = axis.result()
536
537                             # Edge à extruder
538                             tmpEdge = model.addEdge(part, self.infoPoints[id_noeud]["point"], self.infoPoints[value["chainage"][ind+1]]["point"])
539                             tmpEdge.execute(True)
540                             self.lfeatures.append(tmpEdge)
541                             length = model.measureDistance(part, self.infoPoints[value["chainage"][ind-1]]["point"], self.infoPoints[id_noeud]["point"])
542                             point =  model.addPoint(part, tmpEdge.result(), length, False, False)
543                             point.execute(True)
544                             self.lfeatures.append(point)
545                             baseEdge = model.addEdge(part, self.infoPoints[value["chainage"][ind-1]]["point"], point.result())
546                             baseEdge.execute(True)
547                             self.lfeatures.append(baseEdge)
548                             middlePoint = model.addPoint(part, baseEdge.result(), 0.5, True, False)
549                             middlePoint.execute(True)
550                             self.lfeatures.append(middlePoint)
551                             Edge = model.addEdge(part, self.infoPoints[id_noeud]["point"], middlePoint.result())
552                             Edge.execute(True)
553                             self.lfeatures.append(Edge)
554                             self.ledges.append(Edge)
555
556                             # Extrusion
557                             plane = model.addExtrusion(part, [Edge.result()], axis.result(), 10, 0)
558                             plane.execute(True)
559                             self.lfeatures.append(plane)
560                             self.infoPoints[id_noeud]["plane"] = plane.result()
561
562     def createPaths(self, part):
563         """Création des paths pour le pipeNetwork"""
564         print("========================= Création des paths =============================")
565         for key, value in self.connectivities.items():
566             printverbose ("Ligne démarrant sur le noeud '{}'".format(key), verbose=self._verbose)
567             # recherche des noeuds fillets
568             value["paths"] = list()
569             value["isPipe"] = list()
570             value["starts"] = list()
571             value["ends"] = list()
572             ind = 0
573             copy = value['fillet']
574             while ind < len(value['chainage'])-1:
575                 value["starts"].append(self.connectivities[key]['chainage'][ind])
576                 objectsForPath, ind, isPipe, end_noeud = self.retrieveSubshapesforWire(copy, key, ind)
577                 if self._verbose_max:
578                     print("************************* ind = {}".format(ind))
579                     print("************************* objectsForPath = {}".format(objectsForPath))
580                 path = model.addWire(part, objectsForPath, False)
581                 path.execute(True)
582                 self.lfeatures.append(path)
583                 value["paths"].append(path)
584                 value["isPipe"].append(isPipe)
585                 value["ends"].append(end_noeud)
586                 if ind < len(value['chainage'])-1:
587                     copy = model.addCopy(part, [model.selection(copy.defaultResult())], 1)
588                     copy.execute(True)
589                     self.lfeatures.append(copy)
590
591     def createSketches(self, part):
592         """Création des sketchs"""
593         print("========================= Création des sketchs =========================")
594         for key, value in self.connectivities.items():
595             printverbose ("Ligne démarrant sur le noeud '{}'".format(key), verbose=self._verbose)
596             # Creating sketch
597             edge = model.addEdge(part, self.infoPoints[value["chainage"][0]]["point"], self.infoPoints[value["chainage"][1]]["point"])
598             edge.execute(True)
599             self.lfeatures.append(edge)
600             plane = model.addPlane(part, edge.result(), self.infoPoints[value["chainage"][0]]["point"], True)
601             plane.execute(True)
602             self.lfeatures.append(plane)
603             sketch = model.addSketch(part, plane.result())
604             sketch.execute(True)
605             self.lfeatures.append(sketch)
606             SketchProjection = sketch.addProjection(self.infoPoints[value["chainage"][0]]["point"], False)
607             SketchProjection.execute(True)
608             SketchPoint = SketchProjection.createdFeature()
609             SketchPoint.execute(True)
610             SketchCircle = sketch.addCircle(0,0,self.radius)
611             SketchCircle.execute(True)
612             sketch.setCoincident(SketchPoint.result(), SketchCircle.center())
613             sketch.setRadius(SketchCircle.results()[1], self.radius)
614             sketch.execute(True)
615             model.do()
616             value["sketch"] = sketch.result()
617
618     def createPipes(self, part, nameRes):
619         """Création des pipes"""
620         print("========================= Création des pipes =========================")
621         for key, value in self.connectivities.items():
622             printverbose ("Ligne démarrant sur le noeud '{}'".format(key), verbose=self._verbose)
623             pipe = self.createPipe(part, value)
624             value["pipe"] = pipe.result()
625
626         # Fusion des pipes
627         print("========================= Fusion des pipes =========================")
628         lPipes = list()
629         for key, value in self.connectivities.items():
630             lPipes.append(value["pipe"])
631         if len(lPipes) > 1 :
632             fuse = model.addFuse(part, lPipes, False)
633             fuse.execute(True)
634             fuse.setName(nameRes)
635             fuse.result().setName(nameRes)
636         else:
637             lPipes[0].setName(nameRes)
638
639 #==========================================================
640
641     def print_info (self, verbose, comment=""):
642         """Impression si verbose est valide. Avec un comentaire introductif éventuellement."""
643         if verbose:
644             texte = "\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
645             texte += "\nRécapitulatif"
646             if comment:
647                 texte += " {}".format(comment)
648             texte += "\ninfos points ="
649             for key, value in self.infoPoints.items():
650                 texte += "\n{} : {}".format(key, value)
651             texte += "\nconnectivities ="
652             for key, value in self.connectivities.items():
653                 texte += "\n{} : {}".format(key, value)
654             texte += "\n+++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++"
655             print(texte+"\n")
656
657 #==========================================================
658
659 # Execution of the Import
660
661     def execute(self):
662         """F.execute() -- execute the Feature"""
663         # Retrieving the user input
664         apath    = self.string(self.FILE_ID())
665
666         filepath = apath.value()
667         if filepath != "" :
668
669             # A. Initialisation
670             part = model.activeDocument()
671
672             if self.lfeatures :
673                 for feature in self.lfeatures:
674                     part.removeFeature(feature.feature())
675                 self.lfeatures = list()
676                 model.removeFolder(self.folder)
677
678             self.infoPoints = dict()
679             self.connectivities = dict()
680
681             from os.path import basename
682             filename = basename(filepath)
683             if ( "." in filename ):
684                 laux= filename.split(".")
685                 nameRes = laux[0]
686                 for saux in laux[1:-1]:
687                     nameRes+="."+saux
688             else:
689                 nameRes = filename
690
691             # Creating the construction points in the current document
692
693             # B. Traitement du fichier
694             print ("\n=============== Traitement du fichier {}".format(filepath))
695             error = 0
696             while True:
697
698                 # B.1. Lecture du fichier
699                 with open(filepath, encoding='utf-8') as afile:
700                     summary = 0
701                     method = self.parligne
702                     for line in afile:
703                         printverbose  (line[:-1], verbose=self._verbose_max)
704
705                         # B.1.1. Repérages
706                         if line == "\n":
707                             printverbose ("========================= Saut de ligne =========================", verbose=self._verbose_max)
708                             continue
709                         if line[0] == "#" or line[:3] == "...":
710                             continue
711                         if summary == 0 and line[:-1] == "nodes section" :
712                             printverbose ("========================= Lecture des coordonnées ==============================", 80, verbose=self._verbose)
713                             summary = 1
714                             continue
715                         if summary == 1 and line[:-1] == "connectivity section" :
716                             printverbose ("========================= Lecture de la connectivité ===========================", 80, verbose=self._verbose)
717                             summary = 2
718                             continue
719                         if summary == 2 and line[:6] == "method" :
720                             printverbose ("===================== summary == 2 method =========================", verbose=self._verbose_max)
721                             method = line[7:-1]
722                             printverbose ("Méthode : '{}'".format(method), verbose=self._verbose)
723                             if method not in (self.twopartwo, self.parligne):
724                                 raiseException("Problem with type of connectivity")
725                             continue
726                         if summary == 2 and line[:-1] == "fillets section" :
727                             printverbose ("========================= Lecture des fillets =========================", 80, verbose=self._verbose)
728                             summary = 3
729                             continue
730
731                         # B.1.2. Enregistrement des données
732                         if summary == 1:
733                             printverbose ("===================== summary == 1 =========================", 80, verbose=self._verbose_max)
734                             diagno, texte = self.readNodeInfo(line[:-1])
735                             if diagno:
736                                 raiseException("{}\nProblem with description of nodes.".format(texte))
737                             continue
738                         if summary == 2:
739                             printverbose ("===================== summary == 2 =========================", 80, verbose=self._verbose_max)
740                             diagno = self.readConnectivity(line[:-1],method)
741                             if diagno:
742                                 raiseException("Problem with description of connectivities")
743                             continue
744                         if summary == 3:
745                             printverbose ("===================== summary == 3 =========================", 80, verbose=self._verbose_max)
746                             diagno = self.readFillet(line[:-1])
747                             if diagno:
748                                 raiseException("Problem with description of fillets")
749                             continue
750
751                         printverbose ("===================== Rien =========================", 80, verbose=self._verbose_max)
752                         if diagno:
753                             error = diagno
754                             break
755
756                 if error:
757                     break
758
759
760                 # B.2. Gestion des points alignés
761                 self.print_info (self._verbose_max, "avant gestion des points alignés")
762
763                 self.correctConnectivity ()
764
765                 # B.3. Signalement de la fin d'une chaine
766                 for _, value in self.connectivities.items():
767                     self.infoPoints[value['chainage'][-1]]["isEnd"] = True
768
769                 self.print_info (self._verbose_max, "avant les création de points, etc.")
770
771                 # B.4. Creation des points
772                 self.createPoints(part)
773
774                 # B.5. Creation des polylines
775                 self.createPolylines(part)
776
777                 # B.6. Creation des fillets
778                 self.createFillets(part)
779
780                 # B.7. Recherche des coudes droits
781                 self.searchRightConnections(part)
782
783                 # B.8. Création des paths pour le pipeNetwork
784                 self.createPaths(part)
785
786                 # B.9. Création des sketchs pour le pipeNetwork
787                 self.createSketches(part)
788
789                 self.print_info (self._verbose_max, "après la création des sketchs")
790
791                 # B.10. Création des pipes
792                 self.createPipes(part, nameRes)
793
794                 # B.11. Dossier pour les opérations internes
795                 print("========================= Mise en dossier =========================")
796                 self.folder = model.addFolder(part, self.lfeatures[0], self.lfeatures[-1])
797                 self.folder.setName("{}_inter".format(nameRes))
798
799                 # B.12. Ménage des résultats inutiles
800                 print("========================= Ménage des résultats inutiles ==================")
801                 laux = list()
802                 for iaux in range(len(self.ledges)):
803                     laux.append(model.selection("EDGE", "Edge_{}_1".format(iaux)))
804                 _ = model.addRemoveResults(part, laux)
805
806                 break
807
808             return
809
810     def isMacro(self):
811         """Override Feature.initAttributes().
812         F.isMacro() -> True
813
814         pipeNetwork feature is macro: removes itself on the creation transaction
815         finish.
816         """
817         return False