X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshBuilder.py;h=c6e1eabb45b8766ef572d75d31cc4f269217b336;hp=fb80a5abeb7590efb65f55191f196afbbed354f7;hb=b22e182dd1a2c30be324b21074158390d00714b3;hpb=b212155ceadd521a9244243ef03c65975fe2e1f0 diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py index fb80a5abe..c6e1eabb4 100644 --- a/src/SMESH_SWIG/smeshBuilder.py +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -1,9 +1,9 @@ -# Copyright (C) 2007-2013 CEA/DEN, EDF R&D, OPEN CASCADE +# Copyright (C) 2007-2015 CEA/DEN, EDF R&D, OPEN CASCADE # # This library is free software; you can redistribute it and/or # modify it under the terms of the GNU Lesser General Public # License as published by the Free Software Foundation; either -# version 2.1 of the License. +# version 2.1 of the License, or (at your option) any later version. # # This library is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of @@ -161,6 +161,9 @@ SMESH.PointStruct.__init__ = __initPointStruct # Substitute AxisStruct.__init__() to create SMESH.AxisStruct using notebook variables. # Parameters are stored in AxisStruct.parameters attribute def __initAxisStruct(ax,*args): + if len( args ) != 6: + raise RuntimeError,\ + "Bad nb args (%s) passed in SMESH.AxisStruct(x,y,z,dx,dy,dz)"%(len( args )) ax.x, ax.y, ax.z, ax.vx, ax.vy, ax.vz, ax.parameters,hasVars = ParseParameters(*args) pass SMESH.AxisStruct.__init__ = __initAxisStruct @@ -207,12 +210,15 @@ def GetName(obj): raise RuntimeError, "Null or invalid object" ## Prints error message if a hypothesis was not assigned. -def TreatHypoStatus(status, hypName, geomName, isAlgo): +def TreatHypoStatus(status, hypName, geomName, isAlgo, mesh): if isAlgo: hypType = "algorithm" else: hypType = "hypothesis" pass + reason = "" + if hasattr( status, "__getitem__" ): + status,reason = status[0],status[1] if status == HYP_UNKNOWN_FATAL : reason = "for unknown reason" elif status == HYP_INCOMPATIBLE : @@ -235,17 +241,24 @@ def TreatHypoStatus(status, hypName, geomName, isAlgo): elif status == HYP_HIDING_ALGO: reason = "it hides algorithms of lower dimensions by generating elements of all dimensions" elif status == HYP_NEED_SHAPE: - reason = "Algorithm can't work without shape" + reason = "algorithm can't work without shape" + elif status == HYP_INCOMPAT_HYPS: + pass else: return - hypName = '"' + hypName + '"' - geomName= '"' + geomName+ '"' - if status < HYP_UNKNOWN_FATAL and not geomName =='""': - print hypName, "was assigned to", geomName,"but", reason - elif not geomName == '""': - print hypName, "was not assigned to",geomName,":", reason + where = geomName + if where: + where = '"%s"' % geomName + if mesh: + meshName = GetName( mesh ) + if meshName and meshName != NO_NAME: + where = '"%s" in "%s"' % ( geomName, meshName ) + if status < HYP_UNKNOWN_FATAL and where: + print '"%s" was assigned to %s but %s' %( hypName, where, reason ) + elif where: + print '"%s" was not assigned to %s : %s' %( hypName, where, reason ) else: - print hypName, "was not assigned:", reason + print '"%s" was not assigned : %s' %( hypName, reason ) pass ## Private method. Add geom (sub-shape of the main shape) into the study if not yet there @@ -383,10 +396,16 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): def init_smesh(self,theStudy,geompyD = None): #print "init_smesh" self.SetCurrentStudy(theStudy,geompyD) - - ## Creates an empty Mesh. This mesh can have an underlying geometry. - # @param obj the Geometrical object on which the mesh is built. If not defined, - # the mesh will have no underlying geometry. + if theStudy: + global notebook + notebook.myStudy = theStudy + + ## Creates a mesh. This can be either an empty mesh, possibly having an underlying geometry, + # or a mesh wrapping a CORBA mesh given as a parameter. + # @param obj either (1) a CORBA mesh (SMESH._objref_SMESH_Mesh) got e.g. by calling + # salome.myStudy.FindObjectID("0:1:2:3").GetObject() or + # (2) a Geometrical object for meshing or + # (3) none. # @param name the name for the new mesh. # @return an instance of Mesh class. # @ingroup l2_construct @@ -450,7 +469,9 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): # @return SMESH.AxisStruct # @ingroup l1_auxiliary def GetAxisStruct(self,theObj): + import GEOM edges = self.geompyD.SubShapeAll( theObj, geomBuilder.geomBuilder.ShapeType["EDGE"] ) + axis = None if len(edges) > 1: vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) vertex3, vertex4 = self.geompyD.SubShapeAll( edges[1], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) @@ -462,14 +483,18 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): v2 = [vertex4[0]-vertex3[0], vertex4[1]-vertex3[1], vertex4[2]-vertex3[2]] 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] ] axis = AxisStruct(vertex1[0], vertex1[1], vertex1[2], normal[0], normal[1], normal[2]) - return axis + axis._mirrorType = SMESH.SMESH_MeshEditor.PLANE elif len(edges) == 1: vertex1, vertex2 = self.geompyD.SubShapeAll( edges[0], geomBuilder.geomBuilder.ShapeType["VERTEX"] ) p1 = self.geompyD.PointCoordinates( vertex1 ) p2 = self.geompyD.PointCoordinates( vertex2 ) axis = AxisStruct(p1[0], p1[1], p1[2], p2[0]-p1[0], p2[1]-p1[1], p2[2]-p1[2]) - return axis - return None + axis._mirrorType = SMESH.SMESH_MeshEditor.AXIS + elif theObj.GetShapeType() == GEOM.VERTEX: + x,y,z = self.geompyD.PointCoordinates( theObj ) + axis = AxisStruct( x,y,z, 1,0,0,) + axis._mirrorType = SMESH.SMESH_MeshEditor.POINT + return axis # From SMESH_Gen interface: # ------------------------ @@ -498,7 +523,8 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): #return self.IsEmbeddedMode() return SMESH._objref_SMESH_Gen.IsEmbeddedMode(self) - ## Sets the current study + ## Sets the current study. Calling SetCurrentStudy( None ) allows to + # switch OFF automatic pubilishing in the Study of mesh objects. # @ingroup l1_auxiliary def SetCurrentStudy( self, theStudy, geompyD = None ): #self.SetCurrentStudy(theStudy) @@ -514,6 +540,12 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): notebook = salome_notebook.NoteBook( theStudy ) else: notebook = salome_notebook.NoteBook( salome_notebook.PseudoStudyForNoteBook() ) + if theStudy: + sb = theStudy.NewBuilder() + sc = theStudy.FindComponent("SMESH") + if sc: sb.LoadWith(sc, self) + pass + pass ## Gets the current study # @ingroup l1_auxiliary @@ -573,14 +605,15 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): if error.comment: print "*** CreateMeshesFromGMF() errors:\n", error.comment return Mesh(self, self.geompyD, aSmeshMesh), error - ## Concatenate the given meshes into one mesh. - # @return an instance of Mesh class - # @param meshes the meshes to combine into one mesh + ## Concatenate the given meshes into one mesh. All groups of input meshes will be + # present in the new mesh. + # @param meshes the meshes, sub-meshes and groups to combine into one mesh # @param uniteIdenticalGroups if true, groups with same names are united, else they are renamed - # @param mergeNodesAndElements if true, equal nodes and elements aremerged + # @param mergeNodesAndElements if true, equal nodes and elements are merged # @param mergeTolerance tolerance for merging nodes - # @param allGroups forces creation of groups of all elements + # @param allGroups forces creation of groups corresponding to every input mesh # @param name name of a new mesh + # @return an instance of Mesh class def Concatenate( self, meshes, uniteIdenticalGroups, mergeNodesAndElements = False, mergeTolerance = 1e-5, allGroups = False, name = ""): @@ -605,7 +638,7 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): # pass result of Mesh.GetIDSource( list_of_ids, type ) as meshPart # @param meshName a name of the new mesh # @param toCopyGroups to create in the new mesh groups the copied elements belongs to - # @param toKeepIDs to preserve IDs of the copied elements or not + # @param toKeepIDs to preserve order of the copied elements or not # @return an instance of Mesh class def CopyMesh( self, meshPart, meshName, toCopyGroups=False, toKeepIDs=False): if (isinstance( meshPart, Mesh )): @@ -699,7 +732,7 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface, FT_BelongToCylinder, FT_LyingOnGeom]: - # Checks that Threshold is GEOM object + # Check that Threshold is GEOM object if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object): aCriterion.ThresholdStr = GetName(aThreshold) aCriterion.ThresholdID = aThreshold.GetStudyEntry() @@ -708,23 +741,39 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): if not name: name = "%s_%s"%(aThreshold.GetShapeType(), id(aThreshold)%10000) aCriterion.ThresholdID = self.geompyD.addToStudy( aThreshold, name ) - #raise RuntimeError, "Threshold shape must be published" + # or a name of GEOM object + elif isinstance( aThreshold, str ): + aCriterion.ThresholdStr = aThreshold else: - print "Error: The Threshold should be a shape." - return None + raise TypeError, "The Threshold should be a shape." if isinstance(UnaryOp,float): aCriterion.Tolerance = UnaryOp UnaryOp = FT_Undefined pass + elif CritType == FT_BelongToMeshGroup: + # Check that Threshold is a group + if isinstance(aThreshold, SMESH._objref_SMESH_GroupBase): + if aThreshold.GetType() != elementType: + raise ValueError, "Group type mismatches Element type" + aCriterion.ThresholdStr = aThreshold.GetName() + aCriterion.ThresholdID = salome.orb.object_to_string( aThreshold ) + study = self.GetCurrentStudy() + if study: + so = study.FindObjectIOR( aCriterion.ThresholdID ) + if so: + entry = so.GetID() + if entry: + aCriterion.ThresholdID = entry + else: + raise TypeError, "The Threshold should be a Mesh Group" elif CritType == FT_RangeOfIds: - # Checks that Threshold is string + # Check that Threshold is string if isinstance(aThreshold, str): aCriterion.ThresholdStr = aThreshold else: - print "Error: The Threshold should be a string." - return None + raise TypeError, "The Threshold should be a string." elif CritType == FT_CoplanarFaces: - # Checks the Threshold + # Check the Threshold if isinstance(aThreshold, int): aCriterion.ThresholdID = str(aThreshold) elif isinstance(aThreshold, str): @@ -733,10 +782,10 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold aCriterion.ThresholdID = aThreshold else: - raise ValueError,\ + raise TypeError,\ "The Threshold should be an ID of mesh face and not '%s'"%aThreshold elif CritType == FT_ConnectedElements: - # Checks the Threshold + # Check the Threshold if isinstance(aThreshold, geomBuilder.GEOM._objref_GEOM_Object): # shape aCriterion.ThresholdID = aThreshold.GetStudyEntry() if not aCriterion.ThresholdID: @@ -756,11 +805,11 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): else: aCriterion.ThresholdStr = aThreshold # hope that it's point coordinates else: - raise ValueError,\ + raise TypeError,\ "The Threshold should either a VERTEX, or a node ID, "\ "or a list of point coordinates and not '%s'"%aThreshold elif CritType == FT_ElemGeomType: - # Checks the Threshold + # Check the Threshold try: aCriterion.Threshold = self.EnumToLong(aThreshold) assert( aThreshold in SMESH.GeometryType._items ) @@ -768,12 +817,11 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): if isinstance(aThreshold, int): aCriterion.Threshold = aThreshold else: - print "Error: The Threshold should be an integer or SMESH.GeometryType." - return None + raise TypeError, "The Threshold should be an integer or SMESH.GeometryType." pass pass elif CritType == FT_EntityType: - # Checks the Threshold + # Check the Threshold try: aCriterion.Threshold = self.EnumToLong(aThreshold) assert( aThreshold in SMESH.EntityType._items ) @@ -781,18 +829,16 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): if isinstance(aThreshold, int): aCriterion.Threshold = aThreshold else: - print "Error: The Threshold should be an integer or SMESH.EntityType." - return None + raise TypeError, "The Threshold should be an integer or SMESH.EntityType." pass pass elif CritType == FT_GroupColor: - # Checks the Threshold + # Check the Threshold try: aCriterion.ThresholdStr = self.ColorToString(aThreshold) except: - print "Error: The threshold value should be of SALOMEDS.Color type" - return None + raise TypeError, "The threshold value should be of SALOMEDS.Color type" pass elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces, FT_LinearOrQuadratic, FT_BadOrientedVolume, @@ -810,7 +856,7 @@ class smeshBuilder(object, SMESH._objref_SMESH_Gen): aThreshold = float(aThreshold) aCriterion.Threshold = aThreshold except: - print "Error: The Threshold should be a number." + raise TypeError, "The Threshold should be a number." return None if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT: @@ -1212,7 +1258,6 @@ class Mesh: for attrName in dir(self): attr = getattr( self, attrName ) if isinstance( attr, algoCreator ): - #print "algoCreator ", attrName setattr( self, attrName, attr.copy( self )) pass pass @@ -1347,9 +1392,10 @@ class Mesh: # @param discardModifs if True and the mesh has been edited since # a last total re-compute and that may prevent successful partial re-compute, # then the mesh is cleaned before Compute() + # @param refresh if @c True, Object browser is automatically updated (when running in GUI) # @return True or False # @ingroup l2_construct - def Compute(self, geom=0, discardModifs=False): + def Compute(self, geom=0, discardModifs=False, refresh=False): if geom == 0 or not isinstance(geom, geomBuilder.GEOM._objref_GEOM_Object): if self.geom == 0: geom = self.mesh.GetShapeToMesh() @@ -1477,7 +1523,7 @@ class Mesh: smeshgui = salome.ImportComponentGUI("SMESH") smeshgui.Init(self.mesh.GetStudyId()) smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), ok, (self.NbNodes()==0) ) - salome.sg.updateObjBrowser(1) + if refresh: salome.sg.updateObjBrowser(1) pass return ok @@ -1494,27 +1540,30 @@ class Mesh: return self.mesh.SetMeshOrder(submeshes) ## Removes all nodes and elements + # @param refresh if @c True, Object browser is automatically updated (when running in GUI) # @ingroup l2_construct - def Clear(self): + def Clear(self, refresh=False): self.mesh.Clear() if ( salome.sg.hasDesktop() and - salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() )): + salome.myStudyManager.GetStudyByID( self.mesh.GetStudyId() ) ): smeshgui = salome.ImportComponentGUI("SMESH") smeshgui.Init(self.mesh.GetStudyId()) smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) - salome.sg.updateObjBrowser(1) + if refresh: salome.sg.updateObjBrowser(1) ## Removes all nodes and elements of indicated shape + # @param refresh if @c True, Object browser is automatically updated (when running in GUI) + # @param geomId the ID of a sub-shape to remove elements on # @ingroup l2_construct - def ClearSubMesh(self, geomId): + def ClearSubMesh(self, geomId, refresh=False): self.mesh.ClearSubMesh(geomId) if salome.sg.hasDesktop(): smeshgui = salome.ImportComponentGUI("SMESH") smeshgui.Init(self.mesh.GetStudyId()) smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) - salome.sg.updateObjBrowser(1) + if refresh: salome.sg.updateObjBrowser(1) - ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + NETGEN + ## Computes a tetrahedral mesh using AutomaticLength + MEFISTO + Tetrahedron # @param fineness [0.0,1.0] defines mesh fineness # @return True or False # @ingroup l3_algos_basic @@ -1527,8 +1576,7 @@ class Mesh: self.Triangle().LengthFromEdges() pass if dim > 2 : - from salome.NETGENPlugin.NETGENPluginBuilder import NETGEN - self.Tetrahedron(NETGEN) + self.Tetrahedron() pass return self.Compute() @@ -1563,14 +1611,25 @@ class Mesh: if not geom: geom = self.mesh.GetShapeToMesh() pass - AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) - status = self.mesh.AddHypothesis(geom, hyp) - isAlgo = hyp._narrow( SMESH_Algo ) + isApplicable = True + if self.mesh.HasShapeToMesh(): + hyp_type = hyp.GetName() + lib_name = hyp.GetLibName() + checkAll = ( not geom.IsSame( self.mesh.GetShapeToMesh() )) + if checkAll and geom: + checkAll = geom.GetType() == 37 + isApplicable = self.smeshpyD.IsApplicable(hyp_type, lib_name, geom, checkAll) + if isApplicable: + AssureGeomPublished( self, geom, "shape for %s" % hyp.GetName()) + status = self.mesh.AddHypothesis(geom, hyp) + else: + status = HYP_BAD_GEOMETRY,"" hyp_name = GetName( hyp ) geom_name = "" if geom: - geom_name = GetName( geom ) - TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) + geom_name = geom.GetName() + isAlgo = hyp._narrow( SMESH_Algo ) + TreatHypoStatus( status, hyp_name, geom_name, isAlgo, self ) return status ## Return True if an algorithm of hypothesis is assigned to a given shape @@ -1641,17 +1700,24 @@ class Mesh: # - 1D if all mesh nodes lie on OX coordinate axis, or # - 2D if all mesh nodes lie on XOY coordinate plane, or # - 3D in the rest cases. - # # If @a autoDimension is @c False, the space dimension is always 3. + # @param fields : list of GEOM fields defined on the shape to mesh. + # @param 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. # @ingroup l2_impexp def ExportMED(self, f, auto_groups=0, version=MED_V2_2, - overwrite=1, meshPart=None, autoDimension=True): - if meshPart: + overwrite=1, meshPart=None, autoDimension=True, fields=[], geomAssocFields=''): + if meshPart or fields or geomAssocFields: unRegister = genObjUnRegister() if isinstance( meshPart, list ): meshPart = self.GetIDSource( meshPart, SMESH.ALL ) unRegister.set( meshPart ) - self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension) + self.mesh.ExportPartToMED( meshPart, f, auto_groups, version, overwrite, autoDimension, + fields, geomAssocFields) else: self.mesh.ExportToMEDX(f, auto_groups, version, overwrite, autoDimension) @@ -1837,7 +1903,12 @@ class Mesh: # @ingroup l2_grps_create def MakeGroupByIds(self, groupName, elementType, elemIDs): group = self.mesh.CreateGroup(elementType, groupName) - group.Add(elemIDs) + if hasattr( elemIDs, "GetIDs" ): + if hasattr( elemIDs, "SetMesh" ): + elemIDs.SetMesh( self.GetMesh() ) + group.AddFrom( elemIDs ) + else: + group.Add(elemIDs) return group ## Creates a mesh group by the given conditions @@ -1849,7 +1920,7 @@ class Mesh: # @param UnaryOp FT_LogicalNOT or FT_Undefined # @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface, # FT_LyingOnGeom, FT_CoplanarFaces criteria - # @return SMESH_Group + # @return SMESH_GroupOnFilter # @ingroup l2_grps_create def MakeGroup(self, groupName, @@ -1866,40 +1937,32 @@ class Mesh: ## Creates a mesh group by the given criterion # @param groupName the name of the mesh group # @param Criterion the instance of Criterion class - # @return SMESH_Group + # @return SMESH_GroupOnFilter # @ingroup l2_grps_create def MakeGroupByCriterion(self, groupName, Criterion): - aFilterMgr = self.smeshpyD.CreateFilterManager() - aFilter = aFilterMgr.CreateFilter() - aCriteria = [] - aCriteria.append(Criterion) - aFilter.SetCriteria(aCriteria) - group = self.MakeGroupByFilter(groupName, aFilter) - aFilterMgr.UnRegister() - return group + return self.MakeGroupByCriteria( groupName, [Criterion] ) ## Creates a mesh group by the given criteria (list of criteria) # @param groupName the name of the mesh group # @param theCriteria the list of criteria - # @return SMESH_Group + # @param binOp binary operator used when binary operator of criteria is undefined + # @return SMESH_GroupOnFilter # @ingroup l2_grps_create - def MakeGroupByCriteria(self, groupName, theCriteria): - aFilterMgr = self.smeshpyD.CreateFilterManager() - aFilter = aFilterMgr.CreateFilter() - aFilter.SetCriteria(theCriteria) + def MakeGroupByCriteria(self, groupName, theCriteria, binOp=SMESH.FT_LogicalAND): + aFilter = self.smeshpyD.GetFilterFromCriteria( theCriteria, binOp ) group = self.MakeGroupByFilter(groupName, aFilter) - aFilterMgr.UnRegister() return group ## Creates a mesh group by the given filter # @param groupName the name of the mesh group # @param theFilter the instance of Filter class - # @return SMESH_Group + # @return SMESH_GroupOnFilter # @ingroup l2_grps_create def MakeGroupByFilter(self, groupName, theFilter): - group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName) - theFilter.SetMesh( self.mesh ) - group.AddFrom( theFilter ) + #group = self.CreateEmptyGroup(theFilter.GetElementType(), groupName) + #theFilter.SetMesh( self.mesh ) + #group.AddFrom( theFilter ) + group = self.GroupOnFilter( theFilter.GetElementType(), groupName, theFilter ) return group ## Removes a group @@ -1912,7 +1975,8 @@ class Mesh: def RemoveGroupWithContents(self, group): self.mesh.RemoveGroupWithContents(group) - ## Gets the list of groups existing in the mesh in the order of creation (starting from the oldest one) + ## Gets the list of groups existing in the mesh in the order + # of creation (starting from the oldest one) # @return a sequence of SMESH_GroupBase # @ingroup l2_grps_create def GetGroups(self): @@ -1934,7 +1998,7 @@ class Mesh: names.append(group.GetName()) return names - ## Produces a union of two groups + ## Produces a union of two groups. # A new group is created. All mesh elements that are # present in the initial groups are added to the new one # @return an instance of SMESH_Group @@ -1942,7 +2006,7 @@ class Mesh: def UnionGroups(self, group1, group2, name): return self.mesh.UnionGroups(group1, group2, name) - ## Produces a union list of groups + ## Produces a union list of groups. # New group is created. All mesh elements that are present in # initial groups are added to the new one # @return an instance of SMESH_Group @@ -1950,7 +2014,7 @@ class Mesh: def UnionListOfGroups(self, groups, name): return self.mesh.UnionListOfGroups(groups, name) - ## Prodices an intersection of two groups + ## Prodices an intersection of two groups. # A new group is created. All mesh elements that are common # for the two initial groups are added to the new one. # @return an instance of SMESH_Group @@ -1958,7 +2022,7 @@ class Mesh: def IntersectGroups(self, group1, group2, name): return self.mesh.IntersectGroups(group1, group2, name) - ## Produces an intersection of groups + ## Produces an intersection of groups. # New group is created. All mesh elements that are present in all # initial groups simultaneously are added to the new one # @return an instance of SMESH_Group @@ -1966,7 +2030,7 @@ class Mesh: def IntersectListOfGroups(self, groups, name): return self.mesh.IntersectListOfGroups(groups, name) - ## Produces a cut of two groups + ## Produces a cut of two groups. # A new group is created. All mesh elements that are present in # the main group but are not present in the tool group are added to the new one # @return an instance of SMESH_Group @@ -1974,22 +2038,35 @@ class Mesh: def CutGroups(self, main_group, tool_group, name): return self.mesh.CutGroups(main_group, tool_group, name) - ## Produces a cut of groups + ## Produces a cut of groups. # A new group is created. All mesh elements that are present in main groups # but do not present in tool groups are added to the new one # @return an instance of SMESH_Group # @ingroup l2_grps_operon def CutListOfGroups(self, main_groups, tool_groups, name): - return self.mesh.CutListOfGroups(main_groups, tool_groups, name) + return self.mesh.CutListOfGroups(main_groups, tool_groups, name) - ## Produces a group of elements of specified type using list of existing groups - # A new group is created. System - # 1) extracts all nodes on which groups elements are built - # 2) combines all elements of specified dimension laying on these nodes + ## + # Create a standalone group of entities basing on nodes of other groups. + # \param groups - list of groups, sub-meshes or filters, of any type. + # \param elemType - a type of elements to include to the new group. + # \param name - a name of the new group. + # \param nbCommonNodes - a criterion of inclusion of an element to the new group + # basing on number of element nodes common with reference \a groups. + # Meaning of possible values are: + # - SMESH.ALL_NODES - include if all nodes are common, + # - SMESH.MAIN - include if all corner nodes are common (meaningful for a quadratic mesh), + # - SMESH.AT_LEAST_ONE - include if one or more node is common, + # - SMEHS.MAJORITY - include if half of nodes or more are common. + # \param underlyingOnly - if \c True (default), an element is included to the + # new group provided that it is based on nodes of one element of \a groups. # @return an instance of SMESH_Group # @ingroup l2_grps_operon - def CreateDimGroup(self, groups, elem_type, name): - return self.mesh.CreateDimGroup(groups, elem_type, name) + def CreateDimGroup(self, groups, elemType, name, + nbCommonNodes = SMESH.ALL_NODES, underlyingOnly = True): + if isinstance( groups, SMESH._objref_SMESH_IDSource ): + groups = [groups] + return self.mesh.CreateDimGroup(groups, elemType, name, nbCommonNodes, underlyingOnly) ## Convert group on geom into standalone group @@ -2165,11 +2242,11 @@ class Mesh: def NbBiQuadQuadrangles(self): return self.mesh.NbBiQuadQuadrangles() - ## Returns the number of polygons in the mesh + ## Returns the number of polygons of given order in the mesh # @return an integer value # @ingroup l1_meshinfo - def NbPolygons(self): - return self.mesh.NbPolygons() + def NbPolygons(self, elementOrder = SMESH.ORDER_ANY): + return self.mesh.NbPolygons(elementOrder) ## Returns the number of volumes in the mesh # @return an integer value @@ -2290,7 +2367,7 @@ class Mesh: ## Returns the type of mesh element # @return the value from SMESH::ElementType enumeration # @ingroup l1_meshinfo - def GetElementType(self, id, iselem): + def GetElementType(self, id, iselem=True): return self.mesh.GetElementType(id, iselem) ## Returns the geometric type of mesh element @@ -2378,24 +2455,22 @@ class Mesh: def GetElementPosition(self,ElemID): return self.mesh.GetElementPosition(ElemID) - ## If the given element is a node, returns the ID of shape - # \n If there is no node for the given ID - returns -1 - # @return an integer value + ## Returns the ID of the shape, on which the given node was generated. + # @return an integer value > 0 or -1 if there is no node for the given + # ID or the node is not assigned to any geometry # @ingroup l1_meshinfo def GetShapeID(self, id): return self.mesh.GetShapeID(id) - ## Returns the ID of the result shape after - # FindShape() from SMESH_MeshEditor for the given element - # \n If there is no element for the given ID - returns -1 - # @return an integer value + ## Returns the ID of the shape, on which the given element was generated. + # @return an integer value > 0 or -1 if there is no element for the given + # ID or the element is not assigned to any geometry # @ingroup l1_meshinfo def GetShapeIDForElem(self,id): return self.mesh.GetShapeIDForElem(id) - ## Returns the number of nodes for the given element - # \n If there is no element for the given ID - returns -1 - # @return an integer value + ## Returns the number of nodes of the given element + # @return an integer value > 0 or -1 if there is no element for the given ID # @ingroup l1_meshinfo def GetElemNbNodes(self, id): return self.mesh.GetElemNbNodes(id) @@ -2421,7 +2496,7 @@ class Mesh: ## Returns true if the given node is the medium node in one of quadratic elements # @ingroup l1_meshinfo - def IsMediumNodeOfAnyElem(self, nodeID, elementType): + def IsMediumNodeOfAnyElem(self, nodeID, elementType = SMESH.ALL ): return self.mesh.IsMediumNodeOfAnyElem(nodeID, elementType) ## Returns the number of edges for the given element @@ -2549,7 +2624,7 @@ class Mesh: ## Get measure structure specifying bounding box data of the specified object(s) # @param IDs single source object or list of source objects or list of nodes/elements IDs - # @param isElem if @a objects is a list of IDs, @c True value in this parameters specifies that @a objects are elements, + # @param isElem if @a IDs is a list of IDs, @c True value in this parameters specifies that @a objects are elements, # @c False specifies that @a objects are nodes # @return Measure structure # @sa BoundingBox() @@ -2679,6 +2754,14 @@ class Mesh: def AddPolygonalFace(self, IdsOfNodes): return self.editor.AddPolygonalFace(IdsOfNodes) + ## Adds a quadratic polygonal face to the mesh by the list of node IDs + # @param IdsOfNodes the list of node IDs for creation of the element; + # corner nodes follow first. + # @return the Id of the new face + # @ingroup l2_modif_add + def AddQuadPolygonalFace(self, IdsOfNodes): + return self.editor.AddQuadPolygonalFace(IdsOfNodes) + ## Creates both simple and quadratic volume (this is determined # by the number of given nodes). # @param IDsOfNodes the list of node IDs for creation of the element. @@ -2935,6 +3018,37 @@ class Mesh: theFace = -1 return self.editor.Reorient2D( the2DObject, theDirection, theFace, thePoint ) + ## Reorient faces according to adjacent volumes. + # @param the2DObject is a mesh, sub-mesh, group or list of + # either IDs of faces or face groups. + # @param the3DObject is a mesh, sub-mesh, group or list of IDs of volumes. + # @param theOutsideNormal to orient faces to have their normals + # pointing either \a outside or \a inside the adjacent volumes. + # @return number of reoriented faces. + # @ingroup l2_modif_changori + def Reorient2DBy3D(self, the2DObject, the3DObject, theOutsideNormal=True ): + unRegister = genObjUnRegister() + # check the2DObject + if not isinstance( the2DObject, list ): + the2DObject = [ the2DObject ] + elif the2DObject and isinstance( the2DObject[0], int ): + the2DObject = self.GetIDSource( the2DObject, SMESH.FACE ) + unRegister.set( the2DObject ) + the2DObject = [ the2DObject ] + for i,obj2D in enumerate( the2DObject ): + if isinstance( obj2D, Mesh ): + the2DObject[i] = obj2D.GetMesh() + if isinstance( obj2D, list ): + the2DObject[i] = self.GetIDSource( obj2D, SMESH.FACE ) + unRegister.set( the2DObject[i] ) + # check the3DObject + if isinstance( the3DObject, Mesh ): + the3DObject = the3DObject.GetMesh() + if isinstance( the3DObject, list ): + the3DObject = self.GetIDSource( the3DObject, SMESH.VOLUME ) + unRegister.set( the3DObject ) + return self.editor.Reorient2DBy3D( the2DObject, the3DObject, theOutsideNormal ) + ## Fuses the neighbouring triangles into quadrangles. # @param IDsOfElements The triangles to be fused, # @param theCriterion is a numerical functor, in terms of enum SMESH.FunctorType, used to @@ -3320,11 +3434,11 @@ class Mesh: # them with quadratic with the same id. # @param theForce3d new node creation method: # 0 - the medium node lies at the geometrical entity from which the mesh element is built - # 1 - the medium node lies at the middle of the line segments connecting start and end node of a mesh element + # 1 - the medium node lies at the middle of the line segments connecting two nodes of a mesh element # @param theSubMesh a group or a sub-mesh to convert; WARNING: in this case the mesh can become not conformal # @param theToBiQuad If True, converts the mesh to bi-quadratic # @ingroup l2_modif_tofromqu - def ConvertToQuadratic(self, theForce3d, theSubMesh=None, theToBiQuad=False): + def ConvertToQuadratic(self, theForce3d=False, theSubMesh=None, theToBiQuad=False): if isinstance( theSubMesh, Mesh ): theSubMesh = theSubMesh.mesh if theToBiQuad: @@ -3389,7 +3503,7 @@ class Mesh: ## # @brief Creates missing boundary elements around either the whole mesh or - # groups of 2D elements + # groups of elements # @param dimension - defines type of boundary elements to create # @param groupName - a name of group to store all boundary elements in, # "" means not to create the group @@ -3397,7 +3511,7 @@ class Mesh: # mesh + created boundary elements; "" means not to create the new mesh # @param toCopyAll - if true, the whole initial mesh will be copied into # the new mesh else only boundary elements will be copied into the new mesh - # @param groups - groups of 2D elements to make boundary around + # @param groups - groups of elements to make boundary around # @retval tuple( long, mesh, groups ) # long - number of added boundary elements # mesh - the mesh where elements were added to @@ -3410,20 +3524,37 @@ class Mesh: if mesh: mesh = self.smeshpyD.Mesh(mesh) return nb, mesh, group - ## Renumber mesh nodes + ## Renumber mesh nodes (Obsolete, does nothing) # @ingroup l2_modif_renumber def RenumberNodes(self): self.editor.RenumberNodes() - ## Renumber mesh elements + ## Renumber mesh elements (Obsole, does nothing) # @ingroup l2_modif_renumber def RenumberElements(self): self.editor.RenumberElements() - ## Generates new elements by rotation of the elements around the axis - # @param IDsOfElements the list of ids of elements to sweep - # @param Axis the axis of rotation, AxisStruct or line(geom object) - # @param AngleInRadians the angle of Rotation (in radians) or a name of variable which defines angle in degrees + ## Private method converting \a arg into a list of SMESH_IdSource's + def _getIdSourceList(self, arg, idType, unRegister): + if arg and isinstance( arg, list ): + if isinstance( arg[0], int ): + arg = self.GetIDSource( arg, idType ) + unRegister.set( arg ) + elif isinstance( arg[0], Mesh ): + arg[0] = arg[0].GetMesh() + elif isinstance( arg, Mesh ): + arg = arg.GetMesh() + if arg and isinstance( arg, SMESH._objref_SMESH_IDSource ): + arg = [arg] + return arg + + ## Generates new elements by rotation of the given elements and nodes around the axis + # @param nodes - nodes to revolve: a list including ids, groups, sub-meshes or a mesh + # @param edges - edges to revolve: a list including ids, groups, sub-meshes or a mesh + # @param faces - faces to revolve: a list including ids, groups, sub-meshes or a mesh + # @param Axis the axis of rotation: AxisStruct, line (geom object) or [x,y,z,dx,dy,dz] + # @param AngleInRadians the angle of Rotation (in radians) or a name of variable + # which defines angle in degrees # @param NbOfSteps the number of steps # @param Tolerance tolerance # @param MakeGroups forces the generation of new groups from existing ones @@ -3431,23 +3562,44 @@ class Mesh: # of all steps, else - size of each step # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance, - MakeGroups=False, TotalAngle=False): - if IDsOfElements == []: - IDsOfElements = self.GetElementsId() - if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): - Axis = self.smeshpyD.GetAxisStruct(Axis) + def RotationSweepObjects(self, nodes, edges, faces, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + unRegister = genObjUnRegister() + nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister ) + edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister ) + faces = self._getIdSourceList( faces, SMESH.FACE, unRegister ) + + if isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object): + Axis = self.smeshpyD.GetAxisStruct( Axis ) + if isinstance( Axis, list ): + Axis = SMESH.AxisStruct( *Axis ) + AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters self.mesh.SetParameters(Parameters) if TotalAngle and NbOfSteps: AngleInRadians /= NbOfSteps - if MakeGroups: - return self.editor.RotationSweepMakeGroups(IDsOfElements, Axis, - AngleInRadians, NbOfSteps, Tolerance) - self.editor.RotationSweep(IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance) - return [] + return self.editor.RotationSweepObjects( nodes, edges, faces, + Axis, AngleInRadians, + NbOfSteps, Tolerance, MakeGroups) + + ## Generates new elements by rotation of the elements around the axis + # @param IDsOfElements the list of ids of elements to sweep + # @param Axis the axis of rotation, AxisStruct or line(geom object) + # @param AngleInRadians the angle of Rotation (in radians) or a name of variable which defines angle in degrees + # @param NbOfSteps the number of steps + # @param Tolerance tolerance + # @param MakeGroups forces the generation of new groups from existing ones + # @param TotalAngle gives meaning of AngleInRadians: if True then it is an angular size + # of all steps, else - size of each step + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def RotationSweep(self, IDsOfElements, Axis, AngleInRadians, NbOfSteps, Tolerance, + MakeGroups=False, TotalAngle=False): + return self.RotationSweepObjects([], IDsOfElements, IDsOfElements, Axis, + AngleInRadians, NbOfSteps, Tolerance, + MakeGroups, TotalAngle) ## Generates new elements by rotation of the elements of object around the axis # @param theObject object which elements should be sweeped. @@ -3463,21 +3615,9 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): - Axis = self.smeshpyD.GetAxisStruct(Axis) - AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) - NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) - Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if TotalAngle and NbOfSteps: - AngleInRadians /= NbOfSteps - if MakeGroups: - return self.editor.RotationSweepObjectMakeGroups(theObject, Axis, AngleInRadians, - NbOfSteps, Tolerance) - self.editor.RotationSweepObject(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) - return [] + return self.RotationSweepObjects( [], theObject, theObject, Axis, + AngleInRadians, NbOfSteps, Tolerance, + MakeGroups, TotalAngle ) ## Generates new elements by rotation of the elements of object around the axis # @param theObject object which elements should be sweeped. @@ -3493,21 +3633,9 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject1D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): - Axis = self.smeshpyD.GetAxisStruct(Axis) - AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) - NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) - Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if TotalAngle and NbOfSteps: - AngleInRadians /= NbOfSteps - if MakeGroups: - return self.editor.RotationSweepObject1DMakeGroups(theObject, Axis, AngleInRadians, - NbOfSteps, Tolerance) - self.editor.RotationSweepObject1D(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) - return [] + return self.RotationSweepObjects([],theObject,[], Axis, + AngleInRadians, NbOfSteps, Tolerance, + MakeGroups, TotalAngle) ## Generates new elements by rotation of the elements of object around the axis # @param theObject object which elements should be sweeped. @@ -3523,77 +3651,92 @@ class Mesh: # @ingroup l2_modif_extrurev def RotationSweepObject2D(self, theObject, Axis, AngleInRadians, NbOfSteps, Tolerance, MakeGroups=False, TotalAngle=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( Axis, geomBuilder.GEOM._objref_GEOM_Object)): - Axis = self.smeshpyD.GetAxisStruct(Axis) - AngleInRadians,AngleParameters,hasVars = ParseAngles(AngleInRadians) - NbOfSteps,Tolerance,Parameters,hasVars = ParseParameters(NbOfSteps,Tolerance) - Parameters = Axis.parameters + var_separator + AngleParameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if TotalAngle and NbOfSteps: - AngleInRadians /= NbOfSteps - if MakeGroups: - return self.editor.RotationSweepObject2DMakeGroups(theObject, Axis, AngleInRadians, - NbOfSteps, Tolerance) - self.editor.RotationSweepObject2D(theObject, Axis, AngleInRadians, NbOfSteps, Tolerance) - return [] + return self.RotationSweepObjects([],[],theObject, Axis, AngleInRadians, + NbOfSteps, Tolerance, MakeGroups, TotalAngle) - ## Generates new elements by extrusion of the elements with given ids - # @param IDsOfElements the list of elements ids for extrusion + ## Generates new elements by extrusion of the given elements and nodes + # @param nodes - nodes to extrude: a list including ids, groups, sub-meshes or a mesh + # @param edges - edges to extrude: a list including ids, groups, sub-meshes or a mesh + # @param faces - faces to extrude: a list including ids, groups, sub-meshes or a mesh # @param StepVector vector or DirStruct or 3 vector components, defining # the direction and value of extrusion for one step (the total extrusion # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones - # @param IsNodes is True if elements with given ids are nodes # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): - if IDsOfElements == []: - IDsOfElements = self.GetElementsId() + def ExtrusionSweepObjects(self, nodes, edges, faces, StepVector, NbOfSteps, MakeGroups=False): + unRegister = genObjUnRegister() + nodes = self._getIdSourceList( nodes, SMESH.NODE, unRegister ) + edges = self._getIdSourceList( edges, SMESH.EDGE, unRegister ) + faces = self._getIdSourceList( faces, SMESH.FACE, unRegister ) + if isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object): StepVector = self.smeshpyD.GetDirStruct(StepVector) if isinstance( StepVector, list ): StepVector = self.smeshpyD.MakeDirStruct(*StepVector) + NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) Parameters = StepVector.PS.parameters + var_separator + Parameters self.mesh.SetParameters(Parameters) - if MakeGroups: - if(IsNodes): - return self.editor.ExtrusionSweepMakeGroups0D(IDsOfElements, StepVector, NbOfSteps) - else: - return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps) - if(IsNodes): - self.editor.ExtrusionSweep0D(IDsOfElements, StepVector, NbOfSteps) - else: - self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps) - return [] + + return self.editor.ExtrusionSweepObjects( nodes, edges, faces, + StepVector, NbOfSteps, MakeGroups) + ## Generates new elements by extrusion of the elements with given ids - # @param IDsOfElements is ids of elements + # @param IDsOfElements the list of elements ids for extrusion # @param StepVector vector or DirStruct or 3 vector components, defining # the direction and value of extrusion for one step (the total extrusion # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps - # @param ExtrFlags sets flags for extrusion - # @param SewTolerance uses for comparing locations of nodes if flag - # EXTRUSION_FLAG_SEW is set # @param MakeGroups forces the generation of new groups from existing ones - # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @param IsNodes is True if elements with given ids are nodes + # @return the list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev - def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps, - ExtrFlags, SewTolerance, MakeGroups=False): - if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): - StepVector = self.smeshpyD.GetDirStruct(StepVector) - if isinstance( StepVector, list ): - StepVector = self.smeshpyD.MakeDirStruct(*StepVector) - if MakeGroups: - return self.editor.AdvancedExtrusionMakeGroups(IDsOfElements, StepVector, NbOfSteps, - ExtrFlags, SewTolerance) - self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps, - ExtrFlags, SewTolerance) - return [] + def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False): + n,e,f = [],[],[] + if IsNodes: n = IDsOfElements + else : e,f, = IDsOfElements,IDsOfElements + return self.ExtrusionSweepObjects(n,e,f, StepVector, NbOfSteps, MakeGroups) + + ## Generates new elements by extrusion along the normal to a discretized surface or wire + # @param Elements elements to extrude - a list including ids, groups, sub-meshes or a mesh + # Only faces can be extruded so far. Sub-mesh should be a sub-mesh on geom faces. + # @param StepSize length of one extrusion step (the total extrusion + # length will be \a NbOfSteps * \a StepSize ). + # @param NbOfSteps number of extrusion steps. + # @param ByAverageNormal if True each node is translated by \a StepSize + # along the average of the normal vectors to the faces sharing the node; + # else each node is translated along the same average normal till + # intersection with the plane got by translation of the face sharing + # the node along its own normal by \a StepSize. + # @param UseInputElemsOnly to use only \a Elements when computing extrusion direction + # for every node of \a Elements. + # @param MakeGroups forces generation of new groups from existing ones. + # @param Dim dimension of elements to extrude: 2 - faces or 1 - edges. Extrusion of edges + # is not yet implemented. This parameter is used if \a Elements contains + # both faces and edges, i.e. \a Elements is a Mesh. + # @return the list of created groups (SMESH_GroupBase) if \a MakeGroups=True, + # empty list otherwise. + # @ingroup l2_modif_extrurev + def ExtrusionByNormal(self, Elements, StepSize, NbOfSteps, + ByAverageNormal=False, UseInputElemsOnly=True, MakeGroups=False, Dim = 2): + unRegister = genObjUnRegister() + if isinstance( Elements, Mesh ): + Elements = [ Elements.GetMesh() ] + if isinstance( Elements, list ): + if not Elements: + raise RuntimeError, "Elements empty!" + if isinstance( Elements[0], int ): + Elements = self.GetIDSource( Elements, SMESH.ALL ) + unRegister.set( Elements ) + if not isinstance( Elements, list ): + Elements = [ Elements ] + StepSize,NbOfSteps,Parameters,hasVars = ParseParameters(StepSize,NbOfSteps) + self.mesh.SetParameters(Parameters) + return self.editor.ExtrusionByNormal(Elements, StepSize, NbOfSteps, + ByAverageNormal, UseInputElemsOnly, MakeGroups, Dim) ## Generates new elements by extrusion of the elements which belong to the object # @param theObject the object which elements should be processed. @@ -3603,29 +3746,14 @@ class Mesh: # length will be NbOfSteps * ||StepVector||) # @param NbOfSteps the number of steps # @param MakeGroups forces the generation of new groups from existing ones - # @param IsNodes is True if elements which belong to the object are nodes + # @param IsNodes is True if elements to extrude are nodes # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): - StepVector = self.smeshpyD.GetDirStruct(StepVector) - if isinstance( StepVector, list ): - StepVector = self.smeshpyD.MakeDirStruct(*StepVector) - NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) - Parameters = StepVector.PS.parameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if MakeGroups: - if(IsNodes): - return self.editor.ExtrusionSweepObject0DMakeGroups(theObject, StepVector, NbOfSteps) - else: - return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps) - if(IsNodes): - self.editor.ExtrusionSweepObject0D(theObject, StepVector, NbOfSteps) - else: - self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps) - return [] + n,e,f = [],[],[] + if IsNodes: n = theObject + else : e,f, = theObject,theObject + return self.ExtrusionSweepObjects(n,e,f, StepVector, NbOfSteps, MakeGroups) ## Generates new elements by extrusion of the elements which belong to the object # @param theObject object which elements should be processed. @@ -3638,19 +3766,7 @@ class Mesh: # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev def ExtrusionSweepObject1D(self, theObject, StepVector, NbOfSteps, MakeGroups=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): - StepVector = self.smeshpyD.GetDirStruct(StepVector) - if isinstance( StepVector, list ): - StepVector = self.smeshpyD.MakeDirStruct(*StepVector) - NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) - Parameters = StepVector.PS.parameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if MakeGroups: - return self.editor.ExtrusionSweepObject1DMakeGroups(theObject, StepVector, NbOfSteps) - self.editor.ExtrusionSweepObject1D(theObject, StepVector, NbOfSteps) - return [] + return self.ExtrusionSweepObjects([],theObject,[], StepVector, NbOfSteps, MakeGroups) ## Generates new elements by extrusion of the elements which belong to the object # @param theObject object which elements should be processed. @@ -3663,21 +3779,70 @@ class Mesh: # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_extrurev def ExtrusionSweepObject2D(self, theObject, StepVector, NbOfSteps, MakeGroups=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object)): + return self.ExtrusionSweepObjects([],[],theObject, StepVector, NbOfSteps, MakeGroups) + + ## Generates new elements by extrusion of the elements with given ids + # @param IDsOfElements is ids of elements + # @param StepVector vector or DirStruct or 3 vector components, defining + # the direction and value of extrusion for one step (the total extrusion + # length will be NbOfSteps * ||StepVector||) + # @param NbOfSteps the number of steps + # @param ExtrFlags sets flags for extrusion + # @param SewTolerance uses for comparing locations of nodes if flag + # EXTRUSION_FLAG_SEW is set + # @param MakeGroups forces the generation of new groups from existing ones + # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise + # @ingroup l2_modif_extrurev + def AdvancedExtrusion(self, IDsOfElements, StepVector, NbOfSteps, + ExtrFlags, SewTolerance, MakeGroups=False): + if isinstance( StepVector, geomBuilder.GEOM._objref_GEOM_Object): StepVector = self.smeshpyD.GetDirStruct(StepVector) if isinstance( StepVector, list ): StepVector = self.smeshpyD.MakeDirStruct(*StepVector) - NbOfSteps,Parameters,hasVars = ParseParameters(NbOfSteps) - Parameters = StepVector.PS.parameters + var_separator + Parameters - self.mesh.SetParameters(Parameters) - if MakeGroups: - return self.editor.ExtrusionSweepObject2DMakeGroups(theObject, StepVector, NbOfSteps) - self.editor.ExtrusionSweepObject2D(theObject, StepVector, NbOfSteps) - return [] + return self.editor.AdvancedExtrusion(IDsOfElements, StepVector, NbOfSteps, + ExtrFlags, SewTolerance, MakeGroups) + ## Generates new elements by extrusion of the given elements and nodes along the path. + # The path of extrusion must be a meshed edge. + # @param Nodes nodes to extrude: a list including ids, groups, sub-meshes or a mesh + # @param Edges edges to extrude: a list including ids, groups, sub-meshes or a mesh + # @param Faces faces to extrude: a list including ids, groups, sub-meshes or a mesh + # @param PathMesh 1D mesh or 1D sub-mesh, along which proceeds the extrusion + # @param PathShape shape (edge) defines the sub-mesh of PathMesh if PathMesh + # contains not only path segments, else it can be None + # @param NodeStart the first or the last node on the path. Defines the direction of extrusion + # @param HasAngles allows the shape to be rotated around the path + # to get the resulting mesh in a helical fashion + # @param Angles list of angles + # @param LinearVariation forces the computation of rotation angles as linear + # variation of the given Angles along path steps + # @param HasRefPoint allows using the reference point + # @param RefPoint the 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. + # @param MakeGroups forces the generation of new groups from existing ones + # @return list of created groups (SMESH_GroupBase) and SMESH::Extrusion_Error + # @ingroup l2_modif_extrurev + def ExtrusionAlongPathObjects(self, Nodes, Edges, Faces, PathMesh, PathShape=None, + NodeStart=1, HasAngles=False, Angles=[], LinearVariation=False, + HasRefPoint=False, RefPoint=[0,0,0], MakeGroups=False): + unRegister = genObjUnRegister() + Nodes = self._getIdSourceList( Nodes, SMESH.NODE, unRegister ) + Edges = self._getIdSourceList( Edges, SMESH.EDGE, unRegister ) + Faces = self._getIdSourceList( Faces, SMESH.FACE, unRegister ) + if isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object): + RefPoint = self.smeshpyD.GetPointStruct(RefPoint) + if isinstance( RefPoint, list ): + RefPoint = SMESH.PointStruct( *RefPoint ) + if isinstance( PathMesh, Mesh ): + PathMesh = PathMesh.GetMesh() + Angles,AnglesParameters,hasVars = ParseAngles(Angles) + Parameters = AnglesParameters + var_separator + RefPoint.parameters + self.mesh.SetParameters(Parameters) + return self.editor.ExtrusionAlongPathObjects(Nodes, Edges, Faces, + PathMesh, PathShape, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups) ## Generates new elements by extrusion of the given elements # The path of extrusion must be a meshed edge. @@ -3702,34 +3867,15 @@ class Mesh: def ExtrusionAlongPathX(self, Base, Path, NodeStart, HasAngles, Angles, LinearVariation, HasRefPoint, RefPoint, MakeGroups, ElemType): - if isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object): - RefPoint = self.smeshpyD.GetPointStruct(RefPoint) - pass - elif isinstance( RefPoint, list ): - RefPoint = PointStruct(*RefPoint) - pass - Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters - self.mesh.SetParameters(Parameters) - - if (isinstance(Path, Mesh)): Path = Path.GetMesh() - - if isinstance(Base, list): - IDsOfElements = [] - if Base == []: IDsOfElements = self.GetElementsId() - else: IDsOfElements = Base - return self.editor.ExtrusionAlongPathX(IDsOfElements, Path, NodeStart, - HasAngles, Angles, LinearVariation, - HasRefPoint, RefPoint, MakeGroups, ElemType) - else: - if isinstance(Base, Mesh): Base = Base.GetMesh() - if isinstance(Base, SMESH._objref_SMESH_Mesh) or isinstance(Base, SMESH._objref_SMESH_Group) or isinstance(Base, SMESH._objref_SMESH_subMesh): - return self.editor.ExtrusionAlongPathObjX(Base, Path, NodeStart, - HasAngles, Angles, LinearVariation, - HasRefPoint, RefPoint, MakeGroups, ElemType) - else: - raise RuntimeError, "Invalid Base for ExtrusionAlongPathX" - + n,e,f = [],[],[] + if ElemType == SMESH.NODE: n = Base + if ElemType == SMESH.EDGE: e = Base + if ElemType == SMESH.FACE: f = Base + gr,er = self.ExtrusionAlongPathObjects(n,e,f, Path, None, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups) + if MakeGroups: return gr,er + return er ## Generates new elements by extrusion of the given elements # The path of extrusion must be a meshed edge. @@ -3752,30 +3898,18 @@ class Mesh: def ExtrusionAlongPath(self, IDsOfElements, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - if IDsOfElements == []: - IDsOfElements = self.GetElementsId() - if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): - RefPoint = self.smeshpyD.GetPointStruct(RefPoint) - pass - if ( isinstance( PathMesh, Mesh )): - PathMesh = PathMesh.GetMesh() - Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters - self.mesh.SetParameters(Parameters) - if HasAngles and Angles and LinearVariation: - Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) - pass - if MakeGroups: - return self.editor.ExtrusionAlongPathMakeGroups(IDsOfElements, PathMesh, - PathShape, NodeStart, HasAngles, - Angles, HasRefPoint, RefPoint) - return self.editor.ExtrusionAlongPath(IDsOfElements, PathMesh, PathShape, - NodeStart, HasAngles, Angles, HasRefPoint, RefPoint) + n,e,f = [],IDsOfElements,IDsOfElements + gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, + NodeStart, HasAngles, Angles, + LinearVariation, + HasRefPoint, RefPoint, MakeGroups) + if MakeGroups: return gr,er + return er ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. # @param theObject the object which elements should be processed. - # It can be a mesh, a sub mesh or a group. + # It can be a mesh, a sub-mesh or a group. # @param PathMesh mesh containing a 1D sub-mesh on the edge, along which the extrusion proceeds # @param PathShape shape(edge) defines the sub-mesh for the path # @param NodeStart the first or the last node on the edge. Defines the direction of extrusion @@ -3794,25 +3928,12 @@ class Mesh: def ExtrusionAlongPathObject(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): - RefPoint = self.smeshpyD.GetPointStruct(RefPoint) - if ( isinstance( PathMesh, Mesh )): - PathMesh = PathMesh.GetMesh() - Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters - self.mesh.SetParameters(Parameters) - if HasAngles and Angles and LinearVariation: - Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) - pass - if MakeGroups: - return self.editor.ExtrusionAlongPathObjectMakeGroups(theObject, PathMesh, - PathShape, NodeStart, HasAngles, - Angles, HasRefPoint, RefPoint) - return self.editor.ExtrusionAlongPathObject(theObject, PathMesh, PathShape, - NodeStart, HasAngles, Angles, HasRefPoint, - RefPoint) + n,e,f = [],theObject,theObject + gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups) + if MakeGroups: return gr,er + return er ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. @@ -3836,25 +3957,12 @@ class Mesh: def ExtrusionAlongPathObject1D(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): - RefPoint = self.smeshpyD.GetPointStruct(RefPoint) - if ( isinstance( PathMesh, Mesh )): - PathMesh = PathMesh.GetMesh() - Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters - self.mesh.SetParameters(Parameters) - if HasAngles and Angles and LinearVariation: - Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) - pass - if MakeGroups: - return self.editor.ExtrusionAlongPathObject1DMakeGroups(theObject, PathMesh, - PathShape, NodeStart, HasAngles, - Angles, HasRefPoint, RefPoint) - return self.editor.ExtrusionAlongPathObject1D(theObject, PathMesh, PathShape, - NodeStart, HasAngles, Angles, HasRefPoint, - RefPoint) + n,e,f = [],theObject,[] + gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups) + if MakeGroups: return gr,er + return er ## Generates new elements by extrusion of the elements which belong to the object # The path of extrusion must be a meshed edge. @@ -3878,41 +3986,30 @@ class Mesh: def ExtrusionAlongPathObject2D(self, theObject, PathMesh, PathShape, NodeStart, HasAngles, Angles, HasRefPoint, RefPoint, MakeGroups=False, LinearVariation=False): - if ( isinstance( theObject, Mesh )): - theObject = theObject.GetMesh() - if ( isinstance( RefPoint, geomBuilder.GEOM._objref_GEOM_Object)): - RefPoint = self.smeshpyD.GetPointStruct(RefPoint) - if ( isinstance( PathMesh, Mesh )): - PathMesh = PathMesh.GetMesh() - Angles,AnglesParameters,hasVars = ParseAngles(Angles) - Parameters = AnglesParameters + var_separator + RefPoint.parameters - self.mesh.SetParameters(Parameters) - if HasAngles and Angles and LinearVariation: - Angles = self.editor.LinearAnglesVariation( PathMesh, PathShape, Angles ) - pass - if MakeGroups: - return self.editor.ExtrusionAlongPathObject2DMakeGroups(theObject, PathMesh, - PathShape, NodeStart, HasAngles, - Angles, HasRefPoint, RefPoint) - return self.editor.ExtrusionAlongPathObject2D(theObject, PathMesh, PathShape, - NodeStart, HasAngles, Angles, HasRefPoint, - RefPoint) + n,e,f = [],[],theObject + gr,er = self.ExtrusionAlongPathObjects(n,e,f, PathMesh, PathShape, NodeStart, + HasAngles, Angles, LinearVariation, + HasRefPoint, RefPoint, MakeGroups) + if MakeGroups: return gr,er + return er ## Creates a symmetrical copy of mesh elements # @param IDsOfElements list of elements ids # @param Mirror is AxisStruct or geom object(point, line, plane) - # @param theMirrorType is POINT, AXIS or PLANE - # If the Mirror is a geom object this parameter is unnecessary + # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE + # If the Mirror is a geom object this parameter is unnecessary # @param Copy allows to copy element (Copy is 1) or to replace with its mirroring (Copy is 0) # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf - def Mirror(self, IDsOfElements, Mirror, theMirrorType, Copy=0, MakeGroups=False): + def Mirror(self, IDsOfElements, Mirror, theMirrorType=None, Copy=0, MakeGroups=False): if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorMakeGroups(IDsOfElements, Mirror, theMirrorType) self.editor.Mirror(IDsOfElements, Mirror, theMirrorType, Copy) @@ -3921,18 +4018,20 @@ class Mesh: ## Creates a new mesh by a symmetrical copy of mesh elements # @param IDsOfElements the list of elements ids # @param Mirror is AxisStruct or geom object (point, line, plane) - # @param theMirrorType is POINT, AXIS or PLANE - # If the Mirror is a geom object this parameter is unnecessary + # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE + # If the Mirror is a geom object this parameter is unnecessary # @param MakeGroups to generate new groups from existing ones # @param NewMeshName a name of the new mesh to create # @return instance of Mesh class # @ingroup l2_modif_trsf - def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType, MakeGroups=0, NewMeshName=""): + def MirrorMakeMesh(self, IDsOfElements, Mirror, theMirrorType=0, MakeGroups=0, NewMeshName=""): if IDsOfElements == []: IDsOfElements = self.GetElementsId() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorMakeMesh(IDsOfElements, Mirror, theMirrorType, MakeGroups, NewMeshName) return Mesh(self.smeshpyD,self.geompyD,mesh) @@ -3940,18 +4039,20 @@ class Mesh: ## Creates a symmetrical copy of the object # @param theObject mesh, submesh or group # @param Mirror AxisStruct or geom object (point, line, plane) - # @param theMirrorType is POINT, AXIS or PLANE - # If the Mirror is a geom object this parameter is unnecessary + # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE + # If the Mirror is a geom object this parameter is unnecessary # @param Copy allows copying the element (Copy is 1) or replacing it with its mirror (Copy is 0) # @param MakeGroups forces the generation of new groups from existing ones (if Copy) # @return list of created groups (SMESH_GroupBase) if MakeGroups=True, empty list otherwise # @ingroup l2_modif_trsf - def MirrorObject (self, theObject, Mirror, theMirrorType, Copy=0, MakeGroups=False): + def MirrorObject (self, theObject, Mirror, theMirrorType=None, Copy=0, MakeGroups=False): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) if Copy and MakeGroups: return self.editor.MirrorObjectMakeGroups(theObject, Mirror, theMirrorType) self.editor.MirrorObject(theObject, Mirror, theMirrorType, Copy) @@ -3960,18 +4061,20 @@ class Mesh: ## Creates a new mesh by a symmetrical copy of the object # @param theObject mesh, submesh or group # @param Mirror AxisStruct or geom object (point, line, plane) - # @param theMirrorType POINT, AXIS or PLANE - # If the Mirror is a geom object this parameter is unnecessary + # @param theMirrorType smeshBuilder.POINT, smeshBuilder.AXIS or smeshBuilder.PLANE + # If the Mirror is a geom object this parameter is unnecessary # @param MakeGroups forces the generation of new groups from existing ones # @param NewMeshName the name of the new mesh to create # @return instance of Mesh class # @ingroup l2_modif_trsf - def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType,MakeGroups=0, NewMeshName=""): + def MirrorObjectMakeMesh (self, theObject, Mirror, theMirrorType=0,MakeGroups=0,NewMeshName=""): if ( isinstance( theObject, Mesh )): theObject = theObject.GetMesh() - if (isinstance(Mirror, geomBuilder.GEOM._objref_GEOM_Object)): - Mirror = self.smeshpyD.GetAxisStruct(Mirror) - self.mesh.SetParameters(Mirror.parameters) + if ( isinstance( Mirror, geomBuilder.GEOM._objref_GEOM_Object)): + Mirror = self.smeshpyD.GetAxisStruct(Mirror) + theMirrorType = Mirror._mirrorType + else: + self.mesh.SetParameters(Mirror.parameters) mesh = self.editor.MirrorObjectMakeMesh(theObject, Mirror, theMirrorType, MakeGroups, NewMeshName) return Mesh( self.smeshpyD,self.geompyD,mesh ) @@ -4056,7 +4159,7 @@ class Mesh: ## Scales the object # @param theObject - the object to translate (mesh, submesh, or group) - # @param thePoint - base point for scale + # @param thePoint - base point for scale (SMESH.PointStruct or list of 3 coordinates) # @param theScaleFact - list of 1-3 scale factors for axises # @param Copy - allows copying the translated elements # @param MakeGroups - forces the generation of new groups from existing @@ -4070,6 +4173,8 @@ class Mesh: if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject, SMESH.ALL) unRegister.set( theObject ) + if ( isinstance( thePoint, list )): + thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] ) if ( isinstance( theScaleFact, float )): theScaleFact = [theScaleFact] if ( isinstance( theScaleFact, int )): @@ -4084,7 +4189,7 @@ class Mesh: ## Creates a new mesh from the translated object # @param theObject - the object to translate (mesh, submesh, or group) - # @param thePoint - base point for scale + # @param thePoint - base point for scale (SMESH.PointStruct or list of 3 coordinates) # @param theScaleFact - list of 1-3 scale factors for axises # @param MakeGroups - forces the generation of new groups from existing ones # @param NewMeshName - the name of the newly created mesh @@ -4096,6 +4201,8 @@ class Mesh: if ( isinstance( theObject, list )): theObject = self.GetIDSource(theObject,SMESH.ALL) unRegister.set( theObject ) + if ( isinstance( thePoint, list )): + thePoint = PointStruct( thePoint[0], thePoint[1], thePoint[2] ) if ( isinstance( theScaleFact, float )): theScaleFact = [theScaleFact] if ( isinstance( theScaleFact, int )): @@ -4192,45 +4299,59 @@ class Mesh: ## Finds groups of adjacent nodes within Tolerance. # @param Tolerance the value of tolerance - # @return the list of pairs of nodes IDs (e.g. [[1,12],[25,4]]) + # @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts + # corner and medium nodes in separate groups thus preventing + # their further merge. + # @return the list of groups of nodes IDs (e.g. [[1,12,13],[4,25]]) # @ingroup l2_modif_trsf - def FindCoincidentNodes (self, Tolerance): - return self.editor.FindCoincidentNodes(Tolerance) + def FindCoincidentNodes (self, Tolerance, SeparateCornerAndMediumNodes=False): + return self.editor.FindCoincidentNodes( Tolerance, SeparateCornerAndMediumNodes ) ## Finds groups of ajacent nodes within Tolerance. # @param Tolerance the value of tolerance # @param SubMeshOrGroup SubMesh or Group # @param exceptNodes list of either SubMeshes, Groups or node IDs to exclude from search - # @return the list of pairs of nodes IDs (e.g. [[1,12],[25,4]]) + # @param SeparateCornerAndMediumNodes if @c True, in quadratic mesh puts + # corner and medium nodes in separate groups thus preventing + # their further merge. + # @return the list of groups of nodes IDs (e.g. [[1,12,13],[4,25]]) # @ingroup l2_modif_trsf - def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance, exceptNodes=[]): + def FindCoincidentNodesOnPart (self, SubMeshOrGroup, Tolerance, + exceptNodes=[], SeparateCornerAndMediumNodes=False): unRegister = genObjUnRegister() if (isinstance( SubMeshOrGroup, Mesh )): SubMeshOrGroup = SubMeshOrGroup.GetMesh() - if not isinstance( exceptNodes, list): + if not isinstance( exceptNodes, list ): exceptNodes = [ exceptNodes ] - if exceptNodes and isinstance( exceptNodes[0], int): - exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE)] + if exceptNodes and isinstance( exceptNodes[0], int ): + exceptNodes = [ self.GetIDSource( exceptNodes, SMESH.NODE )] unRegister.set( exceptNodes ) - return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance,exceptNodes) + return self.editor.FindCoincidentNodesOnPartBut(SubMeshOrGroup, Tolerance, + exceptNodes, SeparateCornerAndMediumNodes) ## Merges nodes - # @param GroupsOfNodes a list of pairs of nodes IDs for merging (e.g. [[1,12],[25,4]]) + # @param GroupsOfNodes a list of groups of nodes IDs for merging + # (e.g. [[1,12,13],[25,4]], then nodes 12, 13 and 4 will be removed and replaced + # by nodes 1 and 25 correspondingly in all elements and groups # @ingroup l2_modif_trsf def MergeNodes (self, GroupsOfNodes): self.editor.MergeNodes(GroupsOfNodes) ## Finds the elements built on the same nodes. # @param MeshOrSubMeshOrGroup Mesh or SubMesh, or Group of elements for searching - # @return the list of pairs of equal elements IDs (e.g. [[1,12],[25,4]]) + # @return the list of groups of equal elements IDs (e.g. [[1,12,13],[4,25]]) # @ingroup l2_modif_trsf - def FindEqualElements (self, MeshOrSubMeshOrGroup): - if ( isinstance( MeshOrSubMeshOrGroup, Mesh )): + def FindEqualElements (self, MeshOrSubMeshOrGroup=None): + if not MeshOrSubMeshOrGroup: + MeshOrSubMeshOrGroup=self.mesh + elif isinstance( MeshOrSubMeshOrGroup, Mesh ): MeshOrSubMeshOrGroup = MeshOrSubMeshOrGroup.GetMesh() - return self.editor.FindEqualElements(MeshOrSubMeshOrGroup) + return self.editor.FindEqualElements( MeshOrSubMeshOrGroup ) ## Merges elements in each given group. - # @param GroupsOfElementsID a list of pairs of elements IDs for merging (e.g. [[1,12],[25,4]]) + # @param GroupsOfElementsID a list of groups of elements IDs for merging + # (e.g. [[1,12,13],[25,4]], then elements 12, 13 and 4 will be removed and + # replaced by elements 1 and 25 in all groups) # @ingroup l2_modif_trsf def MergeElements(self, GroupsOfElementsID): self.editor.MergeElements(GroupsOfElementsID) @@ -4313,8 +4434,9 @@ class Mesh: ## Creates Duplicates given elements, i.e. creates new elements based on the # same nodes as the given ones. # @param theElements - container of elements to duplicate. It can be a Mesh, - # sub-mesh, group, filter or a list of element IDs. - # @param theGroupName - a name of group to contain the generated elements. + # sub-mesh, group, filter or a list of element IDs. If \a theElements is + # a Mesh, elements of highest dimension are duplicated + # @param theGroupName - a name of group to contain the generated elements. # If a group with such a name already exists, the new elements # are added to the existng group, else a new group is created. # If \a theGroupName is empty, new elements are not added @@ -4485,9 +4607,11 @@ class Mesh: # Triangles are transformed in prisms, and quadrangles in hexahedrons. # @param theDomains - list of groups of volumes # @param createJointElems - if TRUE, create the elements + # @param onAllBoundaries - if TRUE, the nodes and elements are also created on + # the boundary between \a theDomains and the rest mesh # @return TRUE if operation has been completed successfully, FALSE otherwise - def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems ): - return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems ) + def DoubleNodesOnGroupBoundaries(self, theDomains, createJointElems, onAllBoundaries=False ): + return self.editor.DoubleNodesOnGroupBoundaries( theDomains, createJointElems, onAllBoundaries ) ## Double nodes on some external faces and create flat elements. # Flat elements are mainly used by some types of mechanic calculations. @@ -4512,9 +4636,14 @@ class Mesh: self.functors[ funcType._v ] = fn return fn - def _valueFromFunctor(self, funcType, elemId): + ## Returns value of a functor for a given element + # @param funcType an item of SMESH.FunctorType enum + # @param elemId element or node ID + # @param isElem @a elemId is ID of element or node + # @return the functor value or zero in case of invalid arguments + def FunctorValue(self, funcType, elemId, isElem=True): fn = self._getFunctor( funcType ) - if fn.GetElementType() == self.GetElementType(elemId, True): + if fn.GetElementType() == self.GetElementType(elemId, isElem): val = fn.GetValue(elemId) else: val = 0 @@ -4529,7 +4658,7 @@ class Mesh: if elemId == None: length = self.smeshpyD.GetLength(self) else: - length = self._valueFromFunctor(SMESH.FT_Length, elemId) + length = self.FunctorValue(SMESH.FT_Length, elemId) return length ## Get area of 2D element or sum of areas of all 2D mesh elements @@ -4541,7 +4670,7 @@ class Mesh: if elemId == None: area = self.smeshpyD.GetArea(self) else: - area = self._valueFromFunctor(SMESH.FT_Area, elemId) + area = self.FunctorValue(SMESH.FT_Area, elemId) return area ## Get volume of 3D element or sum of volumes of all 3D mesh elements @@ -4553,7 +4682,7 @@ class Mesh: if elemId == None: volume = self.smeshpyD.GetVolume(self) else: - volume = self._valueFromFunctor(SMESH.FT_Volume3D, elemId) + volume = self.FunctorValue(SMESH.FT_Volume3D, elemId) return volume ## Get maximum element length. @@ -4565,7 +4694,7 @@ class Mesh: ftype = SMESH.FT_MaxElementLength3D else: ftype = SMESH.FT_MaxElementLength2D - return self._valueFromFunctor(ftype, elemId) + return self.FunctorValue(ftype, elemId) ## Get aspect ratio of 2D or 3D element. # @param elemId mesh element ID @@ -4576,38 +4705,79 @@ class Mesh: ftype = SMESH.FT_AspectRatio3D else: ftype = SMESH.FT_AspectRatio - return self._valueFromFunctor(ftype, elemId) + return self.FunctorValue(ftype, elemId) ## Get warping angle of 2D element. # @param elemId mesh element ID # @return element's warping angle value # @ingroup l1_measurements def GetWarping(self, elemId): - return self._valueFromFunctor(SMESH.FT_Warping, elemId) + return self.FunctorValue(SMESH.FT_Warping, elemId) ## Get minimum angle of 2D element. # @param elemId mesh element ID # @return element's minimum angle value # @ingroup l1_measurements def GetMinimumAngle(self, elemId): - return self._valueFromFunctor(SMESH.FT_MinimumAngle, elemId) + return self.FunctorValue(SMESH.FT_MinimumAngle, elemId) ## Get taper of 2D element. # @param elemId mesh element ID # @return element's taper value # @ingroup l1_measurements def GetTaper(self, elemId): - return self._valueFromFunctor(SMESH.FT_Taper, elemId) + return self.FunctorValue(SMESH.FT_Taper, elemId) ## Get skew of 2D element. # @param elemId mesh element ID # @return element's skew value # @ingroup l1_measurements def GetSkew(self, elemId): - return self._valueFromFunctor(SMESH.FT_Skew, elemId) + return self.FunctorValue(SMESH.FT_Skew, elemId) + + ## Return minimal and maximal value of a given functor. + # @param funType a functor type, an item of SMESH.FunctorType enum + # (one of SMESH.FunctorType._items) + # @param meshPart a part of mesh (group, sub-mesh) to treat + # @return tuple (min,max) + # @ingroup l1_measurements + def GetMinMax(self, funType, meshPart=None): + unRegister = genObjUnRegister() + if isinstance( meshPart, list ): + meshPart = self.GetIDSource( meshPart, SMESH.ALL ) + unRegister.set( meshPart ) + if isinstance( meshPart, Mesh ): + meshPart = meshPart.mesh + fun = self._getFunctor( funType ) + if fun: + if meshPart: + hist = fun.GetLocalHistogram( 1, False, meshPart ) + else: + hist = fun.GetHistogram( 1, False ) + if hist: + return hist[0].min, hist[0].max + return None pass # end of Mesh class +## class used to add to SMESH_MeshEditor methods removed from its CORBA API +# +class meshEditor(SMESH._objref_SMESH_MeshEditor): + def __init__(self): + SMESH._objref_SMESH_MeshEditor.__init__(self) + self.mesh = None + def __getattr__(self, name ): # method called if an attribute not found + if not self.mesh: # look for name() method in Mesh class + self.mesh = Mesh( None, None, SMESH._objref_SMESH_MeshEditor.GetMesh(self)) + if hasattr( self.mesh, name ): + return getattr( self.mesh, name ) + if name == "ExtrusionAlongPathObjX": + return getattr( self.mesh, "ExtrusionAlongPathX" ) + print name, "NOT FOUND" + return None + pass +omniORB.registerObjref(SMESH._objref_SMESH_MeshEditor._NP_RepositoryId, meshEditor) + ## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class # class Pattern(SMESH._objref_SMESH_Pattern):