IMP 23612: EDF 14143 - Compute angle from 3 points

[modules/smesh.git] / src / SMESH_SWIG / smeshBuilder.py

diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py
old mode 100644 (file)
new mode 100755 (executable)
index 8b62ca6..35198fe
--- a/src/SMESH_SWIG/smeshBuilder.py
+++ b/src/SMESH_SWIG/smeshBuilder.py
@@ -303,6 +303,8 @@ def AssureGeomPublished(mesh, geom, name=''):
     """
     Private method. Add geom (sub-shape of the main shape) into the study if not yet there
     """
     """
     Private method. Add geom (sub-shape of the main shape) into the study if not yet there
     """

+    if not mesh.smeshpyD.IsEnablePublish():
+        return

     if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
         return
     if not geom.GetStudyEntry():
     if not isinstance( geom, geomBuilder.GEOM._objref_GEOM_Object ):
         return
     if not geom.GetStudyEntry():


@@ -780,11 +782,46 @@ class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
                 an instance of class :class:`Mesh`
         """
 
                 an instance of class :class:`Mesh`
         """
 

-        if (isinstance( meshPart, Mesh )):
+        if isinstance( meshPart, Mesh ):

             meshPart = meshPart.GetMesh()
         mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs )
         return Mesh(self, self.geompyD, mesh)
 
             meshPart = meshPart.GetMesh()
         mesh = SMESH._objref_SMESH_Gen.CopyMesh( self,meshPart,meshName,toCopyGroups,toKeepIDs )
         return Mesh(self, self.geompyD, mesh)
 

+    def CopyMeshWithGeom( self, sourceMesh, newGeom, meshName="", toCopyGroups=True,
+                          toReuseHypotheses=True, toCopyElements=True):
+        """
+        Create a mesh by copying a mesh definition (hypotheses and groups) to a new geometry.
+        It is supposed that the new geometry is a modified geometry of *sourceMesh*.
+        To facilitate and speed up the operation, consider using
+        "Set presentation parameters and sub-shapes from arguments" option in
+        a dialog of geometrical operation used to create the new geometry.
+
+        Parameters:
+                sourceMesh: the mesh to copy definition of.
+                newGeom: the new geomtry.
+                meshName: an optional name of the new mesh. If omitted, the mesh name is kept.
+                toCopyGroups: to create groups in the new mesh.
+                toReuseHypotheses: to reuse hypotheses of the *sourceMesh*.
+                toCopyElements: to copy mesh elements present on non-modified sub-shapes of 
+                                *sourceMesh*.
+        Returns:
+                tuple ( ok, newMesh, newGroups, newSubMeshes, newHypotheses, invalidEntries )
+                *invalidEntries* are study entries of objects whose
+                counterparts are not found in the *newGeom*, followed by entries
+                of mesh sub-objects that are invalid because they depend on a not found
+                preceeding sub-shape
+        """
+        if isinstance( sourceMesh, Mesh ):
+            sourceMesh = sourceMesh.GetMesh()
+
+        ok, newMesh, newGroups, newSubMeshes, newHypotheses, invalidEntries = \
+           SMESH._objref_SMESH_Gen.CopyMeshWithGeom( self, sourceMesh, newGeom, meshName,
+                                                     toCopyGroups,
+                                                     toReuseHypotheses,
+                                                     toCopyElements)
+        return ( ok, Mesh(self, self.geompyD, newMesh),
+                 newGroups, newSubMeshes, newHypotheses, invalidEntries )
+

     def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
         """
         Return IDs of sub-shapes
     def GetSubShapesId( self, theMainObject, theListOfSubObjects ):
         """
         Return IDs of sub-shapes


@@ -1406,6 +1443,28 @@ class smeshBuilder( SMESH._objref_SMESH_Gen, object ):
         aMeasurements.UnRegister()
         return pointStruct.x, pointStruct.y, pointStruct.z
 
         aMeasurements.UnRegister()
         return pointStruct.x, pointStruct.y, pointStruct.z
 

+    def GetAngle(self, p1, p2, p3 ):
+        """
+        Computes a radian measure of an angle defined by 3 points: <(p1,p2,p3)
+
+        Parameters:            
+                p1,p2,p3: coordinates of 3 points defined by either SMESH.PointStruct 
+                          or list [x,y,z]
+
+        Returns:        
+            Angle in radians
+        """
+        if isinstance( p1, list ): p1 = PointStruct(*p1)
+        if isinstance( p2, list ): p2 = PointStruct(*p2)
+        if isinstance( p3, list ): p3 = PointStruct(*p3)
+
+        aMeasurements = self.CreateMeasurements()
+        angle = aMeasurements.Angle(p1,p2,p3)
+        aMeasurements.UnRegister()
+
+        return angle
+
+

     pass # end of class smeshBuilder
 
 import omniORB
     pass # end of class smeshBuilder
 
 import omniORB


@@ -1598,7 +1657,7 @@ class Mesh(metaclass = MeshMeta):
 
                    algo1D = mesh.Segment(geom=Edge_1)
 
 
                    algo1D = mesh.Segment(geom=Edge_1)
 

-                creates a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.
+                create a sub-mesh on *Edge_1* and assign Wire Discretization algorithm to it.

                 The created sub-mesh can be retrieved from the algorithm::
 
                    submesh = algo1D.GetSubMesh()
                 The created sub-mesh can be retrieved from the algorithm::
 
                    submesh = algo1D.GetSubMesh()


@@ -1628,6 +1687,12 @@ class Mesh(metaclass = MeshMeta):
 
         self.mesh = self.smeshpyD.CreateMesh(geom)
 
 
         self.mesh = self.smeshpyD.CreateMesh(geom)
 

+    def HasShapeToMesh(self):
+        """
+        Return ``True`` if this mesh is based on geometry
+        """
+        return self.mesh.HasShapeToMesh()
+

     def Load(self):
         """
         Load mesh from the study after opening the study
     def Load(self):
         """
         Load mesh from the study after opening the study


@@ -2182,11 +2247,17 @@ class Mesh(metaclass = MeshMeta):
                         If *autoDimension* is *False*, the space dimension is always 3.
                 fields: list of GEOM fields defined on the shape to mesh.
                 geomAssocFields: each character of this string means a need to export a 
                         If *autoDimension* is *False*, the space dimension is always 3.
                 fields: list of GEOM fields defined on the shape to mesh.
                 geomAssocFields: each character of this string means a need to export a 

-                        corresponding field; correspondence between fields and characters is following:
-                        - 'v' stands for "_vertices _" field;
-                        - 'e' stands for "_edges _" field;
-                        - 'f' stands for "_faces _" field;
-                        - 's' stands for "_solids _" field.
+                        corresponding field; correspondence between fields and characters 
+                        is following:
+
+                        - 'v' stands for "_vertices_" field;
+                        - 'e' stands for "_edges_" field;
+                        - 'f' stands for "_faces_" field;
+                        - 's' stands for "_solids_" field.
+
+                zTolerance (float): tolerance in Z direction. If Z coordinate of a node is 
+                             close to zero within a given tolerance, the coordinate is set to zero.
+                             If *ZTolerance* is negative (default), the node coordinates are kept as is.

         """
         # process positional arguments
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility
         """
         # process positional arguments
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]] # backward compatibility


@@ -2198,6 +2269,7 @@ class Mesh(metaclass = MeshMeta):
         autoDimension   = args[5] if len(args) > 5 else True
         fields          = args[6] if len(args) > 6 else []
         geomAssocFields = args[7] if len(args) > 7 else ''
         autoDimension   = args[5] if len(args) > 5 else True
         fields          = args[6] if len(args) > 6 else []
         geomAssocFields = args[7] if len(args) > 7 else ''

+        z_tolerance     = args[8] if len(args) > 8 else -1.

         # process keywords arguments
         auto_groups     = kwargs.get("auto_groups", auto_groups)
         minor           = kwargs.get("minor", minor)
         # process keywords arguments
         auto_groups     = kwargs.get("auto_groups", auto_groups)
         minor           = kwargs.get("minor", minor)


@@ -2206,14 +2278,20 @@ class Mesh(metaclass = MeshMeta):
         autoDimension   = kwargs.get("autoDimension", autoDimension)
         fields          = kwargs.get("fields", fields)
         geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)
         autoDimension   = kwargs.get("autoDimension", autoDimension)
         fields          = kwargs.get("fields", fields)
         geomAssocFields = kwargs.get("geomAssocFields", geomAssocFields)

+        z_tolerance     = kwargs.get("zTolerance", z_tolerance)
+

         # invoke engine's function
         # invoke engine's function

-        if meshPart or fields or geomAssocFields:
+        if meshPart or fields or geomAssocFields or z_tolerance > 0:

             unRegister = genObjUnRegister()
             if isinstance( meshPart, list ):
                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
                 unRegister.set( meshPart )
             unRegister = genObjUnRegister()
             if isinstance( meshPart, list ):
                 meshPart = self.GetIDSource( meshPart, SMESH.ALL )
                 unRegister.set( meshPart )

+
+            z_tolerance,Parameters,hasVars = ParseParameters(z_tolerance)
+            self.mesh.SetParameters(Parameters)
+

             self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, minor, overwrite, autoDimension,
             self.mesh.ExportPartToMED( meshPart, fileName, auto_groups, minor, overwrite, autoDimension,

-                                       fields, geomAssocFields)
+                                       fields, geomAssocFields, z_tolerance)

         else:
             self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
 
         else:
             self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension)
 


@@ -2404,7 +2482,7 @@ class Mesh(metaclass = MeshMeta):
     # ----------------------
     def CreateEmptyGroup(self, elementType, name):
         """
     # ----------------------
     def CreateEmptyGroup(self, elementType, name):
         """

-        Create an empty mesh group
+        Create an empty standalone mesh group

 
         Parameters:
                 elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 
 
         Parameters:
                 elementType: the :class:`type <SMESH.ElementType>` of elements in the group; 


@@ -2439,7 +2517,7 @@ class Mesh(metaclass = MeshMeta):
     def GroupOnGeom(self, grp, name="", typ=None):
         """
         Create a mesh group based on the geometrical object *grp*
     def GroupOnGeom(self, grp, name="", typ=None):
         """
         Create a mesh group based on the geometrical object *grp*

-        and gives a *name*.
+        and give it a *name*.

         if *name* is not defined the name of the geometric group is used
 
         Parameters:
         if *name* is not defined the name of the geometric group is used
 
         Parameters:


@@ -2484,8 +2562,8 @@ class Mesh(metaclass = MeshMeta):
 
     def GroupOnFilter(self, typ, name, filter):
         """
 
     def GroupOnFilter(self, typ, name, filter):
         """

-        Create a mesh group with given *name* based on the *filter* which
-        is a special type of group dynamically updating it's contents during
+        Create a mesh group with given *name* based on the *filter*.
+        It is a special type of group dynamically updating it's contents during

         mesh modification
 
         Parameters:
         mesh modification
 
         Parameters:


@@ -2635,15 +2713,15 @@ class Mesh(metaclass = MeshMeta):
 
     def GetGroups(self, elemType = SMESH.ALL):
         """
 
     def GetGroups(self, elemType = SMESH.ALL):
         """

-        Get the list of groups existing in the mesh in the order
-        of creation (starting from the oldest one)
+        Get the list of groups existing in the mesh in the order of creation 
+        (starting from the oldest one)

 
         Parameters:
                 elemType (SMESH.ElementType): type of elements the groups contain;
                         by default groups of elements of all types are returned
 
         Returns:
 
         Parameters:
                 elemType (SMESH.ElementType): type of elements the groups contain;
                         by default groups of elements of all types are returned
 
         Returns:

-                a sequence of :class:`SMESH.SMESH_GroupBase`
+                a list of :class:`SMESH.SMESH_GroupBase`

         """
 
         groups = self.mesh.GetGroups()
         """
 
         groups = self.mesh.GetGroups()


@@ -2829,6 +2907,22 @@ class Mesh(metaclass = MeshMeta):
             groups = [groups]
         return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
 
             groups = [groups]
         return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly)
 

+    def FaceGroupsSeparatedByEdges( self, sharpAngle, createEdges=False, useExistingEdges=False ):
+        """
+        Distribute all faces of the mesh among groups using sharp edges and optionally
+        existing 1D elements as group boundaries.
+
+        Parameters:
+                sharpAngle: edge is considered sharp if an angle between normals of
+                            adjacent faces is more than \a sharpAngle in degrees.
+                createEdges (boolean): to create 1D elements for detected sharp edges.
+                useExistingEdges (boolean): to use existing edges as group boundaries
+        Returns:
+                ListOfGroups - the created :class:`groups <SMESH.SMESH_Group>`
+        """
+        sharpAngle,Parameters,hasVars = ParseParameters( sharpAngle )
+        self.mesh.SetParameters(Parameters)
+        return self.mesh.FaceGroupsSeparatedByEdges( sharpAngle, createEdges, useExistingEdges );

 
     def ConvertToStandalone(self, group):
         """
 
     def ConvertToStandalone(self, group):
         """


@@ -3672,7 +3766,9 @@ class Mesh(metaclass = MeshMeta):
                 isElem2: *True* if *id2* is element id, *False* if it is node id
 
         Returns:
                 isElem2: *True* if *id2* is element id, *False* if it is node id
 
         Returns:

-            minimum distance value **GetMinDistance()**
+            minimum distance value
+        See Also:
+            :meth:`GetMinDistance`

         """
 
         aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2)
         """
 
         aMeasure = self.GetMinDistance(id1, id2, isElem1, isElem2)


@@ -3997,7 +4093,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnVertex(self, NodeID, Vertex):
         """
 
     def SetNodeOnVertex(self, NodeID, Vertex):
         """

-        Binds a node to a vertex
+        Bind a node to a vertex

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4020,7 +4116,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
         """
 
     def SetNodeOnEdge(self, NodeID, Edge, paramOnEdge):
         """

-        Stores the node position on an edge
+        Store the node position on an edge

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4043,7 +4139,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeOnFace(self, NodeID, Face, u, v):
         """
 
     def SetNodeOnFace(self, NodeID, Face, u, v):
         """

-        Stores node position on a face
+        Store node position on a face

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4067,7 +4163,7 @@ class Mesh(metaclass = MeshMeta):
 
     def SetNodeInVolume(self, NodeID, Solid):
         """
 
     def SetNodeInVolume(self, NodeID, Solid):
         """

-        Binds a node to a solid
+        Bind a node to a solid

 
         Parameters:
                 NodeID: a node ID
 
         Parameters:
                 NodeID: a node ID


@@ -4182,6 +4278,17 @@ class Mesh(metaclass = MeshMeta):
         else:
             return self.editor.FindElementsByPoint(x, y, z, elementType)
 
         else:
             return self.editor.FindElementsByPoint(x, y, z, elementType)
 

+    def ProjectPoint(self, x,y,z, meshObject, elementType):
+        """
+        Project a point to a mesh object.
+        Return ID of an element of given type where the given point is projected
+        and coordinates of the projection point.
+        In the case if nothing found, return -1 and []
+        """
+        if ( isinstance( meshObject, Mesh )):
+            meshObject = meshObject.GetMesh()
+        return self.editor.ProjectPoint( x,y,z, meshObject, elementType )
+

     def GetPointState(self, x, y, z):
         """
         Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:
     def GetPointState(self, x, y, z):
         """
         Return point state in a closed 2D mesh in terms of TopAbs_State enumeration:


@@ -4205,6 +4312,21 @@ class Mesh(metaclass = MeshMeta):
 
         return self.editor.IsCoherentOrientation2D()
 
 
         return self.editor.IsCoherentOrientation2D()
 

+    def FindSharpEdges( self, angle, addExisting=False ):
+        """
+        Return sharp edges of faces and non-manifold ones.
+        Optionally add existing edges.
+
+        Parameters:
+                angle: angle (in degrees) between normals of adjacent faces to detect sharp edges
+                addExisting: to return existing edges (1D elements) as well
+
+        Returns:
+            list of FaceEdge structures
+        """
+        angle = ParseParameters( angle )[0]
+        return self.editor.FindSharpEdges( angle, addExisting )
+

     def MeshToPassThroughAPoint(self, x, y, z):
         """
         Find the node closest to a point and moves it to a point location
     def MeshToPassThroughAPoint(self, x, y, z):
         """
         Find the node closest to a point and moves it to a point location


@@ -4479,7 +4601,7 @@ class Mesh(metaclass = MeshMeta):
 
         Parameters:
                 IDsOfElements: the faces to be splitted
 
         Parameters:
                 IDsOfElements: the faces to be splitted

-                Diag13:        is used to choose a diagonal for splitting.
+                Diag13 (boolean):        is used to choose a diagonal for splitting.

 
         Returns:
             True in case of success, False otherwise.
 
         Returns:
             True in case of success, False otherwise.


@@ -4495,7 +4617,7 @@ class Mesh(metaclass = MeshMeta):
         Parameters:
                 theObject: the object from which the list of elements is taken,
                         this is :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
         Parameters:
                 theObject: the object from which the list of elements is taken,
                         this is :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`

-                Diag13:    is used to choose a diagonal for splitting.
+                Diag13 (boolean):    is used to choose a diagonal for splitting.

 
         Returns:
             True in case of success, False otherwise.
 
         Returns:
             True in case of success, False otherwise.


@@ -6140,14 +6262,17 @@ class Mesh(metaclass = MeshMeta):
 
         return self.editor.FindFreeBorders( ClosedOnly )
 
 
         return self.editor.FindFreeBorders( ClosedOnly )
 

-    def FillHole(self, holeNodes):
+    def FillHole(self, holeNodes, groupName=""):

         """
         Fill with 2D elements a hole defined by a SMESH.FreeBorder.
 
         Parameters:
         """
         Fill with 2D elements a hole defined by a SMESH.FreeBorder.
 
         Parameters:

-            FreeBorder: either a SMESH.FreeBorder or a list on node IDs. These nodes
+            holeNodes: either a SMESH.FreeBorder or a list on node IDs. These nodes

                 must describe all sequential nodes of the hole border. The first and the last
                 nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.
                 must describe all sequential nodes of the hole border. The first and the last
                 nodes must be the same. Use :meth:`FindFreeBorders` to get nodes of holes.

+            groupName (string): name of a group to add new faces
+        Returns:
+            a :class:`group <SMESH.SMESH_GroupBase>` containing the new faces; or :code:`None` if `groupName` == ""

         """
 
 
         """
 
 


@@ -6155,7 +6280,7 @@ class Mesh(metaclass = MeshMeta):
             holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
         if not isinstance( holeNodes, SMESH.FreeBorder ):
             raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)
             holeNodes = SMESH.FreeBorder(nodeIDs=holeNodes)
         if not isinstance( holeNodes, SMESH.FreeBorder ):
             raise TypeError("holeNodes must be either SMESH.FreeBorder or list of integer and not %s" % holeNodes)

-        self.editor.FillHole( holeNodes )
+        self.editor.FillHole( holeNodes, groupName )

 
     def FindCoincidentFreeBorders (self, tolerance=0.):
         """
 
     def FindCoincidentFreeBorders (self, tolerance=0.):
         """


@@ -6605,7 +6730,7 @@ class Mesh(metaclass = MeshMeta):
     def MakePolyLine(self, segments, groupName='', isPreview=False ):
         """    
         Create a polyline consisting of 1D mesh elements each lying on a 2D element of
     def MakePolyLine(self, segments, groupName='', isPreview=False ):
         """    
         Create a polyline consisting of 1D mesh elements each lying on a 2D element of

-        the initial mesh. Positions of new nodes are found by cutting the mesh by the
+        the initial triangle mesh. Positions of new nodes are found by cutting the mesh by the

         plane passing through pairs of points specified by each :class:`SMESH.PolySegment` structure.
         If there are several paths connecting a pair of points, the shortest path is
         selected by the module. Position of the cutting plane is defined by the two
         plane passing through pairs of points specified by each :class:`SMESH.PolySegment` structure.
         If there are several paths connecting a pair of points, the shortest path is
         selected by the module. Position of the cutting plane is defined by the two


@@ -6615,12 +6740,12 @@ class Mesh(metaclass = MeshMeta):
         The vector goes from the middle point to the projection point. In case of planar
         mesh, the vector is normal to the mesh.
 
         The vector goes from the middle point to the projection point. In case of planar
         mesh, the vector is normal to the mesh.
 

-        *segments* [i].vector returns the used vector which goes from the middle point to its projection.
+        In preview mode, *segments* [i].vector returns the used vector which goes from the middle point to its projection.

 
 

-        Parameters:        
+        Parameters:

             segments: list of :class:`SMESH.PolySegment` defining positions of cutting planes.
             groupName: optional name of a group where created mesh segments will be added.
             segments: list of :class:`SMESH.PolySegment` defining positions of cutting planes.
             groupName: optional name of a group where created mesh segments will be added.

-            
+

         """    
         editor = self.editor
         if isPreview:
         """    
         editor = self.editor
         if isPreview:


@@ -6723,6 +6848,20 @@ class Mesh(metaclass = MeshMeta):
             volume = self.FunctorValue(SMESH.FT_Volume3D, elemId)
         return volume
 
             volume = self.FunctorValue(SMESH.FT_Volume3D, elemId)
         return volume
 

+    def GetAngle(self, node1, node2, node3 ):
+        """
+        Computes a radian measure of an angle defined by 3 nodes: <(node1,node2,node3)
+
+        Parameters:            
+                node1,node2,node3: IDs of the three nodes
+
+        Returns:        
+            Angle in radians
+        """
+        return self.smeshpyD.GetAngle( self.GetNodeXYZ( node1 ),
+                                       self.GetNodeXYZ( node2 ),
+                                       self.GetNodeXYZ( node3 ))
+

     def GetMaxElementLength(self, elemId):
         """
         Get maximum element length.
     def GetMaxElementLength(self, elemId):
         """
         Get maximum element length.


@@ -6865,17 +7004,19 @@ class meshProxy(SMESH._objref_SMESH_Mesh):
     def ExportToMED(self, *args): # function removed
         print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
     def ExportToMED(self, *args): # function removed
         print("WARNING: ExportToMED() is deprecated, use ExportMED() instead")
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]

-        while len(args) < 4:  # !!!! nb of parameters for ExportToMED IDL's method
-            args.append(True)
-        SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+        args2 = list(args)
+        while len(args2) < 5:  # !!!! nb of parameters for ExportToMED IDL's method
+            args2.append(True)
+        SMESH._objref_SMESH_Mesh.ExportMED(self, *args2)

     def ExportPartToMED(self, *args): # 'version' parameter removed
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
         SMESH._objref_SMESH_Mesh.ExportPartToMED(self, *args)
     def ExportMED(self, *args): # signature of method changed
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
     def ExportPartToMED(self, *args): # 'version' parameter removed
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]
         SMESH._objref_SMESH_Mesh.ExportPartToMED(self, *args)
     def ExportMED(self, *args): # signature of method changed
         #args = [i for i in args if i not in [SMESH.MED_V2_1, SMESH.MED_V2_2]]

-        while len(args) < 4:  # !!!! nb of parameters for ExportToMED IDL's method
-            args.append(True)
-        SMESH._objref_SMESH_Mesh.ExportMED(self, *args)
+        args2 = list(args)
+        while len(args2) < 5:  # !!!! nb of parameters for ExportToMED IDL's method
+            args2.append(True)
+        SMESH._objref_SMESH_Mesh.ExportMED(self, *args2)

     pass
 omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)
 
     pass
 omniORB.registerObjref(SMESH._objref_SMESH_Mesh._NP_RepositoryId, meshProxy)