X-Git-Url: http://git.salome-platform.org/gitweb/?p=modules%2Fsmesh.git;a=blobdiff_plain;f=src%2FSMESH_SWIG%2FsmeshBuilder.py;h=a51e40ce8ff5a1189af8d5f7283dc3d7f2452217;hp=7c4acfad49e67aa0dc5f2b692c91a7cdd0351267;hb=811a7a4c176887c38fcd93e53b1822ef60981c6b;hpb=97787812e26d555a6141ece38c9f13167410f425 diff --git a/src/SMESH_SWIG/smeshBuilder.py b/src/SMESH_SWIG/smeshBuilder.py index 7c4acfad4..a51e40ce8 100644 --- a/src/SMESH_SWIG/smeshBuilder.py +++ b/src/SMESH_SWIG/smeshBuilder.py @@ -383,10 +383,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 +456,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 +470,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: # ------------------------ @@ -1514,7 +1526,7 @@ class Mesh: smeshgui.SetMeshIcon( salome.ObjectToID( self.mesh ), False, True ) 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 +1539,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,25 +1574,26 @@ class Mesh: if not geom: geom = self.mesh.GetShapeToMesh() pass - hyp_name = GetName( hyp ) - geom_name = "" - if geom: - geom_name = geom.GetName() isApplicable = True if self.mesh.HasShapeToMesh(): hyp_type = hyp.GetName() lib_name = hyp.GetLibName() - isSubMesh = ( not geom.IsSame( self.mesh.GetShapeToMesh() )) - isApplicable = self.smeshpyD.IsApplicable(hyp_name, lib_name, geom, isSubMesh) + 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) - isAlgo = hyp._narrow( SMESH_Algo ) - TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) - return status else: - TreatHypoStatus( HYP_BAD_GEOMETRY, hyp_name, geom_name, isAlgo ) - return HYP_BAD_GEOMETRY + status = HYP_BAD_GEOMETRY + hyp_name = GetName( hyp ) + geom_name = "" + if geom: + geom_name = geom.GetName() + isAlgo = hyp._narrow( SMESH_Algo ) + TreatHypoStatus( status, hyp_name, geom_name, isAlgo ) + return status ## Return True if an algorithm of hypothesis is assigned to a given shape # @param hyp a hypothesis to check @@ -2952,6 +2964,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 @@ -3924,12 +3967,14 @@ class Mesh: # @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) @@ -3944,12 +3989,14 @@ class Mesh: # @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) @@ -3963,12 +4010,14 @@ class Mesh: # @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) @@ -3983,12 +4032,14 @@ class Mesh: # @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 ) @@ -4502,9 +4553,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. @@ -4623,6 +4676,29 @@ class Mesh: def GetSkew(self, elemId): return self._valueFromFunctor(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 ## Helper class for wrapping of SMESH.SMESH_Pattern CORBA class