X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshBuilder.py;h=ffeaa7cfd19710d8ac6673e8c59c695c584f1744;hp=026858782d102c3112ff8aff43f686b76e9bc3da;hb=cc85955178440fffe36eef234d759e3c3590248f;hpb=09bc0414c91ebabb67c7fe200549044a1854e199 diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py index 026858782..ffeaa7cfd 100755 --- a/src/SMESH_SWIG/smeshBuilder.py +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -745,33 +745,38 @@ class smeshBuilder( SMESH._objref_SMESH_Gen, object ): mergeTolerance: tolerance for merging nodes allGroups: forces creation of groups corresponding to every input mesh name: name of a new mesh - meshToAppendTo a mesh to append all given meshes + meshToAppendTo: a mesh to append all given meshes Returns: an instance of class :class:`Mesh` + + See also: + :meth:`Mesh.Append` """ if not meshes: return None - for i,m in enumerate(meshes): - if isinstance(m, Mesh): + if not isinstance( meshes, list ): + meshes = [ meshes ] + for i,m in enumerate( meshes ): + if isinstance( m, Mesh ): meshes[i] = m.GetMesh() - mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance) + mergeTolerance,Parameters,hasVars = ParseParameters( mergeTolerance ) if hasattr(meshes[0], "SetParameters"): - meshes[0].SetParameters(Parameters) + meshes[0].SetParameters( Parameters ) else: - meshes[0].GetMesh().SetParameters(Parameters) + meshes[0].GetMesh().SetParameters( Parameters ) if isinstance( meshToAppendTo, Mesh ): meshToAppendTo = meshToAppendTo.GetMesh() if allGroups: aSmeshMesh = SMESH._objref_SMESH_Gen.ConcatenateWithGroups( self,meshes,uniteIdenticalGroups,mergeNodesAndElements, - mergeTolerance,meshToAppendTo) + mergeTolerance,meshToAppendTo ) else: aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate( self,meshes,uniteIdenticalGroups,mergeNodesAndElements, - mergeTolerance,meshToAppendTo) + mergeTolerance,meshToAppendTo ) - aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name) + aMesh = Mesh( self, self.geompyD, aSmeshMesh, name=name ) return aMesh def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False): @@ -1188,6 +1193,8 @@ class smeshBuilder( SMESH._objref_SMESH_Gen, object ): functor = aFilterMgr.CreateLength() elif theCriterion == FT_Length2D: functor = aFilterMgr.CreateLength2D() + elif theCriterion == FT_Length3D: + functor = aFilterMgr.CreateLength3D() elif theCriterion == FT_Deflection2D: functor = aFilterMgr.CreateDeflection2D() elif theCriterion == FT_NodeConnectivityNumber: @@ -2501,6 +2508,25 @@ class Mesh(metaclass = MeshMeta): minor = -1 # invoke engine's function self.mesh.ExportMED(fileName, auto_groups, minor, overwrite, autoDimension) + return + + + def Append(self, meshes, uniteIdenticalGroups = True, + mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False): + """ + Append given meshes into this mesh. + All groups of input meshes will be created in this mesh. + + Parameters: + meshes: :class:`meshes, sub-meshes, groups or filters ` to append + uniteIdenticalGroups: if True, groups with same names are united, else they are renamed + mergeNodesAndElements: if True, equal nodes and elements are merged + mergeTolerance: tolerance for merging nodes + allGroups: forces creation of groups corresponding to every input mesh + """ + self.smeshpyD.Concatenate( meshes, uniteIdenticalGroups, + mergeNodesAndElements, mergeTolerance, allGroups, + meshToAppendTo = self.GetMesh() ) # Operations with groups: # ---------------------- @@ -5340,7 +5366,8 @@ class Mesh(metaclass = MeshMeta): NbOfSteps, Tolerance, MakeGroups, TotalAngle) def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False, - scaleFactors=[], linearVariation=False, basePoint=[] ): + scaleFactors=[], linearVariation=False, basePoint=[], + angles=[], anglesVariation=False): """ Generate new elements by extrusion of the given elements and nodes @@ -5354,15 +5381,19 @@ class Mesh(metaclass = MeshMeta): NbOfSteps: the number of steps MakeGroups: forces the generation of new groups from existing ones scaleFactors: optional scale factors to apply during extrusion - linearVariation: if *True*, scaleFactors are spread over all *scaleFactors*, - else scaleFactors[i] is applied to nodes at the i-th extrusion step - basePoint: optional scaling center; if not provided, a gravity center of + linearVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*, + else *scaleFactors* [i] is applied to nodes at the i-th extrusion step + basePoint: optional scaling and rotation center; if not provided, a gravity center of nodes and elements being extruded is used as the scaling center. It can be either - a list of tree components of the point or - a node ID or - a GEOM point + angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. + anglesVariation: forces the computation of rotation angles as linear + variation of the given *angles* along path steps Returns: the list of created :class:`groups ` if *MakeGroups* == True, empty list otherwise @@ -5387,13 +5418,17 @@ class Mesh(metaclass = MeshMeta): basePoint = self.geompyD.PointCoordinates( basePoint ) NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) - Parameters = StepVector.PS.parameters + var_separator + Parameters + scaleFactors,scaleParameters,hasVars = ParseParameters(scaleFactors) + angles,angleParameters,hasVars = ParseAngles(angles) + Parameters = StepVector.PS.parameters + var_separator + \ + Parameters + var_separator + \ + scaleParameters + var_separator + angleParameters self.mesh.SetParameters(Parameters) return self.editor.ExtrusionSweepObjects( nodes, edges, faces, - StepVector, NbOfSteps, + StepVector, NbOfSteps, MakeGroups, scaleFactors, linearVariation, basePoint, - MakeGroups) + angles, anglesVariation ) def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): @@ -5555,9 +5590,10 @@ class Mesh(metaclass = MeshMeta): return self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps, ExtrFlags, SewTolerance, MakeGroups) - def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathMesh, PathShape=None, + def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathObject, PathShape=None, NodeStart=1, HasAngles=False, Angles=[], LinearVariation=False, - HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False): + HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False, + ScaleFactors=[], ScalesVariation=False): """ Generate new elements by extrusion of the given elements and nodes along the path. The path of extrusion must be a meshed edge. @@ -5566,20 +5602,22 @@ class Mesh(metaclass = MeshMeta): Nodes: nodes to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters ` Edges: edges to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters ` Faces: faces to extrude: a list including ids, :class:`a mesh, sub-meshes, groups or filters ` - PathMesh: 1D mesh or 1D sub-mesh, along which proceeds the extrusion - PathShape: shape (edge) defines the sub-mesh of PathMesh if PathMesh - contains not only path segments, else it can be None + PathObject: :class:`mesh, sub-mesh, group or filter ` containing edges along which proceeds the extrusion + PathShape: optional shape (edge or wire) which defines the sub-mesh of the mesh defined by *PathObject* if the mesh contains not only path segments, else it can be None NodeStart: the first or the last node on the path. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. LinearVariation: forces the computation of rotation angles as linear variation of the given Angles along path steps HasRefPoint: allows using the reference point - RefPoint: the reference point around which the shape is rotated (the mass center of the - shape by default). The User can specify any point as the Reference Point. + RefPoint: optional scaling and rotation center (mass center of the extruded + elements by default). The User can specify any point as the Reference Point. *RefPoint* can be either GEOM Vertex, [x,y,z] or :class:`SMESH.PointStruct` MakeGroups: forces the generation of new groups from existing ones + ScaleFactors: optional scale factors to apply during extrusion + ScalesVariation: if *True*, *scaleFactors* are spread over all *NbOfSteps*, + else *scaleFactors* [i] is applied to nodes at the i-th extrusion step Returns: list of created :class:`groups ` and @@ -5597,15 +5635,18 @@ class Mesh(metaclass = MeshMeta): if isinstance( RefPoint, list ): if not RefPoint: RefPoint = [0,0,0] RefPoint = SMESH.PointStruct( *RefPoint ) - if isinstance( PathMesh, Mesh ): - PathMesh = PathMesh.GetMesh() + if isinstance( PathObject, Mesh ): + PathObject = PathObject.GetMesh() Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters + ScaleFactors,ScalesParameters,hasVars = ParseParameters(ScaleFactors) + Parameters = AnglesParameters + var_separator + \ + RefPoint.parameters + var_separator + ScalesParameters self.mesh.SetParameters(Parameters) return self.editor.ExtrusionAlongPathObjects(Nodes, Edges, Faces, - PathMesh, PathShape, NodeStart, + PathObject, PathShape, NodeStart, HasAngles, Angles, LinearVariation, - HasRefPoint, RefPoint, MakeGroups) + HasRefPoint, RefPoint, MakeGroups, + ScaleFactors, ScalesVariation) def ExtrusionAlongPathX(self, Base, Path, NodeStart, HasAngles=False, Angles=[], LinearVariation=False, @@ -5619,9 +5660,9 @@ class Mesh(metaclass = MeshMeta): Base: :class:`mesh, sub-mesh, group, filter `, or list of ids of elements for extrusion Path: 1D mesh or 1D sub-mesh, along which proceeds the extrusion NodeStart: the start node from Path. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles in radians + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. LinearVariation: forces the computation of rotation angles as linear variation of the given Angles along path steps HasRefPoint: allows using the reference point @@ -5662,9 +5703,9 @@ class Mesh(metaclass = MeshMeta): PathMesh: mesh containing a 1D sub-mesh on the edge, along which proceeds the extrusion PathShape: shape (edge) defines the sub-mesh for the path NodeStart: the first or the last node on the edge. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles in radians + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. HasRefPoint: allows using the reference point RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default). The User can specify any point as the Reference Point. @@ -5680,6 +5721,8 @@ class Mesh(metaclass = MeshMeta): Example: :ref:`tui_extrusion_along_path` """ + if not IDsOfElements: + IDsOfElements = [ self.GetMesh() ] n,e,f = [],IDsOfElements,IDsOfElements gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart, HasAngles, Angles, @@ -5701,9 +5744,9 @@ class Mesh(metaclass = MeshMeta): PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds PathShape: shape (edge) defines the sub-mesh for the path NodeStart: the first or the last node on the edge. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. HasRefPoint: allows using the reference point RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default). The User can specify any point as the Reference Point. @@ -5739,9 +5782,9 @@ class Mesh(metaclass = MeshMeta): PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds PathShape: shape (edge) defines the sub-mesh for the path NodeStart: the first or the last node on the edge. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. HasRefPoint: allows using the reference point RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default). The User can specify any point as the Reference Point. @@ -5777,9 +5820,9 @@ class Mesh(metaclass = MeshMeta): PathMesh: mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds PathShape: shape (edge) defines the sub-mesh for the path NodeStart: the first or the last node on the edge. Defines the direction of extrusion - HasAngles: allows the shape to be rotated around the path - to get the resulting mesh in a helical fashion - Angles: list of angles + HasAngles: not used obsolete + Angles: list of angles in radians. Nodes at each extrusion step are rotated + around *basePoint*, additionally to previous steps. HasRefPoint: allows using the reference point RefPoint: the reference point around which the shape is rotated (the mass center of the shape by default). The User can specify any point as the Reference Point. @@ -6239,7 +6282,7 @@ class Mesh(metaclass = MeshMeta): Parameters: Tolerance: the value of tolerance - SubMeshOrGroup: :class:`sub-mesh, group or filter ` or node IDs + SubMeshOrGroup: list of :class:`sub-meshes, groups or filters ` or of node IDs exceptNodes: list of either SubMeshes, Groups or node IDs to exclude from search SeparateCornerAndMediumNodes: if *True*, in quadratic mesh puts corner and medium nodes in separate groups thus preventing @@ -6250,11 +6293,16 @@ class Mesh(metaclass = MeshMeta): """ unRegister = genObjUnRegister() - if (isinstance( SubMeshOrGroup, Mesh )): - SubMeshOrGroup = SubMeshOrGroup.GetMesh() - if isinstance( SubMeshOrGroup, list ): - SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE ) - unRegister.set( SubMeshOrGroup ) + if not isinstance( SubMeshOrGroup, list ): + SubMeshOrGroup = [ SubMeshOrGroup ] + for i,obj in enumerate( SubMeshOrGroup ): + if isinstance( obj, Mesh ): + SubMeshOrGroup = [ obj.GetMesh() ] + break + if isinstance( obj, int ): + SubMeshOrGroup = self.GetIDSource( SubMeshOrGroup, SMESH.NODE ) + unRegister.set( SubMeshOrGroup ) + break if not isinstance( exceptNodes, list ): exceptNodes = [ exceptNodes ] @@ -6272,44 +6320,72 @@ class Mesh(metaclass = MeshMeta): Parameters: GroupsOfNodes: a list of groups of nodes IDs for merging. E.g. [[1,12,13],[25,4]] means that nodes 12, 13 and 4 will be removed and replaced - in all elements and groups by nodes 1 and 25 correspondingly + in all elements and mesh groups by nodes 1 and 25 correspondingly NodesToKeep: nodes to keep in the mesh: a list of groups, sub-meshes or node IDs. If *NodesToKeep* does not include a node to keep for some group to merge, then the first node in the group is kept. AvoidMakingHoles: prevent merging nodes which cause removal of elements becoming invalid """ - # NodesToKeep are converted to SMESH.SMESH_IDSource in meshEditor.MergeNodes() self.editor.MergeNodes( GroupsOfNodes, NodesToKeep, AvoidMakingHoles ) - def FindEqualElements (self, MeshOrSubMeshOrGroup=None): + def FindEqualElements (self, MeshOrSubMeshOrGroup=None, exceptElements=[]): """ Find the elements built on the same nodes. Parameters: - MeshOrSubMeshOrGroup: :class:`mesh, sub-mesh, group or filter ` + MeshOrSubMeshOrGroup: :class:`mesh, sub-meshes, groups or filters ` or element IDs to check for equal elements + exceptElements: list of either SubMeshes, Groups or elements IDs to exclude from search + Returns: the list of groups of equal elements IDs (e.g. [[1,12,13],[4,25]]) """ - if not MeshOrSubMeshOrGroup: - MeshOrSubMeshOrGroup=self.mesh + unRegister = genObjUnRegister() + if MeshOrSubMeshOrGroup is None: + MeshOrSubMeshOrGroup = [ self.mesh ] elif isinstance( MeshOrSubMeshOrGroup, Mesh ): - MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh() - return self.editor.FindEqualElements( MeshOrSubMeshOrGroup ) - - def MergeElements(self, GroupsOfElementsID): + MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup.GetMesh() ] + elif not isinstance( MeshOrSubMeshOrGroup, list ): + MeshOrSubMeshOrGroup = [ MeshOrSubMeshOrGroup ] + if isinstance( MeshOrSubMeshOrGroup[0], int ): + MeshOrSubMeshOrGroup = [ self.GetIDSource( MeshOrSubMeshOrGroup, SMESH.ALL )] + unRegister.set( MeshOrSubMeshOrGroup ) + for item in MeshOrSubMeshOrGroup: + if isinstance( item, Mesh ): + MeshOrSubMeshOrGroup = [ item.GetMesh() ] + + if not isinstance( exceptElements, list ): + exceptElements = [ exceptElements ] + if exceptElements and isinstance( exceptElements[0], int ): + exceptElements = [ self.GetIDSource( exceptElements, SMESH.ALL )] + unRegister.set( exceptElements ) + + return self.editor.FindEqualElements( MeshOrSubMeshOrGroup, exceptElements ) + + def MergeElements(self, GroupsOfElementsID, ElementsToKeep=[]): """ Merge elements in each given group. Parameters: GroupsOfElementsID: a list of groups (lists) of elements IDs for merging (e.g. [[1,12,13],[25,4]] means that elements 12, 13 and 4 will be removed and - replaced in all groups by elements 1 and 25) + replaced in all mesh groups by elements 1 and 25) + ElementsToKeep: elements to keep in the mesh: a list of groups, sub-meshes or node IDs. + If *ElementsToKeep* does not include an element to keep for some group to merge, + then the first element in the group is kept. """ - self.editor.MergeElements(GroupsOfElementsID) + unRegister = genObjUnRegister() + if ElementsToKeep: + if not isinstance( ElementsToKeep, list ): + ElementsToKeep = [ ElementsToKeep ] + if isinstance( ElementsToKeep[0], int ): + ElementsToKeep = [ self.GetIDSource( ElementsToKeep, SMESH.ALL )] + unRegister.set( ElementsToKeep ) + + self.editor.MergeElements( GroupsOfElementsID, ElementsToKeep ) def MergeEqualElements(self): """