def Concatenate( self, meshes, uniteIdenticalGroups,
mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False,
- name = ""):
+ name = "", meshToAppendTo = None):
"""
- Concatenate the given meshes into one mesh. All groups of input meshes will be
- present in the new mesh.
+ Concatenate the given meshes into one mesh, optionally to meshToAppendTo.
+ All groups of input meshes will be present in the new mesh.
Parameters:
meshes: :class:`meshes, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` to combine into one mesh
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
Returns:
an instance of class :class:`Mesh`
if isinstance(m, Mesh):
meshes[i] = m.GetMesh()
mergeTolerance,Parameters,hasVars = ParseParameters(mergeTolerance)
- meshes[0].SetParameters(Parameters)
+ if hasattr(meshes[0], "SetParameters"):
+ meshes[0].SetParameters(Parameters)
+ else:
+ 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)
+ self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
+ mergeTolerance,meshToAppendTo)
else:
aSmeshMesh = SMESH._objref_SMESH_Gen.Concatenate(
- self,meshes,uniteIdenticalGroups,mergeNodesAndElements,mergeTolerance)
+ self,meshes,uniteIdenticalGroups,mergeNodesAndElements,
+ mergeTolerance,meshToAppendTo)
+
aMesh = Mesh(self, self.geompyD, aSmeshMesh, name=name)
return aMesh
def GetGravityCenter(self, obj):
"""
- Get gravity center of all nodes of the mesh object.
+ Get gravity center of all nodes of a mesh object.
Parameters:
obj: :class:`mesh, sub-mesh, group or filter <SMESH.SMESH_IDSource>`
Returns:
- Three components of the gravity center (x,y,z)
+ Three components of the gravity center (x,y,z)
+
+ See also:
+ :meth:`Mesh.BaryCenter`
"""
if isinstance(obj, Mesh): obj = obj.mesh
if isinstance(obj, Mesh_Algorithm): obj = obj.GetSubMesh()
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
return self.mesh
+ def GetEngine(self):
+ """
+ Return a smeshBuilder instance created this mesh
+ """
+ return self.smeshpyD
+
+ def GetGeomEngine(self):
+ """
+ Return a geomBuilder instance
+ """
+ return self.geompyD
+
def GetName(self):
"""
Get the name of the mesh
Create a standalone group of entities basing on nodes of other groups.
Parameters:
- groups: list of reference :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>`, of any type.
+ groups: list of :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>`, of any type.
elemType: a type of elements to include to the new group; either of
(SMESH.NODE, SMESH.EDGE, SMESH.FACE, SMESH.VOLUME).
name: a name of the new group.
def FaceGroupsSeparatedByEdges( self, sharpAngle, createEdges=False, useExistingEdges=False ):
"""
- Distribute all faces of the mesh between groups using sharp edges and optionally
+ Distribute all faces of the mesh among groups using sharp edges and optionally
existing 1D elements as group boundaries.
Parameters:
createEdges (boolean): to create 1D elements for detected sharp edges.
useExistingEdges (boolean): to use existing edges as group boundaries
Returns:
- ListOfGroups - the created groups
+ ListOfGroups - the created :class:`groups <SMESH.SMESH_Group>`
"""
sharpAngle,Parameters,hasVars = ParseParameters( sharpAngle )
self.mesh.SetParameters(Parameters)
return self.mesh.GetNodeXYZ(id)
- def GetNodeInverseElements(self, id):
+ def GetNodeInverseElements(self, id, elemType=SMESH.ALL):
"""
Return list of IDs of inverse elements for the given node.
If there is no node for the given ID - return an empty list
+ Parameters:
+ id: node ID
+ elementType: :class:`type of elements <SMESH.ElementType>` (SMESH.EDGE, SMESH.FACE, SMESH.VOLUME, etc.)
+
Returns:
list of integer values
"""
- return self.mesh.GetNodeInverseElements(id)
+ return self.mesh.GetNodeInverseElements(id,elemType)
def GetNodePosition(self,NodeID):
"""
Returns:
a list of three double values
+
+ See also:
+ :meth:`smeshBuilder.GetGravityCenter`
"""
return self.mesh.BaryCenter(id)
- def GetIdsFromFilter(self, theFilter):
+ def GetIdsFromFilter(self, filter, meshParts=[] ):
"""
Pass mesh elements through the given filter and return IDs of fitting elements
Parameters:
- theFilter: :class:`SMESH.Filter`
+ filter: :class:`SMESH.Filter`
+ meshParts: list of mesh parts (:class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`) to filter
Returns:
a list of ids
See Also:
:meth:`SMESH.Filter.GetIDs`
+ :meth:`SMESH.Filter.GetElementsIdFromParts`
"""
- theFilter.SetMesh( self.mesh )
- return theFilter.GetIDs()
+ filter.SetMesh( self.mesh )
+
+ if meshParts:
+ if isinstance( meshParts, Mesh ):
+ filter.SetMesh( meshParts.GetMesh() )
+ return theFilter.GetIDs()
+ if isinstance( meshParts, SMESH._objref_SMESH_IDSource ):
+ meshParts = [ meshParts ]
+ return filter.GetElementsIdFromParts( meshParts )
+
+ return filter.GetIDs()
# Get mesh measurements information:
# ------------------------------------
the ID of a node
"""
- #preview = self.mesh.GetMeshEditPreviewer()
- #return preview.MoveClosestNodeToPoint(x, y, z, -1)
return self.editor.FindNodeClosestTo(x, y, z)
def FindElementsByPoint(self, x, y, z, elementType = SMESH.ALL, meshPart=None):
else:
return self.editor.FindElementsByPoint(x, y, z, elementType)
- def ProjectPoint(self, x,y,z, meshObject, elementType):
+ def ProjectPoint(self, x,y,z, elementType, meshObject=None):
"""
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 )):
+ if isinstance( meshObject, Mesh ):
meshObject = meshObject.GetMesh()
- return self.editor.ProjectPoint( x,y,z, meshObject, elementType )
+ if not meshObject:
+ meshObject = self.GetMesh()
+ return self.editor.ProjectPoint( x,y,z, elementType, meshObject )
def GetPointState(self, x, y, z):
"""
return self.editor.IsCoherentOrientation2D()
+ def Get1DBranches( self, edges, startNode = 0 ):
+ """
+ Partition given 1D elements into groups of contiguous edges.
+ A node where number of meeting edges != 2 is a group end.
+ An optional startNode is used to orient groups it belongs to.
+
+ Returns:
+ A list of edge groups and a list of corresponding node groups,
+ where the group is a list of IDs of edges or elements.
+ If a group is closed, the first and last nodes of the group are same.
+ """
+ if isinstance( edges, Mesh ):
+ edges = edges.GetMesh()
+ unRegister = genObjUnRegister()
+ if isinstance( edges, list ):
+ edges = self.GetIDSource( edges, SMESH.EDGE )
+ unRegister.set( edges )
+ return self.editor.Get1DBranches( edges, startNode )
+
def FindSharpEdges( self, angle, addExisting=False ):
"""
Return sharp edges of faces and non-manifold ones.
groups: list of :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>` of elements to make boundary around
Returns:
- tuple( long, mesh, groups )
+ tuple( long, mesh, group )
- long - number of added boundary elements
- mesh - the :class:`Mesh` where elements were added to
- group - the :class:`group <SMESH.SMESH_Group>` of boundary elements or None
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,
Parameters:
Tolerance: the value of tolerance
- SubMeshOrGroup: :class:`sub-mesh, group or filter <SMESH.SMESH_IDSource>`
+ SubMeshOrGroup: list of :class:`sub-meshes, groups or filters <SMESH.SMESH_IDSource>` 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
"""
unRegister = genObjUnRegister()
- if (isinstance( SubMeshOrGroup, Mesh )):
- SubMeshOrGroup = SubMeshOrGroup.GetMesh()
+ 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 ]
if exceptNodes and isinstance( exceptNodes[0], int ):
exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE )]
unRegister.set( exceptNodes )
+
return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance,
exceptNodes, SeparateCornerAndMediumNodes)
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 <SMESH.SMESH_IDSource>`
+ MeshOrSubMeshOrGroup: :class:`mesh, sub-meshes, groups or filters <SMESH.SMESH_IDSource>` 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):
"""
segments[i].vector = seg.vector
if isPreview:
return editor.GetPreviewData()
- return None
+ return None
+
+ def MakeSlot(self, segmentGroup, width ):
+ """
+ Create a slot of given width around given 1D elements lying on a triangle mesh.
+ The slot is consrtucted by cutting faces by cylindrical surfaces made
+ around each segment. Segments are expected to be created by MakePolyLine().
+
+ Returns:
+ FaceEdge's located at the slot boundary
+ """
+ return self.editor.MakeSlot( segmentGroup, width )
def GetFunctor(self, funcType ):
"""
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 [0,PI]. -1 if failure case.
+ """
+ p1 = self.GetNodeXYZ( node1 )
+ p2 = self.GetNodeXYZ( node2 )
+ p3 = self.GetNodeXYZ( node3 )
+ if p1 and p2 and p3:
+ return self.smeshpyD.GetAngle( p1,p2,p3 )
+ return -1.
+
+
def GetMaxElementLength(self, elemId):
"""
Get maximum element length.
