Salome HOME
PAL20544 4x: problems with Concatenate().
[modules/smesh.git] / src / SMESH_SWIG / smeshDC.py
1 #  Copyright (C) 2005  OPEN CASCADE, EADS/CCR, LIP6, CEA/DEN,
2 #  CEDRAT, EDF R&D, LEG, PRINCIPIA R&D, BUREAU VERITAS
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.
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 #  File   : smesh.py
21 #  Author : Francis KLOSS, OCC
22 #  Module : SMESH
23
24 """
25  \namespace smesh
26  \brief Module smesh
27 """
28
29 ## @defgroup l1_auxiliary Auxiliary methods and structures
30 ## @defgroup l1_creating  Creating meshes
31 ## @{
32 ##   @defgroup l2_impexp     Importing and exporting meshes
33 ##   @defgroup l2_construct  Constructing meshes
34 ##   @defgroup l2_algorithms Defining Algorithms
35 ##   @{
36 ##     @defgroup l3_algos_basic   Basic meshing algorithms
37 ##     @defgroup l3_algos_proj    Projection Algorithms
38 ##     @defgroup l3_algos_radialp Radial Prism
39 ##     @defgroup l3_algos_segmarv Segments around Vertex
40 ##     @defgroup l3_algos_3dextr  3D extrusion meshing algorithm
41
42 ##   @}
43 ##   @defgroup l2_hypotheses Defining hypotheses
44 ##   @{
45 ##     @defgroup l3_hypos_1dhyps 1D Meshing Hypotheses
46 ##     @defgroup l3_hypos_2dhyps 2D Meshing Hypotheses
47 ##     @defgroup l3_hypos_maxvol Max Element Volume hypothesis
48 ##     @defgroup l3_hypos_netgen Netgen 2D and 3D hypotheses
49 ##     @defgroup l3_hypos_ghs3dh GHS3D Parameters hypothesis
50 ##     @defgroup l3_hypos_blsurf BLSURF Parameters hypothesis
51 ##     @defgroup l3_hypos_hexotic Hexotic Parameters hypothesis
52 ##     @defgroup l3_hypos_additi Additional Hypotheses
53
54 ##   @}
55 ##   @defgroup l2_submeshes Constructing submeshes
56 ##   @defgroup l2_compounds Building Compounds
57 ##   @defgroup l2_editing   Editing Meshes
58
59 ## @}
60 ## @defgroup l1_meshinfo  Mesh Information
61 ## @defgroup l1_controls  Quality controls and Filtering
62 ## @defgroup l1_grouping  Grouping elements
63 ## @{
64 ##   @defgroup l2_grps_create Creating groups
65 ##   @defgroup l2_grps_edit   Editing groups
66 ##   @defgroup l2_grps_operon Using operations on groups
67 ##   @defgroup l2_grps_delete Deleting Groups
68
69 ## @}
70 ## @defgroup l1_modifying Modifying meshes
71 ## @{
72 ##   @defgroup l2_modif_add      Adding nodes and elements
73 ##   @defgroup l2_modif_del      Removing nodes and elements
74 ##   @defgroup l2_modif_edit     Modifying nodes and elements
75 ##   @defgroup l2_modif_renumber Renumbering nodes and elements
76 ##   @defgroup l2_modif_trsf     Transforming meshes (Translation, Rotation, Symmetry, Sewing, Merging)
77 ##   @defgroup l2_modif_movenode Moving nodes
78 ##   @defgroup l2_modif_throughp Mesh through point
79 ##   @defgroup l2_modif_invdiag  Diagonal inversion of elements
80 ##   @defgroup l2_modif_unitetri Uniting triangles
81 ##   @defgroup l2_modif_changori Changing orientation of elements
82 ##   @defgroup l2_modif_cutquadr Cutting quadrangles
83 ##   @defgroup l2_modif_smooth   Smoothing
84 ##   @defgroup l2_modif_extrurev Extrusion and Revolution
85 ##   @defgroup l2_modif_patterns Pattern mapping
86 ##   @defgroup l2_modif_tofromqu Convert to/from Quadratic Mesh
87
88 ## @}
89
90 import salome
91 import geompyDC
92
93 import SMESH # This is necessary for back compatibility
94 from   SMESH import *
95
96 import StdMeshers
97
98 import SALOME
99
100 # import NETGENPlugin module if possible
101 noNETGENPlugin = 0
102 try:
103     import NETGENPlugin
104 except ImportError:
105     noNETGENPlugin = 1
106     pass
107
108 ## @addtogroup l1_auxiliary
109 ## @{
110
111 # Types of algorithms
112 REGULAR    = 1
113 PYTHON     = 2
114 COMPOSITE  = 3
115 SOLE       = 0
116 SIMPLE     = 1
117
118 MEFISTO       = 3
119 NETGEN        = 4
120 GHS3D         = 5
121 FULL_NETGEN   = 6
122 NETGEN_2D     = 7
123 NETGEN_1D2D   = NETGEN
124 NETGEN_1D2D3D = FULL_NETGEN
125 NETGEN_FULL   = FULL_NETGEN
126 Hexa    = 8
127 Hexotic = 9
128 BLSURF  = 10
129
130 # MirrorType enumeration
131 POINT = SMESH_MeshEditor.POINT
132 AXIS =  SMESH_MeshEditor.AXIS
133 PLANE = SMESH_MeshEditor.PLANE
134
135 # Smooth_Method enumeration
136 LAPLACIAN_SMOOTH = SMESH_MeshEditor.LAPLACIAN_SMOOTH
137 CENTROIDAL_SMOOTH = SMESH_MeshEditor.CENTROIDAL_SMOOTH
138
139 # Fineness enumeration (for NETGEN)
140 VeryCoarse = 0
141 Coarse     = 1
142 Moderate   = 2
143 Fine       = 3
144 VeryFine   = 4
145 Custom     = 5
146
147 # Optimization level of GHS3D
148 None_Optimization, Light_Optimization, Medium_Optimization, Strong_Optimization = 0,1,2,3
149
150 # Topology treatment way of BLSURF
151 FromCAD, PreProcess, PreProcessPlus = 0,1,2
152
153 # Element size flag of BLSURF
154 DefaultSize, DefaultGeom, Custom = 0,0,1
155
156 PrecisionConfusion = 1e-07
157
158 def IsEqual(val1, val2, tol=PrecisionConfusion):
159     if abs(val1 - val2) < tol:
160         return True
161     return False
162
163 NO_NAME = "NoName"
164
165 ## Gets object name
166 def GetName(obj):
167     ior  = salome.orb.object_to_string(obj)
168     sobj = salome.myStudy.FindObjectIOR(ior)
169     if sobj is None:
170         return NO_NAME
171     else:
172         attr = sobj.FindAttribute("AttributeName")[1]
173         return attr.Value()
174
175 ## Sets a name to the object
176 def SetName(obj, name):
177     if isinstance( obj, Mesh ):
178         obj = obj.GetMesh()
179     elif isinstance( obj, Mesh_Algorithm ):
180         obj = obj.GetAlgorithm()
181     ior  = salome.orb.object_to_string(obj)
182     sobj = salome.myStudy.FindObjectIOR(ior)
183     if not sobj is None:
184         attr = sobj.FindAttribute("AttributeName")[1]
185         attr.SetValue(name)
186
187 ## Prints error message if a hypothesis was not assigned.
188 def TreatHypoStatus(status, hypName, geomName, isAlgo):
189     if isAlgo:
190         hypType = "algorithm"
191     else:
192         hypType = "hypothesis"
193         pass
194     if status == HYP_UNKNOWN_FATAL :
195         reason = "for unknown reason"
196     elif status == HYP_INCOMPATIBLE :
197         reason = "this hypothesis mismatches the algorithm"
198     elif status == HYP_NOTCONFORM :
199         reason = "a non-conform mesh would be built"
200     elif status == HYP_ALREADY_EXIST :
201         reason = hypType + " of the same dimension is already assigned to this shape"
202     elif status == HYP_BAD_DIM :
203         reason = hypType + " mismatches the shape"
204     elif status == HYP_CONCURENT :
205         reason = "there are concurrent hypotheses on sub-shapes"
206     elif status == HYP_BAD_SUBSHAPE :
207         reason = "the shape is neither the main one, nor its subshape, nor a valid group"
208     elif status == HYP_BAD_GEOMETRY:
209         reason = "geometry mismatches the expectation of the algorithm"
210     elif status == HYP_HIDDEN_ALGO:
211         reason = "it is hidden by an algorithm of an upper dimension, which generates elements of all dimensions"
212     elif status == HYP_HIDING_ALGO:
213         reason = "it hides algorithms of lower dimensions by generating elements of all dimensions"
214     elif status == HYP_NEED_SHAPE:
215         reason = "Algorithm can't work without shape"
216     else:
217         return
218     hypName = '"' + hypName + '"'
219     geomName= '"' + geomName+ '"'
220     if status < HYP_UNKNOWN_FATAL:
221         print hypName, "was assigned to",    geomName,"but", reason
222     else:
223         print hypName, "was not assigned to",geomName,":", reason
224         pass
225
226 ## Converts an angle from degrees to radians
227 def DegreesToRadians(AngleInDegrees):
228     from math import pi
229     return AngleInDegrees * pi / 180.0
230
231 # end of l1_auxiliary
232 ## @}
233
234 # All methods of this class are accessible directly from the smesh.py package.
235 class smeshDC(SMESH._objref_SMESH_Gen):
236
237     ## Sets the current study and Geometry component
238     #  @ingroup l1_auxiliary
239     def init_smesh(self,theStudy,geompyD):
240         self.SetCurrentStudy(theStudy,geompyD)
241
242     ## Creates an empty Mesh. This mesh can have an underlying geometry.
243     #  @param obj the Geometrical object on which the mesh is built. If not defined,
244     #             the mesh will have no underlying geometry.
245     #  @param name the name for the new mesh.
246     #  @return an instance of Mesh class.
247     #  @ingroup l2_construct
248     def Mesh(self, obj=0, name=0):
249       return Mesh(self,self.geompyD,obj,name)
250
251     ## Returns a long value from enumeration
252     #  Should be used for SMESH.FunctorType enumeration
253     #  @ingroup l1_controls
254     def EnumToLong(self,theItem):
255         return theItem._v
256
257     ## Gets PointStruct from vertex
258     #  @param theVertex a GEOM object(vertex)
259     #  @return SMESH.PointStruct
260     #  @ingroup l1_auxiliary
261     def GetPointStruct(self,theVertex):
262         [x, y, z] = self.geompyD.PointCoordinates(theVertex)
263         return PointStruct(x,y,z)
264
265     ## Gets DirStruct from vector
266     #  @param theVector a GEOM object(vector)
267     #  @return SMESH.DirStruct
268     #  @ingroup l1_auxiliary
269     def GetDirStruct(self,theVector):
270         vertices = self.geompyD.SubShapeAll( theVector, geompyDC.ShapeType["VERTEX"] )
271         if(len(vertices) != 2):
272             print "Error: vector object is incorrect."
273             return None
274         p1 = self.geompyD.PointCoordinates(vertices[0])
275         p2 = self.geompyD.PointCoordinates(vertices[1])
276         pnt = PointStruct(p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
277         dirst = DirStruct(pnt)
278         return dirst
279
280     ## Makes DirStruct from a triplet
281     #  @param x,y,z vector components
282     #  @return SMESH.DirStruct
283     #  @ingroup l1_auxiliary
284     def MakeDirStruct(self,x,y,z):
285         pnt = PointStruct(x,y,z)
286         return DirStruct(pnt)
287
288     ## Get AxisStruct from object
289     #  @param theObj a GEOM object (line or plane)
290     #  @return SMESH.AxisStruct
291     #  @ingroup l1_auxiliary
292     def GetAxisStruct(self,theObj):
293         edges = self.geompyD.SubShapeAll( theObj, geompyDC.ShapeType["EDGE"] )
294         if len(edges) > 1:
295             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geompyDC.ShapeType["VERTEX"] )
296             vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geompyDC.ShapeType["VERTEX"] )
297             vertex1 = self.geompyD.PointCoordinates(vertex1)
298             vertex2 = self.geompyD.PointCoordinates(vertex2)
299             vertex3 = self.geompyD.PointCoordinates(vertex3)
300             vertex4 = self.geompyD.PointCoordinates(vertex4)
301             v1 = [vertex2[0]-vertex1[0], vertex2[1]-vertex1[1], vertex2[2]-vertex1[2]]
302             v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]]
303             normal = [ v1[1]*v2[2]-v2[1]*v1[2], v1[2]*v2[0]-v2[2]*v1[0], v1[0]*v2[1]-v2[0]*v1[1] ]
304             axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2])
305             return axis
306         elif len(edges) == 1:
307             vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geompyDC.ShapeType["VERTEX"] )
308             p1 = self.geompyD.PointCoordinates( vertex1 )
309             p2 = self.geompyD.PointCoordinates( vertex2 )
310             axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2])
311             return axis
312         return None
313
314     # From SMESH_Gen interface:
315     # ------------------------
316
317     ## Sets the current mode
318     #  @ingroup l1_auxiliary
319     def SetEmbeddedMode( self,theMode ):
320         #self.SetEmbeddedMode(theMode)
321         SMESH._objref_SMESH_Gen.SetEmbeddedMode(self,theMode)
322
323     ## Gets the current mode
324     #  @ingroup l1_auxiliary
325     def IsEmbeddedMode(self):
326         #return self.IsEmbeddedMode()
327         return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self)
328
329     ## Sets the current study
330     #  @ingroup l1_auxiliary
331     def SetCurrentStudy( self, theStudy, geompyD = None ):
332         #self.SetCurrentStudy(theStudy)
333         if not geompyD:
334             import geompy
335             geompyD = geompy.geom
336             pass
337         self.geompyD=geompyD
338         self.SetGeomEngine(geompyD)
339         SMESH._objref_SMESH_Gen.SetCurrentStudy(self,theStudy)
340
341     ## Gets the current study
342     #  @ingroup l1_auxiliary
343     def GetCurrentStudy(self):
344         #return self.GetCurrentStudy()
345         return SMESH._objref_SMESH_Gen.GetCurrentStudy(self)
346
347     ## Creates a Mesh object importing data from the given UNV file
348     #  @return an instance of Mesh class
349     #  @ingroup l2_impexp
350     def CreateMeshesFromUNV( self,theFileName ):
351         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromUNV(self,theFileName)
352         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
353         return aMesh
354
355     ## Creates a Mesh object(s) importing data from the given MED file
356     #  @return a list of Mesh class instances
357     #  @ingroup l2_impexp
358     def CreateMeshesFromMED( self,theFileName ):
359         aSmeshMeshes, aStatus = SMESH._objref_SMESH_Gen.CreateMeshesFromMED(self,theFileName)
360         aMeshes = []
361         for iMesh in range(len(aSmeshMeshes)) :
362             aMesh = Mesh(self, self.geompyD, aSmeshMeshes[iMesh])
363             aMeshes.append(aMesh)
364         return aMeshes, aStatus
365
366     ## Creates a Mesh object importing data from the given STL file
367     #  @return an instance of Mesh class
368     #  @ingroup l2_impexp
369     def CreateMeshesFromSTL( self, theFileName ):
370         aSmeshMesh = SMESH._objref_SMESH_Gen.CreateMeshesFromSTL(self,theFileName)
371         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
372         return aMesh
373
374     ## Concatenate the given meshes into one mesh.
375     #  @return an instance of Mesh class
376     #  @param meshes the meshes to combine into one mesh
377     #  @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed
378     #  @param mergeNodesAndElements if true, equal nodes and elements aremerged
379     #  @param mergeTolerance tolerance for merging nodes
380     #  @param allGroups forces creation of groups of all elements
381     def Concatenate( self, meshes, uniteIdenticalGroups,
382                      mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False):
383         if allGroups:
384             aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups(
385                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
386         else:
387             aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
388                 self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
389         aMesh = Mesh(self, self.geompyD, aSmeshMesh)
390         return aMesh
391
392     ## From SMESH_Gen interface
393     #  @return the list of integer values
394     #  @ingroup l1_auxiliary
395     def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
396         return SMESH._objref_SMESH_Gen.GetSubShapesId(self,theMainObject, theListOfSubObjects)
397
398     ## From SMESH_Gen interface. Creates a pattern
399     #  @return an instance of SMESH_Pattern
400     #
401     #  <a href="../tui_modifying_meshes_page.html#tui_pattern_mapping">Example of Patterns usage</a>
402     #  @ingroup l2_modif_patterns
403     def GetPattern(self):
404         return SMESH._objref_SMESH_Gen.GetPattern(self)
405
406
407     # Filtering. Auxiliary functions:
408     # ------------------------------
409
410     ## Creates an empty criterion
411     #  @return SMESH.Filter.Criterion
412     #  @ingroup l1_controls
413     def GetEmptyCriterion(self):
414         Type = self.EnumToLong(FT_Undefined)
415         Compare = self.EnumToLong(FT_Undefined)
416         Threshold = 0
417         ThresholdStr = ""
418         ThresholdID = ""
419         UnaryOp = self.EnumToLong(FT_Undefined)
420         BinaryOp = self.EnumToLong(FT_Undefined)
421         Tolerance = 1e-07
422         TypeOfElement = ALL
423         Precision = -1 ##@1e-07
424         return Filter.Criterion(Type, Compare, Threshold, ThresholdStr, ThresholdID,
425                                 UnaryOp, BinaryOp, Tolerance, TypeOfElement, Precision)
426
427     ## Creates a criterion by the given parameters
428     #  @param elementType the type of elements(NODE, EDGE, FACE, VOLUME)
429     #  @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.)
430     #  @param Compare  belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
431     #  @param Treshold the threshold value (range of ids as string, shape, numeric)
432     #  @param UnaryOp  FT_LogicalNOT or FT_Undefined
433     #  @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or
434     #                  FT_Undefined (must be for the last criterion of all criteria)
435     #  @return SMESH.Filter.Criterion
436     #  @ingroup l1_controls
437     def GetCriterion(self,elementType,
438                      CritType,
439                      Compare = FT_EqualTo,
440                      Treshold="",
441                      UnaryOp=FT_Undefined,
442                      BinaryOp=FT_Undefined):
443         aCriterion = self.GetEmptyCriterion()
444         aCriterion.TypeOfElement = elementType
445         aCriterion.Type = self.EnumToLong(CritType)
446
447         aTreshold = Treshold
448
449         if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
450             aCriterion.Compare = self.EnumToLong(Compare)
451         elif Compare == "=" or Compare == "==":
452             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
453         elif Compare == "<":
454             aCriterion.Compare = self.EnumToLong(FT_LessThan)
455         elif Compare == ">":
456             aCriterion.Compare = self.EnumToLong(FT_MoreThan)
457         else:
458             aCriterion.Compare = self.EnumToLong(FT_EqualTo)
459             aTreshold = Compare
460
461         if CritType in [FT_BelongToGeom,     FT_BelongToPlane, FT_BelongToGenSurface,
462                         FT_BelongToCylinder, FT_LyingOnGeom]:
463             # Checks the treshold
464             if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object):
465                 aCriterion.ThresholdStr = GetName(aTreshold)
466                 aCriterion.ThresholdID = salome.ObjectToID(aTreshold)
467             else:
468                 print "Error: The treshold should be a shape."
469                 return None
470         elif CritType == FT_RangeOfIds:
471             # Checks the treshold
472             if isinstance(aTreshold, str):
473                 aCriterion.ThresholdStr = aTreshold
474             else:
475                 print "Error: The treshold should be a string."
476                 return None
477         elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume]:
478             # At this point the treshold is unnecessary
479             if aTreshold ==  FT_LogicalNOT:
480                 aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
481             elif aTreshold in [FT_LogicalAND, FT_LogicalOR]:
482                 aCriterion.BinaryOp = aTreshold
483         else:
484             # Check treshold
485             try:
486                 aTreshold = float(aTreshold)
487                 aCriterion.Threshold = aTreshold
488             except:
489                 print "Error: The treshold should be a number."
490                 return None
491
492         if Treshold ==  FT_LogicalNOT or UnaryOp ==  FT_LogicalNOT:
493             aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
494
495         if Treshold in [FT_LogicalAND, FT_LogicalOR]:
496             aCriterion.BinaryOp = self.EnumToLong(Treshold)
497
498         if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
499             aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
500
501         if BinaryOp in [FT_LogicalAND, FT_LogicalOR]:
502             aCriterion.BinaryOp = self.EnumToLong(BinaryOp)
503
504         return aCriterion
505
506     ## Creates a filter with the given parameters
507     #  @param elementType the type of elements in the group
508     #  @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
509     #  @param Compare  belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
510     #  @param Treshold the threshold value (range of id ids as string, shape, numeric)
511     #  @param UnaryOp  FT_LogicalNOT or FT_Undefined
512     #  @return SMESH_Filter
513     #  @ingroup l1_controls
514     def GetFilter(self,elementType,
515                   CritType=FT_Undefined,
516                   Compare=FT_EqualTo,
517                   Treshold="",
518                   UnaryOp=FT_Undefined):
519         aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
520         aFilterMgr = self.CreateFilterManager()
521         aFilter = aFilterMgr.CreateFilter()
522         aCriteria = []
523         aCriteria.append(aCriterion)
524         aFilter.SetCriteria(aCriteria)
525         return aFilter
526
527     ## Creates a numerical functor by its type
528     #  @param theCriterion FT_...; functor type
529     #  @return SMESH_NumericalFunctor
530     #  @ingroup l1_controls
531     def GetFunctor(self,theCriterion):
532         aFilterMgr = self.CreateFilterManager()
533         if theCriterion == FT_AspectRatio:
534             return aFilterMgr.CreateAspectRatio()
535         elif theCriterion == FT_AspectRatio3D:
536             return aFilterMgr.CreateAspectRatio3D()
537         elif theCriterion == FT_Warping:
538             return aFilterMgr.CreateWarping()
539         elif theCriterion == FT_MinimumAngle:
540             return aFilterMgr.CreateMinimumAngle()
541         elif theCriterion == FT_Taper:
542             return aFilterMgr.CreateTaper()
543         elif theCriterion == FT_Skew:
544             return aFilterMgr.CreateSkew()
545         elif theCriterion == FT_Area:
546             return aFilterMgr.CreateArea()
547         elif theCriterion == FT_Volume3D:
548             return aFilterMgr.CreateVolume3D()
549         elif theCriterion == FT_MultiConnection:
550             return aFilterMgr.CreateMultiConnection()
551         elif theCriterion == FT_MultiConnection2D:
552             return aFilterMgr.CreateMultiConnection2D()
553         elif theCriterion == FT_Length:
554             return aFilterMgr.CreateLength()
555         elif theCriterion == FT_Length2D:
556             return aFilterMgr.CreateLength2D()
557         else:
558             print "Error: given parameter is not numerucal functor type."
559
560
561 import omniORB
562 #Registering the new proxy for SMESH_Gen
563 omniORB.registerObjref(SMESH._objref_SMESH_Gen._NP_RepositoryId, smeshDC)
564
565
566 # Public class: Mesh
567 # ==================
568
569 ## This class allows defining and managing a mesh.
570 #  It has a set of methods to build a mesh on the given geometry, including the definition of sub-meshes.
571 #  It also has methods to define groups of mesh elements, to modify a mesh (by addition of
572 #  new nodes and elements and by changing the existing entities), to get information
573 #  about a mesh and to export a mesh into different formats.
574 class Mesh:
575
576     geom = 0
577     mesh = 0
578     editor = 0
579
580     ## Constructor
581     #
582     #  Creates a mesh on the shape \a obj (or an empty mesh if \a obj is equal to 0) and
583     #  sets the GUI name of this mesh to \a name.
584     #  @param smeshpyD an instance of smeshDC class
585     #  @param geompyD an instance of geompyDC class
586     #  @param obj Shape to be meshed or SMESH_Mesh object
587     #  @param name Study name of the mesh
588     #  @ingroup l2_construct
589     def __init__(self, smeshpyD, geompyD, obj=0, name=0):
590         self.smeshpyD=smeshpyD
591         self.geompyD=geompyD
592         if obj is None:
593             obj = 0
594         if obj != 0:
595             if isinstance(obj, geompyDC.GEOM._objref_GEOM_Object):
596                 self.geom = obj
597                 self.mesh = self.smeshpyD.CreateMesh(self.geom)
598             elif isinstance(obj, SMESH._objref_SMESH_Mesh):
599                 self.SetMesh(obj)
600         else:
601             self.mesh = self.smeshpyD.CreateEmptyMesh()
602         if name != 0:
603             SetName(self.mesh, name)
604         elif obj != 0:
605             SetName(self.mesh, GetName(obj))
606
607         if not self.geom:
608             self.geom = self.mesh.GetShapeToMesh()
609
610         self.editor = self.mesh.GetMeshEditor()
611
612     ## Initializes the Mesh object from an instance of SMESH_Mesh interface
613     #  @param theMesh a SMESH_Mesh object
614     #  @ingroup l2_construct
615     def SetMesh(self, theMesh):
616         self.mesh = theMesh
617         self.geom = self.mesh.GetShapeToMesh()
618
619     ## Returns the mesh, that is an instance of SMESH_Mesh interface
620     #  @return a SMESH_Mesh object
621     #  @ingroup l2_construct
622     def GetMesh(self):
623         return self.mesh
624
625     ## Gets the name of the mesh
626     #  @return the name of the mesh as a string
627     #  @ingroup l2_construct
628     def GetName(self):
629         name = GetName(self.GetMesh())
630         return name
631
632     ## Sets a name to the mesh
633     #  @param name a new name of the mesh
634     #  @ingroup l2_construct
635     def SetName(self, name):
636         SetName(self.GetMesh(), name)
637
638     ## Gets the subMesh object associated to a \a theSubObject geometrical object.
639     #  The subMesh object gives access to the IDs of nodes and elements.
640     #  @param theSubObject a geometrical object (shape)
641     #  @param theName a name for the submesh
642     #  @return an object of type SMESH_SubMesh, representing a part of mesh, which lies on the given shape
643     #  @ingroup l2_submeshes
644     def GetSubMesh(self, theSubObject, theName):
645         submesh = self.mesh.GetSubMesh(theSubObject, theName)
646         return submesh
647
648     ## Returns the shape associated to the mesh
649     #  @return a GEOM_Object
650     #  @ingroup l2_construct
651     def GetShape(self):
652         return self.geom
653
654     ## Associates the given shape to the mesh (entails the recreation of the mesh)
655     #  @param geom the shape to be meshed (GEOM_Object)
656     #  @ingroup l2_construct
657     def SetShape(self, geom):
658         self.mesh = self.smeshpyD.CreateMesh(geom)
659
660     ## Returns true if the hypotheses are defined well
661     #  @param theSubObject a subshape of a mesh shape
662     #  @return True or False
663     #  @ingroup l2_construct
664     def IsReadyToCompute(self, theSubObject):
665         return self.smeshpyD.IsReadyToCompute(self.mesh, theSubObject)
666
667     ## Returns errors of hypotheses definition.
668     #  The list of errors is empty if everything is OK.
669     #  @param theSubObject a subshape of a mesh shape
670     #  @return a list of errors
671     #  @ingroup l2_construct
672     def GetAlgoState(self, theSubObject):
673         return self.smeshpyD.GetAlgoState(self.mesh, theSubObject)
674
675     ## Returns a geometrical object on which the given element was built.
676     #  The returned geometrical object, if not nil, is either found in the
677     #  study or published by this method with the given name
678     #  @param theElementID the id of the mesh element
679     #  @param theGeomName the user-defined name of the geometrical object
680     #  @return GEOM::GEOM_Object instance
681     #  @ingroup l2_construct
682     def GetGeometryByMeshElement(self, theElementID, theGeomName):
683         return self.smeshpyD.GetGeometryByMeshElement( self.mesh, theElementID, theGeomName )
684
685     ## Returns the mesh dimension depending on the dimension of the underlying shape
686     #  @return mesh dimension as an integer value [0,3]
687     #  @ingroup l1_auxiliary
688     def MeshDimension(self):
689         shells = self.geompyD.SubShapeAllIDs( self.geom, geompyDC.ShapeType["SHELL"] )
690         if len( shells ) > 0 :
691             return 3
692         elif self.geompyD.NumberOfFaces( self.geom ) > 0 :
693             return 2
694         elif self.geompyD.NumberOfEdges( self.geom ) > 0 :
695             return 1
696         else:
697             return 0;
698         pass
699
700     ## Creates a segment discretization 1D algorithm.
701     #  If the optional \a algo parameter is not set, this algorithm is REGULAR.
702     #  \n If the optional \a geom parameter is not set, this algorithm is global.
703     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
704     #  @param algo the type of the required algorithm. Possible values are:
705     #     - smesh.REGULAR,
706     #     - smesh.PYTHON for discretization via a python function,
707     #     - smesh.COMPOSITE for meshing a set of edges on one face side as a whole.
708     #  @param geom If defined is the subshape to be meshed
709     #  @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class
710     #  @ingroup l3_algos_basic
711     def Segment(self, algo=REGULAR, geom=0):
712         ## if Segment(geom) is called by mistake
713         if isinstance( algo, geompyDC.GEOM._objref_GEOM_Object):
714             algo, geom = geom, algo
715             if not algo: algo = REGULAR
716             pass
717         if algo == REGULAR:
718             return Mesh_Segment(self,  geom)
719         elif algo == PYTHON:
720             return Mesh_Segment_Python(self, geom)
721         elif algo == COMPOSITE:
722             return Mesh_CompositeSegment(self, geom)
723         else:
724             return Mesh_Segment(self, geom)
725
726     ## Enables creation of nodes and segments usable by 2D algoritms.
727     #  The added nodes and segments must be bound to edges and vertices by
728     #  SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
729     #  If the optional \a geom parameter is not set, this algorithm is global.
730     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
731     #  @param geom the subshape to be manually meshed
732     #  @return StdMeshers_UseExisting_1D algorithm that generates nothing
733     #  @ingroup l3_algos_basic
734     def UseExistingSegments(self, geom=0):
735         algo = Mesh_UseExisting(1,self,geom)
736         return algo.GetAlgorithm()
737
738     ## Enables creation of nodes and faces usable by 3D algoritms.
739     #  The added nodes and faces must be bound to geom faces by SetNodeOnFace()
740     #  and SetMeshElementOnShape()
741     #  If the optional \a geom parameter is not set, this algorithm is global.
742     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
743     #  @param geom the subshape to be manually meshed
744     #  @return StdMeshers_UseExisting_2D algorithm that generates nothing
745     #  @ingroup l3_algos_basic
746     def UseExistingFaces(self, geom=0):
747         algo = Mesh_UseExisting(2,self,geom)
748         return algo.GetAlgorithm()
749
750     ## Creates a triangle 2D algorithm for faces.
751     #  If the optional \a geom parameter is not set, this algorithm is global.
752     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
753     #  @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF
754     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
755     #  @return an instance of Mesh_Triangle algorithm
756     #  @ingroup l3_algos_basic
757     def Triangle(self, algo=MEFISTO, geom=0):
758         ## if Triangle(geom) is called by mistake
759         if (isinstance(algo, geompyDC.GEOM._objref_GEOM_Object)):
760             geom = algo
761             algo = MEFISTO
762
763         return Mesh_Triangle(self, algo, geom)
764
765     ## Creates a quadrangle 2D algorithm for faces.
766     #  If the optional \a geom parameter is not set, this algorithm is global.
767     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
768     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
769     #  @return an instance of Mesh_Quadrangle algorithm
770     #  @ingroup l3_algos_basic
771     def Quadrangle(self, geom=0):
772         return Mesh_Quadrangle(self,  geom)
773
774     ## Creates a tetrahedron 3D algorithm for solids.
775     #  The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
776     #  If the optional \a geom parameter is not set, this algorithm is global.
777     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
778     #  @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.FULL_NETGEN
779     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
780     #  @return an instance of Mesh_Tetrahedron algorithm
781     #  @ingroup l3_algos_basic
782     def Tetrahedron(self, algo=NETGEN, geom=0):
783         ## if Tetrahedron(geom) is called by mistake
784         if ( isinstance( algo, geompyDC.GEOM._objref_GEOM_Object)):
785             algo, geom = geom, algo
786             if not algo: algo = NETGEN
787             pass
788         return Mesh_Tetrahedron(self,  algo, geom)
789
790     ## Creates a hexahedron 3D algorithm for solids.
791     #  If the optional \a geom parameter is not set, this algorithm is global.
792     #  \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
793     #  @param algo possible values are: smesh.Hexa, smesh.Hexotic
794     #  @param geom If defined, the subshape to be meshed (GEOM_Object)
795     #  @return an instance of Mesh_Hexahedron algorithm
796     #  @ingroup l3_algos_basic
797     def Hexahedron(self, algo=Hexa, geom=0):
798         ## if Hexahedron(geom, algo) or Hexahedron(geom) is called by mistake
799         if ( isinstance(algo, geompyDC.GEOM._objref_GEOM_Object) ):
800             if   geom in [Hexa, Hexotic]: algo, geom = geom, algo
801             elif geom == 0:               algo, geom = Hexa, algo
802         return Mesh_Hexahedron(self, algo, geom)
803
804     ## Deprecated, used only for compatibility!
805     #  @return an instance of Mesh_Netgen algorithm
806     #  @ingroup l3_algos_basic
807     def Netgen(self, is3D, geom=0):
808         return Mesh_Netgen(self,  is3D, geom)
809
810     ## Creates a projection 1D algorithm for edges.
811     #  If the optional \a geom parameter is not set, this algorithm is global.
812     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
813     #  @param geom If defined, the subshape to be meshed
814     #  @return an instance of Mesh_Projection1D algorithm
815     #  @ingroup l3_algos_proj
816     def Projection1D(self, geom=0):
817         return Mesh_Projection1D(self,  geom)
818
819     ## Creates a projection 2D algorithm for faces.
820     #  If the optional \a geom parameter is not set, this algorithm is global.
821     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
822     #  @param geom If defined, the subshape to be meshed
823     #  @return an instance of Mesh_Projection2D algorithm
824     #  @ingroup l3_algos_proj
825     def Projection2D(self, geom=0):
826         return Mesh_Projection2D(self,  geom)
827
828     ## Creates a projection 3D algorithm for solids.
829     #  If the optional \a geom parameter is not set, this algorithm is global.
830     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
831     #  @param geom If defined, the subshape to be meshed
832     #  @return an instance of Mesh_Projection3D algorithm
833     #  @ingroup l3_algos_proj
834     def Projection3D(self, geom=0):
835         return Mesh_Projection3D(self,  geom)
836
837     ## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids.
838     #  If the optional \a geom parameter is not set, this algorithm is global.
839     #  Otherwise, this algorithm defines a submesh based on \a geom subshape.
840     #  @param geom If defined, the subshape to be meshed
841     #  @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm
842     #  @ingroup l3_algos_radialp l3_algos_3dextr
843     def Prism(self, geom=0):
844         shape = geom
845         if shape==0:
846             shape = self.geom
847         nbSolids = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SOLID"] ))
848         nbShells = len( self.geompyD.SubShapeAll( shape, geompyDC.ShapeType["SHELL"] ))
849         if nbSolids == 0 or nbSolids == nbShells:
850             return Mesh_Prism3D(self,  geom)
851         return Mesh_RadialPrism3D(self,  geom)
852
853     ## Computes the mesh and returns the status of the computation
854     #  @return True or False
855     #  @ingroup l2_construct
856     def Compute(self, geom=0):
857         if geom == 0 or not isinstance(geom, geompyDC.GEOM._objref_GEOM_Object):
858             if self.geom == 0:
859                 geom = self.mesh.GetShapeToMesh()
860             else:
861                 geom = self.geom
862         ok = False
863         try:
864             ok = self.smeshpyD.Compute(self.mesh, geom)
865         except SALOME.SALOME_Exception, ex:
866             print "Mesh computation failed, exception caught:"
867             print "    ", ex.details.text
868         except:
869             import traceback
870             print "Mesh computation failed, exception caught:"
871             traceback.print_exc()
872         if True:#not ok:
873             errors = self.smeshpyD.GetAlgoState( self.mesh, geom )
874             allReasons = ""
875             for err in errors:
876                 if err.isGlobalAlgo:
877                     glob = "global"
878                 else:
879                     glob = "local"
880                     pass
881                 dim = err.algoDim
882                 name = err.algoName
883                 if len(name) == 0:
884                     reason = '%s %sD algorithm is missing' % (glob, dim)
885                 elif err.state == HYP_MISSING:
886                     reason = ('%s %sD algorithm "%s" misses %sD hypothesis'
887                               % (glob, dim, name, dim))
888                 elif err.state == HYP_NOTCONFORM:
889                     reason = 'Global "Not Conform mesh allowed" hypothesis is missing'
890                 elif err.state == HYP_BAD_PARAMETER:
891                     reason = ('Hypothesis of %s %sD algorithm "%s" has a bad parameter value'
892                               % ( glob, dim, name ))
893                 elif err.state == HYP_BAD_GEOMETRY:
894                     reason = ('%s %sD algorithm "%s" is assigned to mismatching'
895                               'geometry' % ( glob, dim, name ))
896                 else:
897                     reason = "For unknown reason."+\
898                              " Revise Mesh.Compute() implementation in smeshDC.py!"
899                     pass
900                 if allReasons != "":
901                     allReasons += "\n"
902                     pass
903                 allReasons += reason
904                 pass
905             if allReasons != "":
906                 print '"' + GetName(self.mesh) + '"',"has not been computed:"
907                 print allReasons
908                 ok = False
909             elif not ok:
910                 print '"' + GetName(self.mesh) + '"',"has not been computed."
911                 pass
912             pass
913         if salome.sg.hasDesktop():
914             smeshgui = salome.ImportComponentGUI("SMESH")
915             smeshgui.Init(salome.myStudyId)
916             smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) )
917             salome.sg.updateObjBrowser(1)
918             pass
919         return ok
920
921     ## Removes all nodes and elements
922     #  @ingroup l2_construct
923     def Clear(self):
924         self.mesh.Clear()
925         if salome.sg.hasDesktop():
926             smeshgui = salome.ImportComponentGUI("SMESH")
927             smeshgui.Init(salome.myStudyId)
928             smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True )
929             salome.sg.updateObjBrowser(1)
930
931     ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN
932     #  @param fineness [0,-1] defines mesh fineness
933     #  @return True or False
934     #  @ingroup l3_algos_basic
935     def AutomaticTetrahedralization(self, fineness=0):
936         dim = self.MeshDimension()
937         # assign hypotheses
938         self.RemoveGlobalHypotheses()
939         self.Segment().AutomaticLength(fineness)
940         if dim > 1 :
941             self.Triangle().LengthFromEdges()
942             pass
943         if dim > 2 :
944             self.Tetrahedron(NETGEN)
945             pass
946         return self.Compute()
947
948     ## Computes an hexahedral mesh using AutomaticLength + Quadrangle + Hexahedron
949     #  @param fineness [0,-1] defines mesh fineness
950     #  @return True or False
951     #  @ingroup l3_algos_basic
952     def AutomaticHexahedralization(self, fineness=0):
953         dim = self.MeshDimension()
954         # assign the hypotheses
955         self.RemoveGlobalHypotheses()
956         self.Segment().AutomaticLength(fineness)
957         if dim > 1 :
958             self.Quadrangle()
959             pass
960         if dim > 2 :
961             self.Hexahedron()
962             pass
963         return self.Compute()
964
965     ## Assigns a hypothesis
966     #  @param hyp a hypothesis to assign
967     #  @param geom a subhape of mesh geometry
968     #  @return SMESH.Hypothesis_Status
969     #  @ingroup l2_hypotheses
970     def AddHypothesis(self, hyp, geom=0):
971         if isinstance( hyp, Mesh_Algorithm ):
972             hyp = hyp.GetAlgorithm()
973             pass
974         if not geom:
975             geom = self.geom
976             if not geom:
977                 geom = self.mesh.GetShapeToMesh()
978             pass
979         status = self.mesh.AddHypothesis(geom, hyp)
980         isAlgo = hyp._narrow( SMESH_Algo )
981         TreatHypoStatus( status, GetName( hyp ), GetName( geom ), isAlgo )
982         return status
983
984     ## Unassigns a hypothesis
985     #  @param hyp a hypothesis to unassign
986     #  @param geom a subshape of mesh geometry
987     #  @return SMESH.Hypothesis_Status
988     #  @ingroup l2_hypotheses
989     def RemoveHypothesis(self, hyp, geom=0):
990         if isinstance( hyp, Mesh_Algorithm ):
991             hyp = hyp.GetAlgorithm()
992             pass
993         if not geom:
994             geom = self.geom
995             pass
996         status = self.mesh.RemoveHypothesis(geom, hyp)
997         return status
998
999     ## Gets the list of hypotheses added on a geometry
1000     #  @param geom a subshape of mesh geometry
1001     #  @return the sequence of SMESH_Hypothesis
1002     #  @ingroup l2_hypotheses
1003     def GetHypothesisList(self, geom):
1004         return self.mesh.GetHypothesisList( geom )
1005
1006     ## Removes all global hypotheses
1007     #  @ingroup l2_hypotheses
1008     def RemoveGlobalHypotheses(self):
1009         current_hyps = self.mesh.GetHypothesisList( self.geom )
1010         for hyp in current_hyps:
1011             self.mesh.RemoveHypothesis( self.geom, hyp )
1012             pass
1013         pass
1014
1015     ## Creates a mesh group based on the geometric object \a grp
1016     #  and gives a \a name, \n if this parameter is not defined
1017     #  the name is the same as the geometric group name \n
1018     #  Note: Works like GroupOnGeom().
1019     #  @param grp  a geometric group, a vertex, an edge, a face or a solid
1020     #  @param name the name of the mesh group
1021     #  @return SMESH_GroupOnGeom
1022     #  @ingroup l2_grps_create
1023     def Group(self, grp, name=""):
1024         return self.GroupOnGeom(grp, name)
1025
1026     ## Deprecated, used only for compatibility! Please, use ExportMED() method instead.
1027     #  Exports the mesh in a file in MED format and chooses the \a version of MED format
1028     #  @param f the file name
1029     #  @param version values are SMESH.MED_V2_1, SMESH.MED_V2_2
1030     #  @ingroup l2_impexp
1031     def ExportToMED(self, f, version, opt=0):
1032         self.mesh.ExportToMED(f, opt, version)
1033
1034     ## Exports the mesh in a file in MED format
1035     #  @param f is the file name
1036     #  @param auto_groups boolean parameter for creating/not creating
1037     #  the groups Group_On_All_Nodes, Group_On_All_Faces, ... ;
1038     #  the typical use is auto_groups=false.
1039     #  @param version MED format version(MED_V2_1 or MED_V2_2)
1040     #  @ingroup l2_impexp
1041     def ExportMED(self, f, auto_groups=0, version=MED_V2_2):
1042         self.mesh.ExportToMED(f, auto_groups, version)
1043
1044     ## Exports the mesh in a file in DAT format
1045     #  @param f the file name
1046     #  @ingroup l2_impexp
1047     def ExportDAT(self, f):
1048         self.mesh.ExportDAT(f)
1049
1050     ## Exports the mesh in a file in UNV format
1051     #  @param f the file name
1052     #  @ingroup l2_impexp
1053     def ExportUNV(self, f):
1054         self.mesh.ExportUNV(f)
1055
1056     ## Export the mesh in a file in STL format
1057     #  @param f the file name
1058     #  @param ascii defines the file encoding
1059     #  @ingroup l2_impexp
1060     def ExportSTL(self, f, ascii=1):
1061         self.mesh.ExportSTL(f, ascii)
1062
1063
1064     # Operations with groups:
1065     # ----------------------
1066
1067     ## Creates an empty mesh group
1068     #  @param elementType the type of elements in the group
1069     #  @param name the name of the mesh group
1070     #  @return SMESH_Group
1071     #  @ingroup l2_grps_create
1072     def CreateEmptyGroup(self, elementType, name):
1073         return self.mesh.CreateGroup(elementType, name)
1074
1075     ## Creates a mesh group based on the geometrical object \a grp
1076     #  and gives a \a name, \n if this parameter is not defined
1077     #  the name is the same as the geometrical group name
1078     #  @param grp  a geometrical group, a vertex, an edge, a face or a solid
1079     #  @param name the name of the mesh group
1080     #  @param typ  the type of elements in the group. If not set, it is
1081     #              automatically detected by the type of the geometry
1082     #  @return SMESH_GroupOnGeom
1083     #  @ingroup l2_grps_create
1084     def GroupOnGeom(self, grp, name="", typ=None):
1085         if name == "":
1086             name = grp.GetName()
1087
1088         if typ == None:
1089             tgeo = str(grp.GetShapeType())
1090             if tgeo == "VERTEX":
1091                 typ = NODE
1092             elif tgeo == "EDGE":
1093                 typ = EDGE
1094             elif tgeo == "FACE":
1095                 typ = FACE
1096             elif tgeo == "SOLID":
1097                 typ = VOLUME
1098             elif tgeo == "SHELL":
1099                 typ = VOLUME
1100             elif tgeo == "COMPOUND":
1101                 if len( self.geompyD.GetObjectIDs( grp )) == 0:
1102                     print "Mesh.Group: empty geometric group", GetName( grp )
1103                     return 0
1104                 tgeo = self.geompyD.GetType(grp)
1105                 if tgeo == geompyDC.ShapeType["VERTEX"]:
1106                     typ = NODE
1107                 elif tgeo == geompyDC.ShapeType["EDGE"]:
1108                     typ = EDGE
1109                 elif tgeo == geompyDC.ShapeType["FACE"]:
1110                     typ = FACE
1111                 elif tgeo == geompyDC.ShapeType["SOLID"]:
1112                     typ = VOLUME
1113
1114         if typ == None:
1115             print "Mesh.Group: bad first argument: expected a group, a vertex, an edge, a face or a solid"
1116             return 0
1117         else:
1118             return self.mesh.CreateGroupFromGEOM(typ, name, grp)
1119
1120     ## Creates a mesh group by the given ids of elements
1121     #  @param groupName the name of the mesh group
1122     #  @param elementType the type of elements in the group
1123     #  @param elemIDs the list of ids
1124     #  @return SMESH_Group
1125     #  @ingroup l2_grps_create
1126     def MakeGroupByIds(self, groupName, elementType, elemIDs):
1127         group = self.mesh.CreateGroup(elementType, groupName)
1128         group.Add(elemIDs)
1129         return group
1130
1131     ## Creates a mesh group by the given conditions
1132     #  @param groupName the name of the mesh group
1133     #  @param elementType the type of elements in the group
1134     #  @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
1135     #  @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
1136     #  @param Treshold the threshold value (range of id ids as string, shape, numeric)
1137     #  @param UnaryOp FT_LogicalNOT or FT_Undefined
1138     #  @return SMESH_Group
1139     #  @ingroup l2_grps_create
1140     def MakeGroup(self,
1141                   groupName,
1142                   elementType,
1143                   CritType=FT_Undefined,
1144                   Compare=FT_EqualTo,
1145                   Treshold="",
1146                   UnaryOp=FT_Undefined):
1147         aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined)
1148         group = self.MakeGroupByCriterion(groupName, aCriterion)
1149         return group
1150
1151     ## Creates a mesh group by the given criterion
1152     #  @param groupName the name of the mesh group
1153     #  @param Criterion the instance of Criterion class
1154     #  @return SMESH_Group
1155     #  @ingroup l2_grps_create
1156     def MakeGroupByCriterion(self, groupName, Criterion):
1157         aFilterMgr = self.smeshpyD.CreateFilterManager()
1158         aFilter = aFilterMgr.CreateFilter()
1159         aCriteria = []
1160         aCriteria.append(Criterion)
1161         aFilter.SetCriteria(aCriteria)
1162         group = self.MakeGroupByFilter(groupName, aFilter)
1163         return group
1164
1165     ## Creates a mesh group by the given criteria (list of criteria)
1166     #  @param groupName the name of the mesh group
1167     #  @param theCriteria the list of criteria
1168     #  @return SMESH_Group
1169     #  @ingroup l2_grps_create
1170     def MakeGroupByCriteria(self, groupName, theCriteria):
1171         aFilterMgr = self.smeshpyD.CreateFilterManager()
1172         aFilter = aFilterMgr.CreateFilter()
1173         aFilter.SetCriteria(theCriteria)
1174         group = self.MakeGroupByFilter(groupName, aFilter)
1175         return group
1176
1177     ## Creates a mesh group by the given filter
1178     #  @param groupName the name of the mesh group
1179     #  @param theFilter the instance of Filter class
1180     #  @return SMESH_Group
1181     #  @ingroup l2_grps_create
1182     def MakeGroupByFilter(self, groupName, theFilter):
1183         anIds = theFilter.GetElementsId(self.mesh)
1184         anElemType = theFilter.GetElementType()
1185         group = self.MakeGroupByIds(groupName, anElemType, anIds)
1186         return group
1187
1188     ## Passes mesh elements through the given filter and return IDs of fitting elements
1189     #  @param theFilter SMESH_Filter
1190     #  @return a list of ids
1191     #  @ingroup l1_controls
1192     def GetIdsFromFilter(self, theFilter):
1193         return theFilter.GetElementsId(self.mesh)
1194
1195     ## Verifies whether a 2D mesh element has free edges (edges connected to one face only)\n
1196     #  Returns a list of special structures (borders).
1197     #  @return a list of SMESH.FreeEdges.Border structure: edge id and ids of two its nodes.
1198     #  @ingroup l1_controls
1199     def GetFreeBorders(self):
1200         aFilterMgr = self.smeshpyD.CreateFilterManager()
1201         aPredicate = aFilterMgr.CreateFreeEdges()
1202         aPredicate.SetMesh(self.mesh)
1203         aBorders = aPredicate.GetBorders()
1204         return aBorders
1205
1206     ## Removes a group
1207     #  @ingroup l2_grps_delete
1208     def RemoveGroup(self, group):
1209         self.mesh.RemoveGroup(group)
1210
1211     ## Removes a group with its contents
1212     #  @ingroup l2_grps_delete
1213     def RemoveGroupWithContents(self, group):
1214         self.mesh.RemoveGroupWithContents(group)
1215
1216     ## Gets the list of groups existing in the mesh
1217     #  @return a sequence of SMESH_GroupBase
1218     #  @ingroup l2_grps_create
1219     def GetGroups(self):
1220         return self.mesh.GetGroups()
1221
1222     ## Gets the number of groups existing in the mesh
1223     #  @return the quantity of groups as an integer value
1224     #  @ingroup l2_grps_create
1225     def NbGroups(self):
1226         return self.mesh.NbGroups()
1227
1228     ## Gets the list of names of groups existing in the mesh
1229     #  @return list of strings
1230     #  @ingroup l2_grps_create
1231     def GetGroupNames(self):
1232         groups = self.GetGroups()
1233         names = []
1234         for group in groups:
1235             names.append(group.GetName())
1236         return names
1237
1238     ## Produces a union of two groups
1239     #  A new group is created. All mesh elements that are
1240     #  present in the initial groups are added to the new one
1241     #  @return an instance of SMESH_Group
1242     #  @ingroup l2_grps_operon
1243     def UnionGroups(self, group1, group2, name):
1244         return self.mesh.UnionGroups(group1, group2, name)
1245
1246     ## Prodices an intersection of two groups
1247     #  A new group is created. All mesh elements that are common
1248     #  for the two initial groups are added to the new one.
1249     #  @return an instance of SMESH_Group
1250     #  @ingroup l2_grps_operon
1251     def IntersectGroups(self, group1, group2, name):
1252         return self.mesh.IntersectGroups(group1, group2, name)
1253
1254     ## Produces a cut of two groups
1255     #  A new group is created. All mesh elements that are present in
1256     #  the main group but are not present in the tool group are added to the new one
1257     #  @return an instance of SMESH_Group
1258     #  @ingroup l2_grps_operon
1259     def CutGroups(self, mainGroup, toolGroup, name):
1260         return self.mesh.CutGroups(mainGroup, toolGroup, name)
1261
1262
1263     # Get some info about mesh:
1264     # ------------------------
1265
1266     ## Returns the log of nodes and elements added or removed
1267     #  since the previous clear of the log.
1268     #  @param clearAfterGet log is emptied after Get (safe if concurrents access)
1269     #  @return list of log_block structures:
1270     #                                        commandType
1271     #                                        number
1272     #                                        coords
1273     #                                        indexes
1274     #  @ingroup l1_auxiliary
1275     def GetLog(self, clearAfterGet):
1276         return self.mesh.GetLog(clearAfterGet)
1277
1278     ## Clears the log of nodes and elements added or removed since the previous
1279     #  clear. Must be used immediately after GetLog if clearAfterGet is false.
1280     #  @ingroup l1_auxiliary
1281     def ClearLog(self):
1282         self.mesh.ClearLog()
1283
1284     ## Toggles auto color mode on the object.
1285     #  @param theAutoColor the flag which toggles auto color mode.
1286     #  @ingroup l1_auxiliary
1287     def SetAutoColor(self, theAutoColor):
1288         self.mesh.SetAutoColor(theAutoColor)
1289
1290     ## Gets flag of object auto color mode.
1291     #  @return True or False
1292     #  @ingroup l1_auxiliary
1293     def GetAutoColor(self):
1294         return self.mesh.GetAutoColor()
1295
1296     ## Gets the internal ID
1297     #  @return integer value, which is the internal Id of the mesh
1298     #  @ingroup l1_auxiliary
1299     def GetId(self):
1300         return self.mesh.GetId()
1301
1302     ## Get the study Id
1303     #  @return integer value, which is the study Id of the mesh
1304     #  @ingroup l1_auxiliary
1305     def GetStudyId(self):
1306         return self.mesh.GetStudyId()
1307
1308     ## Checks the group names for duplications.
1309     #  Consider the maximum group name length stored in MED file.
1310     #  @return True or False
1311     #  @ingroup l1_auxiliary
1312     def HasDuplicatedGroupNamesMED(self):
1313         return self.mesh.HasDuplicatedGroupNamesMED()
1314
1315     ## Obtains the mesh editor tool
1316     #  @return an instance of SMESH_MeshEditor
1317     #  @ingroup l1_modifying
1318     def GetMeshEditor(self):
1319         return self.mesh.GetMeshEditor()
1320
1321     ## Gets MED Mesh
1322     #  @return an instance of SALOME_MED::MESH
1323     #  @ingroup l1_auxiliary
1324     def GetMEDMesh(self):
1325         return self.mesh.GetMEDMesh()
1326
1327
1328     # Get informations about mesh contents:
1329     # ------------------------------------
1330
1331     ## Returns the number of nodes in the mesh
1332     #  @return an integer value
1333     #  @ingroup l1_meshinfo
1334     def NbNodes(self):
1335         return self.mesh.NbNodes()
1336
1337     ## Returns the number of elements in the mesh
1338     #  @return an integer value
1339     #  @ingroup l1_meshinfo
1340     def NbElements(self):
1341         return self.mesh.NbElements()
1342
1343     ## Returns the number of edges in the mesh
1344     #  @return an integer value
1345     #  @ingroup l1_meshinfo
1346     def NbEdges(self):
1347         return self.mesh.NbEdges()
1348
1349     ## Returns the number of edges with the given order in the mesh
1350     #  @param elementOrder the order of elements:
1351     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1352     #  @return an integer value
1353     #  @ingroup l1_meshinfo
1354     def NbEdgesOfOrder(self, elementOrder):
1355         return self.mesh.NbEdgesOfOrder(elementOrder)
1356
1357     ## Returns the number of faces in the mesh
1358     #  @return an integer value
1359     #  @ingroup l1_meshinfo
1360     def NbFaces(self):
1361         return self.mesh.NbFaces()
1362
1363     ## Returns the number of faces with the given order in the mesh
1364     #  @param elementOrder the order of elements:
1365     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1366     #  @return an integer value
1367     #  @ingroup l1_meshinfo
1368     def NbFacesOfOrder(self, elementOrder):
1369         return self.mesh.NbFacesOfOrder(elementOrder)
1370
1371     ## Returns the number of triangles in the mesh
1372     #  @return an integer value
1373     #  @ingroup l1_meshinfo
1374     def NbTriangles(self):
1375         return self.mesh.NbTriangles()
1376
1377     ## Returns the number of triangles with the given order in the mesh
1378     #  @param elementOrder is the order of elements:
1379     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1380     #  @return an integer value
1381     #  @ingroup l1_meshinfo
1382     def NbTrianglesOfOrder(self, elementOrder):
1383         return self.mesh.NbTrianglesOfOrder(elementOrder)
1384
1385     ## Returns the number of quadrangles in the mesh
1386     #  @return an integer value
1387     #  @ingroup l1_meshinfo
1388     def NbQuadrangles(self):
1389         return self.mesh.NbQuadrangles()
1390
1391     ## Returns the number of quadrangles with the given order in the mesh
1392     #  @param elementOrder the order of elements:
1393     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1394     #  @return an integer value
1395     #  @ingroup l1_meshinfo
1396     def NbQuadranglesOfOrder(self, elementOrder):
1397         return self.mesh.NbQuadranglesOfOrder(elementOrder)
1398
1399     ## Returns the number of polygons in the mesh
1400     #  @return an integer value
1401     #  @ingroup l1_meshinfo
1402     def NbPolygons(self):
1403         return self.mesh.NbPolygons()
1404
1405     ## Returns the number of volumes in the mesh
1406     #  @return an integer value
1407     #  @ingroup l1_meshinfo
1408     def NbVolumes(self):
1409         return self.mesh.NbVolumes()
1410
1411     ## Returns the number of volumes with the given order in the mesh
1412     #  @param elementOrder  the order of elements:
1413     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1414     #  @return an integer value
1415     #  @ingroup l1_meshinfo
1416     def NbVolumesOfOrder(self, elementOrder):
1417         return self.mesh.NbVolumesOfOrder(elementOrder)
1418
1419     ## Returns the number of tetrahedrons in the mesh
1420     #  @return an integer value
1421     #  @ingroup l1_meshinfo
1422     def NbTetras(self):
1423         return self.mesh.NbTetras()
1424
1425     ## Returns the number of tetrahedrons with the given order in the mesh
1426     #  @param elementOrder  the order of elements:
1427     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1428     #  @return an integer value
1429     #  @ingroup l1_meshinfo
1430     def NbTetrasOfOrder(self, elementOrder):
1431         return self.mesh.NbTetrasOfOrder(elementOrder)
1432
1433     ## Returns the number of hexahedrons in the mesh
1434     #  @return an integer value
1435     #  @ingroup l1_meshinfo
1436     def NbHexas(self):
1437         return self.mesh.NbHexas()
1438
1439     ## Returns the number of hexahedrons with the given order in the mesh
1440     #  @param elementOrder  the order of elements:
1441     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1442     #  @return an integer value
1443     #  @ingroup l1_meshinfo
1444     def NbHexasOfOrder(self, elementOrder):
1445         return self.mesh.NbHexasOfOrder(elementOrder)
1446
1447     ## Returns the number of pyramids in the mesh
1448     #  @return an integer value
1449     #  @ingroup l1_meshinfo
1450     def NbPyramids(self):
1451         return self.mesh.NbPyramids()
1452
1453     ## Returns the number of pyramids with the given order in the mesh
1454     #  @param elementOrder  the order of elements:
1455     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1456     #  @return an integer value
1457     #  @ingroup l1_meshinfo
1458     def NbPyramidsOfOrder(self, elementOrder):
1459         return self.mesh.NbPyramidsOfOrder(elementOrder)
1460
1461     ## Returns the number of prisms in the mesh
1462     #  @return an integer value
1463     #  @ingroup l1_meshinfo
1464     def NbPrisms(self):
1465         return self.mesh.NbPrisms()
1466
1467     ## Returns the number of prisms with the given order in the mesh
1468     #  @param elementOrder  the order of elements:
1469     #         ORDER_ANY, ORDER_LINEAR or ORDER_QUADRATIC
1470     #  @return an integer value
1471     #  @ingroup l1_meshinfo
1472     def NbPrismsOfOrder(self, elementOrder):
1473         return self.mesh.NbPrismsOfOrder(elementOrder)
1474
1475     ## Returns the number of polyhedrons in the mesh
1476     #  @return an integer value
1477     #  @ingroup l1_meshinfo
1478     def NbPolyhedrons(self):
1479         return self.mesh.NbPolyhedrons()
1480
1481     ## Returns the number of submeshes in the mesh
1482     #  @return an integer value
1483     #  @ingroup l1_meshinfo
1484     def NbSubMesh(self):
1485         return self.mesh.NbSubMesh()
1486
1487     ## Returns the list of mesh elements IDs
1488     #  @return the list of integer values
1489     #  @ingroup l1_meshinfo
1490     def GetElementsId(self):
1491         return self.mesh.GetElementsId()
1492
1493     ## Returns the list of IDs of mesh elements with the given type
1494     #  @param elementType  the required type of elements
1495     #  @return list of integer values
1496     #  @ingroup l1_meshinfo
1497     def GetElementsByType(self, elementType):
1498         return self.mesh.GetElementsByType(elementType)
1499
1500     ## Returns the list of mesh nodes IDs
1501     #  @return the list of integer values
1502     #  @ingroup l1_meshinfo
1503     def GetNodesId(self):
1504         return self.mesh.GetNodesId()
1505
1506     # Get the information about mesh elements:
1507     # ------------------------------------
1508
1509     ## Returns the type of mesh element
1510     #  @return the value from SMESH::ElementType enumeration
1511     #  @ingroup l1_meshinfo
1512     def GetElementType(self, id, iselem):
1513         return self.mesh.GetElementType(id, iselem)
1514
1515     ## Returns the list of submesh elements IDs
1516     #  @param Shape a geom object(subshape) IOR
1517     #         Shape must be the subshape of a ShapeToMesh()
1518     #  @return the list of integer values
1519     #  @ingroup l1_meshinfo
1520     def GetSubMeshElementsId(self, Shape):
1521         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1522             ShapeID = Shape.GetSubShapeIndices()[0]
1523         else:
1524             ShapeID = Shape
1525         return self.mesh.GetSubMeshElementsId(ShapeID)
1526
1527     ## Returns the list of submesh nodes IDs
1528     #  @param Shape a geom object(subshape) IOR
1529     #         Shape must be the subshape of a ShapeToMesh()
1530     #  @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes
1531     #  @return the list of integer values
1532     #  @ingroup l1_meshinfo
1533     def GetSubMeshNodesId(self, Shape, all):
1534         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1535             ShapeID = Shape.GetSubShapeIndices()[0]
1536         else:
1537             ShapeID = Shape
1538         return self.mesh.GetSubMeshNodesId(ShapeID, all)
1539
1540     ## Returns the list of IDs of submesh elements with the given type
1541     #  @param Shape a geom object(subshape) IOR
1542     #         Shape must be a subshape of a ShapeToMesh()
1543     #  @return the list of integer values
1544     #  @ingroup l1_meshinfo
1545     def GetSubMeshElementType(self, Shape):
1546         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1547             ShapeID = Shape.GetSubShapeIndices()[0]
1548         else:
1549             ShapeID = Shape
1550         return self.mesh.GetSubMeshElementType(ShapeID)
1551
1552     ## Gets the mesh description
1553     #  @return string value
1554     #  @ingroup l1_meshinfo
1555     def Dump(self):
1556         return self.mesh.Dump()
1557
1558
1559     # Get the information about nodes and elements of a mesh by its IDs:
1560     # -----------------------------------------------------------
1561
1562     ## Gets XYZ coordinates of a node
1563     #  \n If there is no nodes for the given ID - returns an empty list
1564     #  @return a list of double precision values
1565     #  @ingroup l1_meshinfo
1566     def GetNodeXYZ(self, id):
1567         return self.mesh.GetNodeXYZ(id)
1568
1569     ## Returns list of IDs of inverse elements for the given node
1570     #  \n If there is no node for the given ID - returns an empty list
1571     #  @return a list of integer values
1572     #  @ingroup l1_meshinfo
1573     def GetNodeInverseElements(self, id):
1574         return self.mesh.GetNodeInverseElements(id)
1575
1576     ## @brief Returns the position of a node on the shape
1577     #  @return SMESH::NodePosition
1578     #  @ingroup l1_meshinfo
1579     def GetNodePosition(self,NodeID):
1580         return self.mesh.GetNodePosition(NodeID)
1581
1582     ## If the given element is a node, returns the ID of shape
1583     #  \n If there is no node for the given ID - returns -1
1584     #  @return an integer value
1585     #  @ingroup l1_meshinfo
1586     def GetShapeID(self, id):
1587         return self.mesh.GetShapeID(id)
1588
1589     ## Returns the ID of the result shape after
1590     #  FindShape() from SMESH_MeshEditor for the given element
1591     #  \n If there is no element for the given ID - returns -1
1592     #  @return an integer value
1593     #  @ingroup l1_meshinfo
1594     def GetShapeIDForElem(self,id):
1595         return self.mesh.GetShapeIDForElem(id)
1596
1597     ## Returns the number of nodes for the given element
1598     #  \n If there is no element for the given ID - returns -1
1599     #  @return an integer value
1600     #  @ingroup l1_meshinfo
1601     def GetElemNbNodes(self, id):
1602         return self.mesh.GetElemNbNodes(id)
1603
1604     ## Returns the node ID the given index for the given element
1605     #  \n If there is no element for the given ID - returns -1
1606     #  \n If there is no node for the given index - returns -2
1607     #  @return an integer value
1608     #  @ingroup l1_meshinfo
1609     def GetElemNode(self, id, index):
1610         return self.mesh.GetElemNode(id, index)
1611
1612     ## Returns the IDs of nodes of the given element
1613     #  @return a list of integer values
1614     #  @ingroup l1_meshinfo
1615     def GetElemNodes(self, id):
1616         return self.mesh.GetElemNodes(id)
1617
1618     ## Returns true if the given node is the medium node in the given quadratic element
1619     #  @ingroup l1_meshinfo
1620     def IsMediumNode(self, elementID, nodeID):
1621         return self.mesh.IsMediumNode(elementID, nodeID)
1622
1623     ## Returns true if the given node is the medium node in one of quadratic elements
1624     #  @ingroup l1_meshinfo
1625     def IsMediumNodeOfAnyElem(self, nodeID, elementType):
1626         return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType)
1627
1628     ## Returns the number of edges for the given element
1629     #  @ingroup l1_meshinfo
1630     def ElemNbEdges(self, id):
1631         return self.mesh.ElemNbEdges(id)
1632
1633     ## Returns the number of faces for the given element
1634     #  @ingroup l1_meshinfo
1635     def ElemNbFaces(self, id):
1636         return self.mesh.ElemNbFaces(id)
1637
1638     ## Returns true if the given element is a polygon
1639     #  @ingroup l1_meshinfo
1640     def IsPoly(self, id):
1641         return self.mesh.IsPoly(id)
1642
1643     ## Returns true if the given element is quadratic
1644     #  @ingroup l1_meshinfo
1645     def IsQuadratic(self, id):
1646         return self.mesh.IsQuadratic(id)
1647
1648     ## Returns XYZ coordinates of the barycenter of the given element
1649     #  \n If there is no element for the given ID - returns an empty list
1650     #  @return a list of three double values
1651     #  @ingroup l1_meshinfo
1652     def BaryCenter(self, id):
1653         return self.mesh.BaryCenter(id)
1654
1655
1656     # Mesh edition (SMESH_MeshEditor functionality):
1657     # ---------------------------------------------
1658
1659     ## Removes the elements from the mesh by ids
1660     #  @param IDsOfElements is a list of ids of elements to remove
1661     #  @return True or False
1662     #  @ingroup l2_modif_del
1663     def RemoveElements(self, IDsOfElements):
1664         return self.editor.RemoveElements(IDsOfElements)
1665
1666     ## Removes nodes from mesh by ids
1667     #  @param IDsOfNodes is a list of ids of nodes to remove
1668     #  @return True or False
1669     #  @ingroup l2_modif_del
1670     def RemoveNodes(self, IDsOfNodes):
1671         return self.editor.RemoveNodes(IDsOfNodes)
1672
1673     ## Add a node to the mesh by coordinates
1674     #  @return Id of the new node
1675     #  @ingroup l2_modif_add
1676     def AddNode(self, x, y, z):
1677         return self.editor.AddNode( x, y, z)
1678
1679     ## Creates a linear or quadratic edge (this is determined
1680     #  by the number of given nodes).
1681     #  @param IDsOfNodes the list of node IDs for creation of the element.
1682     #  The order of nodes in this list should correspond to the description
1683     #  of MED. \n This description is located by the following link:
1684     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1685     #  @return the Id of the new edge
1686     #  @ingroup l2_modif_add
1687     def AddEdge(self, IDsOfNodes):
1688         return self.editor.AddEdge(IDsOfNodes)
1689
1690     ## Creates a linear or quadratic face (this is determined
1691     #  by the number of given nodes).
1692     #  @param IDsOfNodes the list of node IDs for creation of the element.
1693     #  The order of nodes in this list should correspond to the description
1694     #  of MED. \n This description is located by the following link:
1695     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1696     #  @return the Id of the new face
1697     #  @ingroup l2_modif_add
1698     def AddFace(self, IDsOfNodes):
1699         return self.editor.AddFace(IDsOfNodes)
1700
1701     ## Adds a polygonal face to the mesh by the list of node IDs
1702     #  @param IdsOfNodes the list of node IDs for creation of the element.
1703     #  @return the Id of the new face
1704     #  @ingroup l2_modif_add
1705     def AddPolygonalFace(self, IdsOfNodes):
1706         return self.editor.AddPolygonalFace(IdsOfNodes)
1707
1708     ## Creates both simple and quadratic volume (this is determined
1709     #  by the number of given nodes).
1710     #  @param IDsOfNodes the list of node IDs for creation of the element.
1711     #  The order of nodes in this list should correspond to the description
1712     #  of MED. \n This description is located by the following link:
1713     #  http://www.salome-platform.org/salome2/web_med_internet/logiciels/medV2.2.2_doc_html/html/modele_de_donnees.html#3.
1714     #  @return the Id of the new volumic element
1715     #  @ingroup l2_modif_add
1716     def AddVolume(self, IDsOfNodes):
1717         return self.editor.AddVolume(IDsOfNodes)
1718
1719     ## Creates a volume of many faces, giving nodes for each face.
1720     #  @param IdsOfNodes the list of node IDs for volume creation face by face.
1721     #  @param Quantities the list of integer values, Quantities[i]
1722     #         gives the quantity of nodes in face number i.
1723     #  @return the Id of the new volumic element
1724     #  @ingroup l2_modif_add
1725     def AddPolyhedralVolume (self, IdsOfNodes, Quantities):
1726         return self.editor.AddPolyhedralVolume(IdsOfNodes, Quantities)
1727
1728     ## Creates a volume of many faces, giving the IDs of the existing faces.
1729     #  @param IdsOfFaces the list of face IDs for volume creation.
1730     #
1731     #  Note:  The created volume will refer only to the nodes
1732     #         of the given faces, not to the faces themselves.
1733     #  @return the Id of the new volumic element
1734     #  @ingroup l2_modif_add
1735     def AddPolyhedralVolumeByFaces (self, IdsOfFaces):
1736         return self.editor.AddPolyhedralVolumeByFaces(IdsOfFaces)
1737
1738
1739     ## @brief Binds a node to a vertex
1740     #  @param NodeID a node ID
1741     #  @param Vertex a vertex or vertex ID
1742     #  @return True if succeed else raises an exception
1743     #  @ingroup l2_modif_add
1744     def SetNodeOnVertex(self, NodeID, Vertex):
1745         if ( isinstance( Vertex, geompyDC.GEOM._objref_GEOM_Object)):
1746             VertexID = Vertex.GetSubShapeIndices()[0]
1747         else:
1748             VertexID = Vertex
1749         try:
1750             self.editor.SetNodeOnVertex(NodeID, VertexID)
1751         except SALOME.SALOME_Exception, inst:
1752             raise ValueError, inst.details.text
1753         return True
1754
1755
1756     ## @brief Stores the node position on an edge
1757     #  @param NodeID a node ID
1758     #  @param Edge an edge or edge ID
1759     #  @param paramOnEdge a parameter on the edge where the node is located
1760     #  @return True if succeed else raises an exception
1761     #  @ingroup l2_modif_add
1762     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
1763         if ( isinstance( Edge, geompyDC.GEOM._objref_GEOM_Object)):
1764             EdgeID = Edge.GetSubShapeIndices()[0]
1765         else:
1766             EdgeID = Edge
1767         try:
1768             self.editor.SetNodeOnEdge(NodeID, EdgeID, paramOnEdge)
1769         except SALOME.SALOME_Exception, inst:
1770             raise ValueError, inst.details.text
1771         return True
1772
1773     ## @brief Stores node position on a face
1774     #  @param NodeID a node ID
1775     #  @param Face a face or face ID
1776     #  @param u U parameter on the face where the node is located
1777     #  @param v V parameter on the face where the node is located
1778     #  @return True if succeed else raises an exception
1779     #  @ingroup l2_modif_add
1780     def SetNodeOnFace(self, NodeID, Face, u, v):
1781         if ( isinstance( Face, geompyDC.GEOM._objref_GEOM_Object)):
1782             FaceID = Face.GetSubShapeIndices()[0]
1783         else:
1784             FaceID = Face
1785         try:
1786             self.editor.SetNodeOnFace(NodeID, FaceID, u, v)
1787         except SALOME.SALOME_Exception, inst:
1788             raise ValueError, inst.details.text
1789         return True
1790
1791     ## @brief Binds a node to a solid
1792     #  @param NodeID a node ID
1793     #  @param Solid  a solid or solid ID
1794     #  @return True if succeed else raises an exception
1795     #  @ingroup l2_modif_add
1796     def SetNodeInVolume(self, NodeID, Solid):
1797         if ( isinstance( Solid, geompyDC.GEOM._objref_GEOM_Object)):
1798             SolidID = Solid.GetSubShapeIndices()[0]
1799         else:
1800             SolidID = Solid
1801         try:
1802             self.editor.SetNodeInVolume(NodeID, SolidID)
1803         except SALOME.SALOME_Exception, inst:
1804             raise ValueError, inst.details.text
1805         return True
1806
1807     ## @brief Bind an element to a shape
1808     #  @param ElementID an element ID
1809     #  @param Shape a shape or shape ID
1810     #  @return True if succeed else raises an exception
1811     #  @ingroup l2_modif_add
1812     def SetMeshElementOnShape(self, ElementID, Shape):
1813         if ( isinstance( Shape, geompyDC.GEOM._objref_GEOM_Object)):
1814             ShapeID = Shape.GetSubShapeIndices()[0]
1815         else:
1816             ShapeID = Shape
1817         try:
1818             self.editor.SetMeshElementOnShape(ElementID, ShapeID)
1819         except SALOME.SALOME_Exception, inst:
1820             raise ValueError, inst.details.text
1821         return True
1822
1823
1824     ## Moves the node with the given id
1825     #  @param NodeID the id of the node
1826     #  @param x  a new X coordinate
1827     #  @param y  a new Y coordinate
1828     #  @param z  a new Z coordinate
1829     #  @return True if succeed else False
1830     #  @ingroup l2_modif_movenode
1831     def MoveNode(self, NodeID, x, y, z):
1832         return self.editor.MoveNode(NodeID, x, y, z)
1833
1834     ## Finds the node closest to a point
1835     #  @param x  the X coordinate of a point
1836     #  @param y  the Y coordinate of a point
1837     #  @param z  the Z coordinate of a point
1838     #  @return the ID of a node
1839     #  @ingroup l2_modif_throughp
1840     def FindNodeClosestTo(self, x, y, z):
1841         preview = self.mesh.GetMeshEditPreviewer()
1842         return preview.MoveClosestNodeToPoint(x, y, z, -1)
1843
1844     ## Finds the node closest to a point and moves it to a point location
1845     #  @param x  the X coordinate of a point
1846     #  @param y  the Y coordinate of a point
1847     #  @param z  the Z coordinate of a point
1848     #  @return the ID of a moved node
1849     #  @ingroup l2_modif_throughp
1850     def MeshToPassThroughAPoint(self, x, y, z):
1851         return self.editor.MoveClosestNodeToPoint(x, y, z, -1)
1852
1853     ## Replaces two neighbour triangles sharing Node1-Node2 link
1854     #  with the triangles built on the same 4 nodes but having other common link.
1855     #  @param NodeID1  the ID of the first node
1856     #  @param NodeID2  the ID of the second node
1857     #  @return false if proper faces were not found
1858     #  @ingroup l2_modif_invdiag
1859     def InverseDiag(self, NodeID1, NodeID2):
1860         return self.editor.InverseDiag(NodeID1, NodeID2)
1861
1862     ## Replaces two neighbour triangles sharing Node1-Node2 link
1863     #  with a quadrangle built on the same 4 nodes.
1864     #  @param NodeID1  the ID of the first node
1865     #  @param NodeID2  the ID of the second node
1866     #  @return false if proper faces were not found
1867     #  @ingroup l2_modif_unitetri
1868     def DeleteDiag(self, NodeID1, NodeID2):
1869         return self.editor.DeleteDiag(NodeID1, NodeID2)
1870
1871     ## Reorients elements by ids
1872     #  @param IDsOfElements if undefined reorients all mesh elements
1873     #  @return True if succeed else False
1874     #  @ingroup l2_modif_changori
1875     def Reorient(self, IDsOfElements=None):
1876         if IDsOfElements == None:
1877             IDsOfElements = self.GetElementsId()
1878         return self.editor.Reorient(IDsOfElements)
1879
1880     ## Reorients all elements of the object
1881     #  @param theObject mesh, submesh or group
1882     #  @return True if succeed else False
1883     #  @ingroup l2_modif_changori
1884     def ReorientObject(self, theObject):
1885         if ( isinstance( theObject, Mesh )):
1886             theObject = theObject.GetMesh()
1887         return self.editor.ReorientObject(theObject)
1888
1889     ## Fuses the neighbouring triangles into quadrangles.
1890     #  @param IDsOfElements The triangles to be fused,
1891     #  @param theCriterion  is FT_...; used to choose a neighbour to fuse with.
1892     #  @param MaxAngle      is the maximum angle between element normals at which the fusion
1893     #                       is still performed; theMaxAngle is mesured in radians.
1894     #  @return TRUE in case of success, FALSE otherwise.
1895     #  @ingroup l2_modif_unitetri
1896     def TriToQuad(self, IDsOfElements, theCriterion, MaxAngle):
1897         if IDsOfElements == []:
1898             IDsOfElements = self.GetElementsId()
1899         return self.editor.TriToQuad(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion), MaxAngle)
1900
1901     ## Fuses the neighbouring triangles of the object into quadrangles
1902     #  @param theObject is mesh, submesh or group
1903     #  @param theCriterion is FT_...; used to choose a neighbour to fuse with.
1904     #  @param MaxAngle   a max angle between element normals at which the fusion
1905     #                   is still performed; theMaxAngle is mesured in radians.
1906     #  @return TRUE in case of success, FALSE otherwise.
1907     #  @ingroup l2_modif_unitetri
1908     def TriToQuadObject (self, theObject, theCriterion, MaxAngle):
1909         if ( isinstance( theObject, Mesh )):
1910             theObject = theObject.GetMesh()
1911         return self.editor.TriToQuadObject(theObject, self.smeshpyD.GetFunctor(theCriterion), MaxAngle)
1912
1913     ## Splits quadrangles into triangles.
1914     #  @param IDsOfElements the faces to be splitted.
1915     #  @param theCriterion   FT_...; used to choose a diagonal for splitting.
1916     #  @return TRUE in case of success, FALSE otherwise.
1917     #  @ingroup l2_modif_cutquadr
1918     def QuadToTri (self, IDsOfElements, theCriterion):
1919         if IDsOfElements == []:
1920             IDsOfElements = self.GetElementsId()
1921         return self.editor.QuadToTri(IDsOfElements, self.smeshpyD.GetFunctor(theCriterion))
1922
1923     ## Splits quadrangles into triangles.
1924     #  @param theObject  the object from which the list of elements is taken, this is mesh, submesh or group
1925     #  @param theCriterion   FT_...; used to choose a diagonal for splitting.
1926     #  @return TRUE in case of success, FALSE otherwise.
1927     #  @ingroup l2_modif_cutquadr
1928     def QuadToTriObject (self, theObject, theCriterion):
1929         if ( isinstance( theObject, Mesh )):
1930             theObject = theObject.GetMesh()
1931         return self.editor.QuadToTriObject(theObject, self.smeshpyD.GetFunctor(theCriterion))
1932
1933     ## Splits quadrangles into triangles.
1934     #  @param IDsOfElements the faces to be splitted
1935     #  @param Diag13        is used to choose a diagonal for splitting.
1936     #  @return TRUE in case of success, FALSE otherwise.
1937     #  @ingroup l2_modif_cutquadr
1938     def SplitQuad (self, IDsOfElements, Diag13):
1939         if IDsOfElements == []:
1940             IDsOfElements = self.GetElementsId()
1941         return self.editor.SplitQuad(IDsOfElements, Diag13)
1942
1943     ## Splits quadrangles into triangles.
1944     #  @param theObject the object from which the list of elements is taken, this is mesh, submesh or group
1945     #  @param Diag13    is used to choose a diagonal for splitting.
1946     #  @return TRUE in case of success, FALSE otherwise.
1947     #  @ingroup l2_modif_cutquadr
1948     def SplitQuadObject (self, theObject, Diag13):
1949         if ( isinstance( theObject, Mesh )):
1950             theObject = theObject.GetMesh()
1951         return self.editor.SplitQuadObject(theObject, Diag13)
1952
1953     ## Finds a better splitting of the given quadrangle.
1954     #  @param IDOfQuad   the ID of the quadrangle to be splitted.
1955     #  @param theCriterion  FT_...; a criterion to choose a diagonal for splitting.
1956     #  @return 1 if 1-3 diagonal is better, 2 if 2-4
1957     #          diagonal is better, 0 if error occurs.
1958     #  @ingroup l2_modif_cutquadr
1959     def BestSplit (self, IDOfQuad, theCriterion):
1960         return self.editor.BestSplit(IDOfQuad, self.smeshpyD.GetFunctor(theCriterion))
1961
1962     ## Splits quadrangle faces near triangular facets of volumes
1963     #
1964     #  @ingroup l1_auxiliary
1965     def SplitQuadsNearTriangularFacets(self):
1966         faces_array = self.GetElementsByType(SMESH.FACE)
1967         for face_id in faces_array:
1968             if self.GetElemNbNodes(face_id) == 4: # quadrangle
1969                 quad_nodes = self.mesh.GetElemNodes(face_id)
1970                 node1_elems = self.GetNodeInverseElements(quad_nodes[1 -1])
1971                 isVolumeFound = False
1972                 for node1_elem in node1_elems:
1973                     if not isVolumeFound:
1974                         if self.GetElementType(node1_elem, True) == SMESH.VOLUME:
1975                             nb_nodes = self.GetElemNbNodes(node1_elem)
1976                             if 3 < nb_nodes and nb_nodes < 7: # tetra or penta, or prism
1977                                 volume_elem = node1_elem
1978                                 volume_nodes = self.mesh.GetElemNodes(volume_elem)
1979                                 if volume_nodes.count(quad_nodes[2 -1]) > 0: # 1,2
1980                                     if volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,2,4
1981                                         isVolumeFound = True
1982                                         if volume_nodes.count(quad_nodes[3 -1]) == 0: # 1,2,4 & !3
1983                                             self.SplitQuad([face_id], False) # diagonal 2-4
1984                                     elif volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,2,3 & !4
1985                                         isVolumeFound = True
1986                                         self.SplitQuad([face_id], True) # diagonal 1-3
1987                                 elif volume_nodes.count(quad_nodes[4 -1]) > 0: # 1,4 & !2
1988                                     if volume_nodes.count(quad_nodes[3 -1]) > 0: # 1,4,3 & !2
1989                                         isVolumeFound = True
1990                                         self.SplitQuad([face_id], True) # diagonal 1-3
1991
1992     ## @brief Splits hexahedrons into tetrahedrons.
1993     #
1994     #  This operation uses pattern mapping functionality for splitting.
1995     #  @param theObject the object from which the list of hexahedrons is taken; this is mesh, submesh or group.
1996     #  @param theNode000,theNode001 within the range [0,7]; gives the orientation of the
1997     #         pattern relatively each hexahedron: the (0,0,0) key-point of the pattern
1998     #         will be mapped into <VAR>theNode000</VAR>-th node of each volume, the (0,0,1)
1999     #         key-point will be mapped into <VAR>theNode001</VAR>-th node of each volume.
2000     #         The (0,0,0) key-point of the used pattern corresponds to a non-split corner.
2001     #  @return TRUE in case of success, FALSE otherwise.
2002     #  @ingroup l1_auxiliary
2003     def SplitHexaToTetras (self, theObject, theNode000, theNode001):
2004         # Pattern:     5.---------.6
2005         #              /|#*      /|
2006         #             / | #*    / |
2007         #            /  |  # * /  |
2008         #           /   |   # /*  |
2009         # (0,0,1) 4.---------.7 * |
2010         #          |#*  |1   | # *|
2011         #          | # *.----|---#.2
2012         #          |  #/ *   |   /
2013         #          |  /#  *  |  /
2014         #          | /   # * | /
2015         #          |/      #*|/
2016         # (0,0,0) 0.---------.3
2017         pattern_tetra = "!!! Nb of points: \n 8 \n\
2018         !!! Points: \n\
2019         0 0 0  !- 0 \n\
2020         0 1 0  !- 1 \n\
2021         1 1 0  !- 2 \n\
2022         1 0 0  !- 3 \n\
2023         0 0 1  !- 4 \n\
2024         0 1 1  !- 5 \n\
2025         1 1 1  !- 6 \n\
2026         1 0 1  !- 7 \n\
2027         !!! Indices of points of 6 tetras: \n\
2028         0 3 4 1 \n\
2029         7 4 3 1 \n\
2030         4 7 5 1 \n\
2031         6 2 5 7 \n\
2032         1 5 2 7 \n\
2033         2 3 1 7 \n"
2034
2035         pattern = self.smeshpyD.GetPattern()
2036         isDone  = pattern.LoadFromFile(pattern_tetra)
2037         if not isDone:
2038             print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
2039             return isDone
2040
2041         pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
2042         isDone = pattern.MakeMesh(self.mesh, False, False)
2043         if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
2044
2045         # split quafrangle faces near triangular facets of volumes
2046         self.SplitQuadsNearTriangularFacets()
2047
2048         return isDone
2049
2050     ## @brief Split hexahedrons into prisms.
2051     #
2052     #  Uses the pattern mapping functionality for splitting.
2053     #  @param theObject the object (mesh, submesh or group) from where the list of hexahedrons is taken;
2054     #  @param theNode000,theNode001 (within the range [0,7]) gives the orientation of the
2055     #         pattern relatively each hexahedron: keypoint (0,0,0) of the pattern
2056     #         will be mapped into the <VAR>theNode000</VAR>-th node of each volume, keypoint (0,0,1)
2057     #         will be mapped into the <VAR>theNode001</VAR>-th node of each volume.
2058     #         Edge (0,0,0)-(0,0,1) of used pattern connects two not split corners.
2059     #  @return TRUE in case of success, FALSE otherwise.
2060     #  @ingroup l1_auxiliary
2061     def SplitHexaToPrisms (self, theObject, theNode000, theNode001):
2062         # Pattern:     5.---------.6
2063         #              /|#       /|
2064         #             / | #     / |
2065         #            /  |  #   /  |
2066         #           /   |   # /   |
2067         # (0,0,1) 4.---------.7   |
2068         #          |    |    |    |
2069         #          |   1.----|----.2
2070         #          |   / *   |   /
2071         #          |  /   *  |  /
2072         #          | /     * | /
2073         #          |/       *|/
2074         # (0,0,0) 0.---------.3
2075         pattern_prism = "!!! Nb of points: \n 8 \n\
2076         !!! Points: \n\
2077         0 0 0  !- 0 \n\
2078         0 1 0  !- 1 \n\
2079         1 1 0  !- 2 \n\
2080         1 0 0  !- 3 \n\
2081         0 0 1  !- 4 \n\
2082         0 1 1  !- 5 \n\
2083         1 1 1  !- 6 \n\
2084         1 0 1  !- 7 \n\
2085         !!! Indices of points of 2 prisms: \n\
2086         0 1 3 4 5 7 \n\
2087         2 3 1 6 7 5 \n"
2088
2089         pattern = self.smeshpyD.GetPattern()
2090         isDone  = pattern.LoadFromFile(pattern_prism)
2091         if not isDone:
2092             print 'Pattern.LoadFromFile :', pattern.GetErrorCode()
2093             return isDone
2094
2095         pattern.ApplyToHexahedrons(self.mesh, theObject.GetIDs(), theNode000, theNode001)
2096         isDone = pattern.MakeMesh(self.mesh, False, False)
2097         if not isDone: print 'Pattern.MakeMesh :', pattern.GetErrorCode()
2098
2099         # Splits quafrangle faces near triangular facets of volumes
2100         self.SplitQuadsNearTriangularFacets()
2101
2102         return isDone
2103
2104     ## Smoothes elements
2105     #  @param IDsOfElements the list if ids of elements to smooth
2106     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2107     #  Note that nodes built on edges and boundary nodes are always fixed.
2108     #  @param MaxNbOfIterations the maximum number of iterations
2109     #  @param MaxAspectRatio varies in range [1.0, inf]
2110     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2111     #  @return TRUE in case of success, FALSE otherwise.
2112     #  @ingroup l2_modif_smooth
2113     def Smooth(self, IDsOfElements, IDsOfFixedNodes,
2114                MaxNbOfIterations, MaxAspectRatio, Method):
2115         if IDsOfElements == []:
2116             IDsOfElements = self.GetElementsId()
2117         return self.editor.Smooth(IDsOfElements, IDsOfFixedNodes,
2118                                   MaxNbOfIterations, MaxAspectRatio, Method)
2119
2120     ## Smoothes elements which belong to the given object
2121     #  @param theObject the object to smooth
2122     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2123     #  Note that nodes built on edges and boundary nodes are always fixed.
2124     #  @param MaxNbOfIterations the maximum number of iterations
2125     #  @param MaxAspectRatio varies in range [1.0, inf]
2126     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2127     #  @return TRUE in case of success, FALSE otherwise.
2128     #  @ingroup l2_modif_smooth
2129     def SmoothObject(self, theObject, IDsOfFixedNodes,
2130                      MaxNbOfIterations, MaxAspectRatio, Method):
2131         if ( isinstance( theObject, Mesh )):
2132             theObject = theObject.GetMesh()
2133         return self.editor.SmoothObject(theObject, IDsOfFixedNodes,
2134                                         MaxNbOfIterations, MaxAspectRatio, Method)
2135
2136     ## Parametrically smoothes the given elements
2137     #  @param IDsOfElements the list if ids of elements to smooth
2138     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2139     #  Note that nodes built on edges and boundary nodes are always fixed.
2140     #  @param MaxNbOfIterations the maximum number of iterations
2141     #  @param MaxAspectRatio varies in range [1.0, inf]
2142     #  @param Method is Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2143     #  @return TRUE in case of success, FALSE otherwise.
2144     #  @ingroup l2_modif_smooth
2145     def SmoothParametric(self, IDsOfElements, IDsOfFixedNodes,
2146                          MaxNbOfIterations, MaxAspectRatio, Method):
2147         if IDsOfElements == []:
2148             IDsOfElements = self.GetElementsId()
2149         return self.editor.SmoothParametric(IDsOfElements, IDsOfFixedNodes,
2150                                             MaxNbOfIterations, MaxAspectRatio, Method)
2151
2152     ## Parametrically smoothes the elements which belong to the given object
2153     #  @param theObject the object to smooth
2154     #  @param IDsOfFixedNodes the list of ids of fixed nodes.
2155     #  Note that nodes built on edges and boundary nodes are always fixed.
2156     #  @param MaxNbOfIterations the maximum number of iterations
2157     #  @param MaxAspectRatio varies in range [1.0, inf]
2158     #  @param Method Laplacian(LAPLACIAN_SMOOTH) or Centroidal(CENTROIDAL_SMOOTH)
2159     #  @return TRUE in case of success, FALSE otherwise.
2160     #  @ingroup l2_modif_smooth
2161     def SmoothParametricObject(self, theObject, IDsOfFixedNodes,
2162                                MaxNbOfIterations, MaxAspectRatio, Method):
2163         if ( isinstance( theObject, Mesh )):
2164             theObject = theObject.GetMesh()
2165         return self.editor.SmoothParametricObject(theObject, IDsOfFixedNodes,
2166                                                   MaxNbOfIterations, MaxAspectRatio, Method)
2167
2168     ## Converts the mesh to quadratic, deletes old elements, replacing
2169     #  them with quadratic with the same id.
2170     #  @ingroup l2_modif_tofromqu
2171     def ConvertToQuadratic(self, theForce3d):
2172         self.editor.ConvertToQuadratic(theForce3d)
2173
2174     ## Converts the mesh from quadratic to ordinary,
2175     #  deletes old quadratic elements, \n replacing
2176     #  them with ordinary mesh elements with the same id.
2177     #  @return TRUE in case of success, FALSE otherwise.
2178     #  @ingroup l2_modif_tofromqu
2179     def ConvertFromQuadratic(self):
2180         return self.editor.ConvertFromQuadratic()
2181
2182     ## Renumber mesh nodes
2183     #  @ingroup l2_modif_renumber
2184     def RenumberNodes(self):
2185         self.editor.RenumberNodes()
2186
2187     ## Renumber mesh elements
2188     #  @ingroup l2_modif_renumber
2189     def RenumberElements(self):
2190         self.editor.RenumberElements()
2191
2192     ## Generates new elements by rotation of the elements around the axis
2193     #  @param IDsOfElements the list of ids of elements to sweep
2194     #  @param Axis the axis of rotation, AxisStruct or line(geom object)
2195     #  @param AngleInRadians the angle of Rotation
2196     #  @param NbOfSteps the number of steps
2197     #  @param Tolerance tolerance
2198     #  @param MakeGroups forces the generation of new groups from existing ones
2199     #  @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
2200     #                    of all steps, else - size of each step
2201     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2202     #  @ingroup l2_modif_extrurev
2203     def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance,
2204                       MakeGroups=False, TotalAngle=False):
2205         if IDsOfElements == []:
2206             IDsOfElements = self.GetElementsId()
2207         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2208             Axis = self.smeshpyD.GetAxisStruct(Axis)
2209         if TotalAngle and NbOfSteps:
2210             AngleInRadians /= NbOfSteps
2211         if MakeGroups:
2212             return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis,
2213                                                        AngleInRadians, NbOfSteps, Tolerance)
2214         self.editor.RotationSweep(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance)
2215         return []
2216
2217     ## Generates new elements by rotation of the elements of object around the axis
2218     #  @param theObject object which elements should be sweeped
2219     #  @param Axis the axis of rotation, AxisStruct or line(geom object)
2220     #  @param AngleInRadians the angle of Rotation
2221     #  @param NbOfSteps number of steps
2222     #  @param Tolerance tolerance
2223     #  @param MakeGroups forces the generation of new groups from existing ones
2224     #  @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size
2225     #                    of all steps, else - size of each step
2226     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2227     #  @ingroup l2_modif_extrurev
2228     def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance,
2229                             MakeGroups=False, TotalAngle=False):
2230         if ( isinstance( theObject, Mesh )):
2231             theObject = theObject.GetMesh()
2232         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2233             Axis = self.smeshpyD.GetAxisStruct(Axis)
2234         if TotalAngle and NbOfSteps:
2235             AngleInRadians /= NbOfSteps
2236         if MakeGroups:
2237             return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians,
2238                                                              NbOfSteps, Tolerance)
2239         self.editor.RotationSweepObject(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance)
2240         return []
2241
2242     ## Generates new elements by extrusion of the elements with given ids
2243     #  @param IDsOfElements the list of elements ids for extrusion
2244     #  @param StepVector vector, defining the direction and value of extrusion
2245     #  @param NbOfSteps the number of steps
2246     #  @param MakeGroups forces the generation of new groups from existing ones
2247     #  @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2248     #  @ingroup l2_modif_extrurev
2249     def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False):
2250         if IDsOfElements == []:
2251             IDsOfElements = self.GetElementsId()
2252         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2253             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2254         if MakeGroups:
2255             return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
2256         self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
2257         return []
2258
2259     ## Generates new elements by extrusion of the elements with given ids
2260     #  @param IDsOfElements is ids of elements
2261     #  @param StepVector vector, defining the direction and value of extrusion
2262     #  @param NbOfSteps the number of steps
2263     #  @param ExtrFlags sets flags for extrusion
2264     #  @param SewTolerance uses for comparing locations of nodes if flag
2265     #         EXTRUSION_FLAG_SEW is set
2266     #  @param MakeGroups forces the generation of new groups from existing ones
2267     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2268     #  @ingroup l2_modif_extrurev
2269     def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps,
2270                           ExtrFlags, SewTolerance, MakeGroups=False):
2271         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2272             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2273         if MakeGroups:
2274             return self.editor.AdvancedExtrusionMakeGroups(IDsOfElements, StepVector, NbOfSteps,
2275                                                            ExtrFlags, SewTolerance)
2276         self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps,
2277                                       ExtrFlags, SewTolerance)
2278         return []
2279
2280     ## Generates new elements by extrusion of the elements which belong to the object
2281     #  @param theObject the object which elements should be processed
2282     #  @param StepVector vector, defining the direction and value of extrusion
2283     #  @param NbOfSteps the number of steps
2284     #  @param MakeGroups forces the generation of new groups from existing ones
2285     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2286     #  @ingroup l2_modif_extrurev
2287     def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2288         if ( isinstance( theObject, Mesh )):
2289             theObject = theObject.GetMesh()
2290         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2291             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2292         if MakeGroups:
2293             return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps)
2294         self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)
2295         return []
2296
2297     ## Generates new elements by extrusion of the elements which belong to the object
2298     #  @param theObject object which elements should be processed
2299     #  @param StepVector vector, defining the direction and value of extrusion
2300     #  @param NbOfSteps the number of steps
2301     #  @param MakeGroups to generate new groups from existing ones
2302     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2303     #  @ingroup l2_modif_extrurev
2304     def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2305         if ( isinstance( theObject, Mesh )):
2306             theObject = theObject.GetMesh()
2307         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2308             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2309         if MakeGroups:
2310             return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps)
2311         self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps)
2312         return []
2313
2314     ## Generates new elements by extrusion of the elements which belong to the object
2315     #  @param theObject object which elements should be processed
2316     #  @param StepVector vector, defining the direction and value of extrusion
2317     #  @param NbOfSteps the number of steps
2318     #  @param MakeGroups forces the generation of new groups from existing ones
2319     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2320     #  @ingroup l2_modif_extrurev
2321     def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps, MakeGroups=False):
2322         if ( isinstance( theObject, Mesh )):
2323             theObject = theObject.GetMesh()
2324         if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
2325             StepVector = self.smeshpyD.GetDirStruct(StepVector)
2326         if MakeGroups:
2327             return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps)
2328         self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps)
2329         return []
2330
2331     ## Generates new elements by extrusion of the given elements
2332     #  The path of extrusion must be a meshed edge.
2333     #  @param IDsOfElements ids of elements
2334     #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion
2335     #  @param PathShape shape(edge) defines the sub-mesh for the path
2336     #  @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
2337     #  @param HasAngles allows the shape to be rotated around the path
2338     #                   to get the resulting mesh in a helical fashion
2339     #  @param Angles list of angles
2340     #  @param HasRefPoint allows using the reference point
2341     #  @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
2342     #         The User can specify any point as the Reference Point.
2343     #  @param MakeGroups forces the generation of new groups from existing ones
2344     #  @param LinearVariation forces the computation of rotation angles as linear
2345     #                         variation of the given Angles along path steps
2346     #  @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
2347     #          only SMESH::Extrusion_Error otherwise
2348     #  @ingroup l2_modif_extrurev
2349     def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart,
2350                            HasAngles, Angles, HasRefPoint, RefPoint,
2351                            MakeGroups=False, LinearVariation=False):
2352         if IDsOfElements == []:
2353             IDsOfElements = self.GetElementsId()
2354         if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)):
2355             RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
2356             pass
2357         if ( isinstance( PathMesh, Mesh )):
2358             PathMesh = PathMesh.GetMesh()
2359         if HasAngles and Angles and LinearVariation:
2360             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
2361             pass
2362         if MakeGroups:
2363             return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh,
2364                                                             PathShape, NodeStart, HasAngles,
2365                                                             Angles, HasRefPoint, RefPoint)
2366         return self.editor.ExtrusionAlongPath(IDsOfElements, PathMesh, PathShape,
2367                                               NodeStart, HasAngles, Angles, HasRefPoint, RefPoint)
2368
2369     ## Generates new elements by extrusion of the elements which belong to the object
2370     #  The path of extrusion must be a meshed edge.
2371     #  @param theObject the object which elements should be processed
2372     #  @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds
2373     #  @param PathShape shape(edge) defines the sub-mesh for the path
2374     #  @param NodeStart the first or the last node on the edge. Defines the direction of extrusion
2375     #  @param HasAngles allows the shape to be rotated around the path
2376     #                   to get the resulting mesh in a helical fashion
2377     #  @param Angles list of angles
2378     #  @param HasRefPoint allows using the reference point
2379     #  @param RefPoint the point around which the shape is rotated (the mass center of the shape by default).
2380     #         The User can specify any point as the Reference Point.
2381     #  @param MakeGroups forces the generation of new groups from existing ones
2382     #  @param LinearVariation forces the computation of rotation angles as linear
2383     #                         variation of the given Angles along path steps
2384     #  @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error if MakeGroups=True,
2385     #          only SMESH::Extrusion_Error otherwise
2386     #  @ingroup l2_modif_extrurev
2387     def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart,
2388                                  HasAngles, Angles, HasRefPoint, RefPoint,
2389                                  MakeGroups=False, LinearVariation=False):
2390         if ( isinstance( theObject, Mesh )):
2391             theObject = theObject.GetMesh()
2392         if ( isinstance( RefPoint, geompyDC.GEOM._objref_GEOM_Object)):
2393             RefPoint = self.smeshpyD.GetPointStruct(RefPoint)
2394         if ( isinstance( PathMesh, Mesh )):
2395             PathMesh = PathMesh.GetMesh()
2396         if HasAngles and Angles and LinearVariation:
2397             Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles )
2398             pass
2399         if MakeGroups:
2400             return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh,
2401                                                                   PathShape, NodeStart, HasAngles,
2402                                                                   Angles, HasRefPoint, RefPoint)
2403         return self.editor.ExtrusionAlongPathObject(theObject, PathMesh, PathShape,
2404                                                     NodeStart, HasAngles, Angles, HasRefPoint,
2405                                                     RefPoint)
2406
2407     ## Creates a symmetrical copy of mesh elements
2408     #  @param IDsOfElements list of elements ids
2409     #  @param Mirror is AxisStruct or geom object(point, line, plane)
2410     #  @param theMirrorType is  POINT, AXIS or PLANE
2411     #  If the Mirror is a geom object this parameter is unnecessary
2412     #  @param Copy allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0)
2413     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2414     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2415     #  @ingroup l2_modif_trsf
2416     def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False):
2417         if IDsOfElements == []:
2418             IDsOfElements = self.GetElementsId()
2419         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2420             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2421         if Copy and MakeGroups:
2422             return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType)
2423         self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy)
2424         return []
2425
2426     ## Creates a new mesh by a symmetrical copy of mesh elements
2427     #  @param IDsOfElements the list of elements ids
2428     #  @param Mirror is AxisStruct or geom object (point, line, plane)
2429     #  @param theMirrorType is  POINT, AXIS or PLANE
2430     #  If the Mirror is a geom object this parameter is unnecessary
2431     #  @param MakeGroups to generate new groups from existing ones
2432     #  @param NewMeshName a name of the new mesh to create
2433     #  @return instance of Mesh class
2434     #  @ingroup l2_modif_trsf
2435     def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""):
2436         if IDsOfElements == []:
2437             IDsOfElements = self.GetElementsId()
2438         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2439             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2440         mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType,
2441                                           MakeGroups, NewMeshName)
2442         return Mesh(self.smeshpyD,self.geompyD,mesh)
2443
2444     ## Creates a symmetrical copy of the object
2445     #  @param theObject mesh, submesh or group
2446     #  @param Mirror AxisStruct or geom object (point, line, plane)
2447     #  @param theMirrorType is  POINT, AXIS or PLANE
2448     #  If the Mirror is a geom object this parameter is unnecessary
2449     #  @param Copy allows copying the element (Copy is 1) or replacing it with its mirror (Copy is 0)
2450     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2451     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2452     #  @ingroup l2_modif_trsf
2453     def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False):
2454         if ( isinstance( theObject, Mesh )):
2455             theObject = theObject.GetMesh()
2456         if ( isinstance( Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2457             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2458         if Copy and MakeGroups:
2459             return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType)
2460         self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy)
2461         return []
2462
2463     ## Creates a new mesh by a symmetrical copy of the object
2464     #  @param theObject mesh, submesh or group
2465     #  @param Mirror AxisStruct or geom object (point, line, plane)
2466     #  @param theMirrorType POINT, AXIS or PLANE
2467     #  If the Mirror is a geom object this parameter is unnecessary
2468     #  @param MakeGroups forces the generation of new groups from existing ones
2469     #  @param NewMeshName the name of the new mesh to create
2470     #  @return instance of Mesh class
2471     #  @ingroup l2_modif_trsf
2472     def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""):
2473         if ( isinstance( theObject, Mesh )):
2474             theObject = theObject.GetMesh()
2475         if (isinstance(Mirror, geompyDC.GEOM._objref_GEOM_Object)):
2476             Mirror = self.smeshpyD.GetAxisStruct(Mirror)
2477         mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType,
2478                                                 MakeGroups, NewMeshName)
2479         return Mesh( self.smeshpyD,self.geompyD,mesh )
2480
2481     ## Translates the elements
2482     #  @param IDsOfElements list of elements ids
2483     #  @param Vector the direction of translation (DirStruct or vector)
2484     #  @param Copy allows copying the translated elements
2485     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2486     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2487     #  @ingroup l2_modif_trsf
2488     def Translate(self, IDsOfElements, Vector, Copy, MakeGroups=False):
2489         if IDsOfElements == []:
2490             IDsOfElements = self.GetElementsId()
2491         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2492             Vector = self.smeshpyD.GetDirStruct(Vector)
2493         if Copy and MakeGroups:
2494             return self.editor.TranslateMakeGroups(IDsOfElements, Vector)
2495         self.editor.Translate(IDsOfElements, Vector, Copy)
2496         return []
2497
2498     ## Creates a new mesh of translated elements
2499     #  @param IDsOfElements list of elements ids
2500     #  @param Vector the direction of translation (DirStruct or vector)
2501     #  @param MakeGroups forces the generation of new groups from existing ones
2502     #  @param NewMeshName the name of the newly created mesh
2503     #  @return instance of Mesh class
2504     #  @ingroup l2_modif_trsf
2505     def TranslateMakeMesh(self, IDsOfElements, Vector, MakeGroups=False, NewMeshName=""):
2506         if IDsOfElements == []:
2507             IDsOfElements = self.GetElementsId()
2508         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2509             Vector = self.smeshpyD.GetDirStruct(Vector)
2510         mesh = self.editor.TranslateMakeMesh(IDsOfElements, Vector, MakeGroups, NewMeshName)
2511         return Mesh ( self.smeshpyD, self.geompyD, mesh )
2512
2513     ## Translates the object
2514     #  @param theObject the object to translate (mesh, submesh, or group)
2515     #  @param Vector direction of translation (DirStruct or geom vector)
2516     #  @param Copy allows copying the translated elements
2517     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2518     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2519     #  @ingroup l2_modif_trsf
2520     def TranslateObject(self, theObject, Vector, Copy, MakeGroups=False):
2521         if ( isinstance( theObject, Mesh )):
2522             theObject = theObject.GetMesh()
2523         if ( isinstance( Vector, geompyDC.GEOM._objref_GEOM_Object)):
2524             Vector = self.smeshpyD.GetDirStruct(Vector)
2525         if Copy and MakeGroups:
2526             return self.editor.TranslateObjectMakeGroups(theObject, Vector)
2527         self.editor.TranslateObject(theObject, Vector, Copy)
2528         return []
2529
2530     ## Creates a new mesh from the translated object
2531     #  @param theObject the object to translate (mesh, submesh, or group)
2532     #  @param Vector the direction of translation (DirStruct or geom vector)
2533     #  @param MakeGroups forces the generation of new groups from existing ones
2534     #  @param NewMeshName the name of the newly created mesh
2535     #  @return instance of Mesh class
2536     #  @ingroup l2_modif_trsf
2537     def TranslateObjectMakeMesh(self, theObject, Vector, MakeGroups=False, NewMeshName=""):
2538         if (isinstance(theObject, Mesh)):
2539             theObject = theObject.GetMesh()
2540         if (isinstance(Vector, geompyDC.GEOM._objref_GEOM_Object)):
2541             Vector = self.smeshpyD.GetDirStruct(Vector)
2542         mesh = self.editor.TranslateObjectMakeMesh(theObject, Vector, MakeGroups, NewMeshName)
2543         return Mesh( self.smeshpyD, self.geompyD, mesh )
2544
2545     ## Rotates the elements
2546     #  @param IDsOfElements list of elements ids
2547     #  @param Axis the axis of rotation (AxisStruct or geom line)
2548     #  @param AngleInRadians the angle of rotation (in radians)
2549     #  @param Copy allows copying the rotated elements
2550     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2551     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2552     #  @ingroup l2_modif_trsf
2553     def Rotate (self, IDsOfElements, Axis, AngleInRadians, Copy, MakeGroups=False):
2554         if IDsOfElements == []:
2555             IDsOfElements = self.GetElementsId()
2556         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2557             Axis = self.smeshpyD.GetAxisStruct(Axis)
2558         if Copy and MakeGroups:
2559             return self.editor.RotateMakeGroups(IDsOfElements, Axis, AngleInRadians)
2560         self.editor.Rotate(IDsOfElements, Axis, AngleInRadians, Copy)
2561         return []
2562
2563     ## Creates a new mesh of rotated elements
2564     #  @param IDsOfElements list of element ids
2565     #  @param Axis the axis of rotation (AxisStruct or geom line)
2566     #  @param AngleInRadians the angle of rotation (in radians)
2567     #  @param MakeGroups forces the generation of new groups from existing ones
2568     #  @param NewMeshName the name of the newly created mesh
2569     #  @return instance of Mesh class
2570     #  @ingroup l2_modif_trsf
2571     def RotateMakeMesh (self, IDsOfElements, Axis, AngleInRadians, MakeGroups=0, NewMeshName=""):
2572         if IDsOfElements == []:
2573             IDsOfElements = self.GetElementsId()
2574         if ( isinstance( Axis, geompyDC.GEOM._objref_GEOM_Object)):
2575             Axis = self.smeshpyD.GetAxisStruct(Axis)
2576         mesh = self.editor.RotateMakeMesh(IDsOfElements, Axis, AngleInRadians,
2577                                           MakeGroups, NewMeshName)
2578         return Mesh( self.smeshpyD, self.geompyD, mesh )
2579
2580     ## Rotates the object
2581     #  @param theObject the object to rotate( mesh, submesh, or group)
2582     #  @param Axis the axis of rotation (AxisStruct or geom line)
2583     #  @param AngleInRadians the angle of rotation (in radians)
2584     #  @param Copy allows copying the rotated elements
2585     #  @param MakeGroups forces the generation of new groups from existing ones (if Copy)
2586     #  @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise
2587     #  @ingroup l2_modif_trsf
2588     def RotateObject (self, theObject, Axis, AngleInRadians, Copy, MakeGroups=False):
2589         if (isinstance(theObject, Mesh)):
2590             theObject = theObject.GetMesh()
2591         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
2592             Axis = self.smeshpyD.GetAxisStruct(Axis)
2593         if Copy and MakeGroups:
2594             return self.editor.RotateObjectMakeGroups(theObject, Axis, AngleInRadians)
2595         self.editor.RotateObject(theObject, Axis, AngleInRadians, Copy)
2596         return []
2597
2598     ## Creates a new mesh from the rotated object
2599     #  @param theObject the object to rotate (mesh, submesh, or group)
2600     #  @param Axis the axis of rotation (AxisStruct or geom line)
2601     #  @param AngleInRadians the angle of rotation (in radians)
2602     #  @param MakeGroups forces the generation of new groups from existing ones
2603     #  @param NewMeshName the name of the newly created mesh
2604     #  @return instance of Mesh class
2605     #  @ingroup l2_modif_trsf
2606     def RotateObjectMakeMesh(self, theObject, Axis, AngleInRadians, MakeGroups=0,NewMeshName=""):
2607         if (isinstance( theObject, Mesh )):
2608             theObject = theObject.GetMesh()
2609         if (isinstance(Axis, geompyDC.GEOM._objref_GEOM_Object)):
2610             Axis = self.smeshpyD.GetAxisStruct(Axis)
2611         mesh = self.editor.RotateObjectMakeMesh(theObject, Axis, AngleInRadians,
2612                                                        MakeGroups, NewMeshName)
2613         return Mesh( self.smeshpyD, self.geompyD, mesh )
2614
2615     ## Finds groups of ajacent nodes within Tolerance.
2616     #  @param Tolerance the value of tolerance
2617     #  @return the list of groups of nodes
2618     #  @ingroup l2_modif_trsf
2619     def FindCoincidentNodes (self, Tolerance):
2620         return self.editor.FindCoincidentNodes(Tolerance)
2621
2622     ## Finds groups of ajacent nodes within Tolerance.
2623     #  @param Tolerance the value of tolerance
2624     #  @param SubMeshOrGroup SubMesh or Group
2625     #  @return the list of groups of nodes
2626     #  @ingroup l2_modif_trsf
2627     def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance):
2628         return self.editor.FindCoincidentNodesOnPart(SubMeshOrGroup, Tolerance)
2629
2630     ## Merges nodes
2631     #  @param GroupsOfNodes the list of groups of nodes
2632     #  @ingroup l2_modif_trsf
2633     def MergeNodes (self, GroupsOfNodes):
2634         self.editor.MergeNodes(GroupsOfNodes)
2635
2636     ## Finds the elements built on the same nodes.
2637     #  @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching
2638     #  @return a list of groups of equal elements
2639     #  @ingroup l2_modif_trsf
2640     def FindEqualElements (self, MeshOrSubMeshOrGroup):
2641         return self.editor.FindEqualElements(MeshOrSubMeshOrGroup)
2642
2643     ## Merges elements in each given group.
2644     #  @param GroupsOfElementsID groups of elements for merging
2645     #  @ingroup l2_modif_trsf
2646     def MergeElements(self, GroupsOfElementsID):
2647         self.editor.MergeElements(GroupsOfElementsID)
2648
2649     ## Leaves one element and removes all other elements built on the same nodes.
2650     #  @ingroup l2_modif_trsf
2651     def MergeEqualElements(self):
2652         self.editor.MergeEqualElements()
2653
2654     ## Sews free borders
2655     #  @return SMESH::Sew_Error
2656     #  @ingroup l2_modif_trsf
2657     def SewFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
2658                         FirstNodeID2, SecondNodeID2, LastNodeID2,
2659                         CreatePolygons, CreatePolyedrs):
2660         return self.editor.SewFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
2661                                           FirstNodeID2, SecondNodeID2, LastNodeID2,
2662                                           CreatePolygons, CreatePolyedrs)
2663
2664     ## Sews conform free borders
2665     #  @return SMESH::Sew_Error
2666     #  @ingroup l2_modif_trsf
2667     def SewConformFreeBorders (self, FirstNodeID1, SecondNodeID1, LastNodeID1,
2668                                FirstNodeID2, SecondNodeID2):
2669         return self.editor.SewConformFreeBorders(FirstNodeID1, SecondNodeID1, LastNodeID1,
2670                                                  FirstNodeID2, SecondNodeID2)
2671
2672     ## Sews border to side
2673     #  @return SMESH::Sew_Error
2674     #  @ingroup l2_modif_trsf
2675     def SewBorderToSide (self, FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
2676                          FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs):
2677         return self.editor.SewBorderToSide(FirstNodeIDOnFreeBorder, SecondNodeIDOnFreeBorder, LastNodeIDOnFreeBorder,
2678                                            FirstNodeIDOnSide, LastNodeIDOnSide, CreatePolygons, CreatePolyedrs)
2679
2680     ## Sews two sides of a mesh. The nodes belonging to Side1 are
2681     #  merged with the nodes of elements of Side2.
2682     #  The number of elements in theSide1 and in theSide2 must be
2683     #  equal and they should have similar nodal connectivity.
2684     #  The nodes to merge should belong to side borders and
2685     #  the first node should be linked to the second.
2686     #  @return SMESH::Sew_Error
2687     #  @ingroup l2_modif_trsf
2688     def SewSideElements (self, IDsOfSide1Elements, IDsOfSide2Elements,
2689                          NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
2690                          NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge):
2691         return self.editor.SewSideElements(IDsOfSide1Elements, IDsOfSide2Elements,
2692                                            NodeID1OfSide1ToMerge, NodeID1OfSide2ToMerge,
2693                                            NodeID2OfSide1ToMerge, NodeID2OfSide2ToMerge)
2694
2695     ## Sets new nodes for the given element.
2696     #  @param ide the element id
2697     #  @param newIDs nodes ids
2698     #  @return If the number of nodes does not correspond to the type of element - returns false
2699     #  @ingroup l2_modif_edit
2700     def ChangeElemNodes(self, ide, newIDs):
2701         return self.editor.ChangeElemNodes(ide, newIDs)
2702
2703     ## If during the last operation of MeshEditor some nodes were
2704     #  created, this method returns the list of their IDs, \n
2705     #  if new nodes were not created - returns empty list
2706     #  @return the list of integer values (can be empty)
2707     #  @ingroup l1_auxiliary
2708     def GetLastCreatedNodes(self):
2709         return self.editor.GetLastCreatedNodes()
2710
2711     ## If during the last operation of MeshEditor some elements were
2712     #  created this method returns the list of their IDs, \n
2713     #  if new elements were not created - returns empty list
2714     #  @return the list of integer values (can be empty)
2715     #  @ingroup l1_auxiliary
2716     def GetLastCreatedElems(self):
2717         return self.editor.GetLastCreatedElems()
2718
2719 ## The mother class to define algorithm, it is not recommended to use it directly.
2720 #
2721 #  More details.
2722 #  @ingroup l2_algorithms
2723 class Mesh_Algorithm:
2724     #  @class Mesh_Algorithm
2725     #  @brief Class Mesh_Algorithm
2726
2727     #def __init__(self,smesh):
2728     #    self.smesh=smesh
2729     def __init__(self):
2730         self.mesh = None
2731         self.geom = None
2732         self.subm = None
2733         self.algo = None
2734
2735     ## Finds a hypothesis in the study by its type name and parameters.
2736     #  Finds only the hypotheses created in smeshpyD engine.
2737     #  @return SMESH.SMESH_Hypothesis
2738     def FindHypothesis (self, hypname, args, CompareMethod, smeshpyD):
2739         study = smeshpyD.GetCurrentStudy()
2740         #to do: find component by smeshpyD object, not by its data type
2741         scomp = study.FindComponent(smeshpyD.ComponentDataType())
2742         if scomp is not None:
2743             res,hypRoot = scomp.FindSubObject(SMESH.Tag_HypothesisRoot)
2744             # Check if the root label of the hypotheses exists
2745             if res and hypRoot is not None:
2746                 iter = study.NewChildIterator(hypRoot)
2747                 # Check all published hypotheses
2748                 while iter.More():
2749                     hypo_so_i = iter.Value()
2750                     attr = hypo_so_i.FindAttribute("AttributeIOR")[1]
2751                     if attr is not None:
2752                         anIOR = attr.Value()
2753                         hypo_o_i = salome.orb.string_to_object(anIOR)
2754                         if hypo_o_i is not None:
2755                             # Check if this is a hypothesis
2756                             hypo_i = hypo_o_i._narrow(SMESH.SMESH_Hypothesis)
2757                             if hypo_i is not None:
2758                                 # Check if the hypothesis belongs to current engine
2759                                 if smeshpyD.GetObjectId(hypo_i) > 0:
2760                                     # Check if this is the required hypothesis
2761                                     if hypo_i.GetName() == hypname:
2762                                         # Check arguments
2763                                         if CompareMethod(hypo_i, args):
2764                                             # found!!!
2765                                             return hypo_i
2766                                         pass
2767                                     pass
2768                                 pass
2769                             pass
2770                         pass
2771                     iter.Next()
2772                     pass
2773                 pass
2774             pass
2775         return None
2776
2777     ## Finds the algorithm in the study by its type name.
2778     #  Finds only the algorithms, which have been created in smeshpyD engine.
2779     #  @return SMESH.SMESH_Algo
2780     def FindAlgorithm (self, algoname, smeshpyD):
2781         study = smeshpyD.GetCurrentStudy()
2782         #to do: find component by smeshpyD object, not by its data type
2783         scomp = study.FindComponent(smeshpyD.ComponentDataType())
2784         if scomp is not None:
2785             res,hypRoot = scomp.FindSubObject(SMESH.Tag_AlgorithmsRoot)
2786             # Check if the root label of the algorithms exists
2787             if res and hypRoot is not None:
2788                 iter = study.NewChildIterator(hypRoot)
2789                 # Check all published algorithms
2790                 while iter.More():
2791                     algo_so_i = iter.Value()
2792                     attr = algo_so_i.FindAttribute("AttributeIOR")[1]
2793                     if attr is not None:
2794                         anIOR = attr.Value()
2795                         algo_o_i = salome.orb.string_to_object(anIOR)
2796                         if algo_o_i is not None:
2797                             # Check if this is an algorithm
2798                             algo_i = algo_o_i._narrow(SMESH.SMESH_Algo)
2799                             if algo_i is not None:
2800                                 # Checks if the algorithm belongs to the current engine
2801                                 if smeshpyD.GetObjectId(algo_i) > 0:
2802                                     # Check if this is the required algorithm
2803                                     if algo_i.GetName() == algoname:
2804                                         # found!!!
2805                                         return algo_i
2806                                     pass
2807                                 pass
2808                             pass
2809                         pass
2810                     iter.Next()
2811                     pass
2812                 pass
2813             pass
2814         return None
2815
2816     ## If the algorithm is global, returns 0; \n
2817     #  else returns the submesh associated to this algorithm.
2818     def GetSubMesh(self):
2819         return self.subm
2820
2821     ## Returns the wrapped mesher.
2822     def GetAlgorithm(self):
2823         return self.algo
2824
2825     ## Gets the list of hypothesis that can be used with this algorithm
2826     def GetCompatibleHypothesis(self):
2827         mylist = []
2828         if self.algo:
2829             mylist = self.algo.GetCompatibleHypothesis()
2830         return mylist
2831
2832     ## Gets the name of the algorithm
2833     def GetName(self):
2834         GetName(self.algo)
2835
2836     ## Sets the name to the algorithm
2837     def SetName(self, name):
2838         SetName(self.algo, name)
2839
2840     ## Gets the id of the algorithm
2841     def GetId(self):
2842         return self.algo.GetId()
2843
2844     ## Private method.
2845     def Create(self, mesh, geom, hypo, so="libStdMeshersEngine.so"):
2846         if geom is None:
2847             raise RuntimeError, "Attemp to create " + hypo + " algoritm on None shape"
2848         algo = self.FindAlgorithm(hypo, mesh.smeshpyD)
2849         if algo is None:
2850             algo = mesh.smeshpyD.CreateHypothesis(hypo, so)
2851             pass
2852         self.Assign(algo, mesh, geom)
2853         return self.algo
2854
2855     ## Private method
2856     def Assign(self, algo, mesh, geom):
2857         if geom is None:
2858             raise RuntimeError, "Attemp to create " + algo + " algoritm on None shape"
2859         self.mesh = mesh
2860         piece = mesh.geom
2861         if not geom:
2862             self.geom = piece
2863         else:
2864             self.geom = geom
2865             name = GetName(geom)
2866             if name==NO_NAME:
2867                 name = mesh.geompyD.SubShapeName(geom, piece)
2868                 mesh.geompyD.addToStudyInFather(piece, geom, name)
2869             self.subm = mesh.mesh.GetSubMesh(geom, algo.GetName())
2870
2871         self.algo = algo
2872         status = mesh.mesh.AddHypothesis(self.geom, self.algo)
2873         TreatHypoStatus( status, algo.GetName(), GetName(self.geom), True )
2874
2875     def CompareHyp (self, hyp, args):
2876         print "CompareHyp is not implemented for ", self.__class__.__name__, ":", hyp.GetName()
2877         return False
2878
2879     def CompareEqualHyp (self, hyp, args):
2880         return True
2881
2882     ## Private method
2883     def Hypothesis (self, hyp, args=[], so="libStdMeshersEngine.so",
2884                     UseExisting=0, CompareMethod=""):
2885         hypo = None
2886         if UseExisting:
2887             if CompareMethod == "": CompareMethod = self.CompareHyp
2888             hypo = self.FindHypothesis(hyp, args, CompareMethod, self.mesh.smeshpyD)
2889             pass
2890         if hypo is None:
2891             hypo = self.mesh.smeshpyD.CreateHypothesis(hyp, so)
2892             a = ""
2893             s = "="
2894             i = 0
2895             n = len(args)
2896             while i<n:
2897                 a = a + s + str(args[i])
2898                 s = ","
2899                 i = i + 1
2900                 pass
2901             SetName(hypo, hyp + a)
2902             pass
2903         status = self.mesh.mesh.AddHypothesis(self.geom, hypo)
2904         TreatHypoStatus( status, GetName(hypo), GetName(self.geom), 0 )
2905         return hypo
2906
2907
2908 # Public class: Mesh_Segment
2909 # --------------------------
2910
2911 ## Class to define a segment 1D algorithm for discretization
2912 #
2913 #  More details.
2914 #  @ingroup l3_algos_basic
2915 class Mesh_Segment(Mesh_Algorithm):
2916
2917     ## Private constructor.
2918     def __init__(self, mesh, geom=0):
2919         Mesh_Algorithm.__init__(self)
2920         self.Create(mesh, geom, "Regular_1D")
2921
2922     ## Defines "LocalLength" hypothesis to cut an edge in several segments with the same length
2923     #  @param l for the length of segments that cut an edge
2924     #  @param UseExisting if ==true - searches for an  existing hypothesis created with
2925     #                    the same parameters, else (default) - creates a new one
2926     #  @param p precision, used for calculation of the number of segments.
2927     #           The precision should be a positive, meaningful value within the range [0,1].
2928     #           In general, the number of segments is calculated with the formula:
2929     #           nb = ceil((edge_length / l) - p)
2930     #           Function ceil rounds its argument to the higher integer.
2931     #           So, p=0 means rounding of (edge_length / l) to the higher integer,