elif status == HYP_CONCURENT :
reason = "there are concurrent hypotheses on sub-shapes"
elif status == HYP_BAD_SUBSHAPE :
- reason = "the shape is neither the main one, nor its subshape, nor a valid group"
+ reason = "the shape is neither the main one, nor its sub-shape, nor a valid group"
elif status == HYP_BAD_GEOMETRY:
reason = "geometry mismatches the expectation of the algorithm"
elif status == HYP_HIDDEN_ALGO:
def DumpPython(self, theStudy, theIsPublished=True, theIsMultiFile=True):
return SMESH._objref_SMESH_Gen.DumpPython(self, theStudy, theIsPublished, theIsMultiFile)
+ ## Set mode of DumpPython(), \a historical or \a snapshot.
+ # In the \a historical mode, the Python Dump script includes all commands
+ # performed by SMESH engine. In the \a snapshot mode, commands
+ # relating to objects removed from the Study are excluded from the script
+ # as well as commands not influencing the current state of meshes
+ def SetDumpPythonHistorical(self, isHistorical):
+ if isHistorical: val = "true"
+ else: val = "false"
+ SMESH._objref_SMESH_Gen.SetOption(self, "historical_python_dump", val)
+
## Sets the current study and Geometry component
# @ingroup l1_auxiliary
def init_smesh(self,theStudy,geompyD):
# @param elementType the type of elements(NODE, EDGE, FACE, VOLUME)
# @param CritType the type of criterion (FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc.)
# @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
- # @param Treshold the threshold value (range of ids as string, shape, numeric)
+ # @param Threshold the threshold value (range of ids as string, shape, numeric)
# @param UnaryOp FT_LogicalNOT or FT_Undefined
# @param BinaryOp a binary logical operation FT_LogicalAND, FT_LogicalOR or
# FT_Undefined (must be for the last criterion of all criteria)
def GetCriterion(self,elementType,
CritType,
Compare = FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
BinaryOp=FT_Undefined,
Tolerance=1e-07):
aCriterion.Type = self.EnumToLong(CritType)
aCriterion.Tolerance = Tolerance
- aTreshold = Treshold
+ aThreshold = Threshold
if Compare in [FT_LessThan, FT_MoreThan, FT_EqualTo]:
aCriterion.Compare = self.EnumToLong(Compare)
aCriterion.Compare = self.EnumToLong(FT_MoreThan)
elif Compare != FT_Undefined:
aCriterion.Compare = self.EnumToLong(FT_EqualTo)
- aTreshold = Compare
+ aThreshold = Compare
if CritType in [FT_BelongToGeom, FT_BelongToPlane, FT_BelongToGenSurface,
FT_BelongToCylinder, FT_LyingOnGeom]:
- # Checks the treshold
- if isinstance(aTreshold, geompyDC.GEOM._objref_GEOM_Object):
- aCriterion.ThresholdStr = GetName(aTreshold)
- aCriterion.ThresholdID = salome.ObjectToID(aTreshold)
+ # Checks the Threshold
+ if isinstance(aThreshold, geompyDC.GEOM._objref_GEOM_Object):
+ aCriterion.ThresholdStr = GetName(aThreshold)
+ aCriterion.ThresholdID = salome.ObjectToID(aThreshold)
else:
- print "Error: The treshold should be a shape."
+ print "Error: The Threshold should be a shape."
return None
if isinstance(UnaryOp,float):
aCriterion.Tolerance = UnaryOp
UnaryOp = FT_Undefined
pass
elif CritType == FT_RangeOfIds:
- # Checks the treshold
- if isinstance(aTreshold, str):
- aCriterion.ThresholdStr = aTreshold
+ # Checks the Threshold
+ if isinstance(aThreshold, str):
+ aCriterion.ThresholdStr = aThreshold
else:
- print "Error: The treshold should be a string."
+ print "Error: The Threshold should be a string."
return None
elif CritType == FT_CoplanarFaces:
- # Checks the treshold
- if isinstance(aTreshold, int):
- aCriterion.ThresholdID = "%s"%aTreshold
- elif isinstance(aTreshold, str):
- ID = int(aTreshold)
+ # Checks the Threshold
+ if isinstance(aThreshold, int):
+ aCriterion.ThresholdID = "%s"%aThreshold
+ elif isinstance(aThreshold, str):
+ ID = int(aThreshold)
if ID < 1:
- raise ValueError, "Invalid ID of mesh face: '%s'"%aTreshold
- aCriterion.ThresholdID = aTreshold
+ raise ValueError, "Invalid ID of mesh face: '%s'"%aThreshold
+ aCriterion.ThresholdID = aThreshold
else:
raise ValueError,\
- "The treshold should be an ID of mesh face and not '%s'"%aTreshold
+ "The Threshold should be an ID of mesh face and not '%s'"%aThreshold
elif CritType == FT_ElemGeomType:
- # Checks the treshold
+ # Checks the Threshold
try:
- aCriterion.Threshold = self.EnumToLong(aTreshold)
- assert( aTreshold in SMESH.GeometryType._items )
+ aCriterion.Threshold = self.EnumToLong(aThreshold)
+ assert( aThreshold in SMESH.GeometryType._items )
except:
- if isinstance(aTreshold, int):
- aCriterion.Threshold = aTreshold
+ if isinstance(aThreshold, int):
+ aCriterion.Threshold = aThreshold
else:
- print "Error: The treshold should be an integer or SMESH.GeometryType."
+ print "Error: The Threshold should be an integer or SMESH.GeometryType."
return None
pass
pass
elif CritType == FT_GroupColor:
- # Checks the treshold
+ # Checks the Threshold
try:
- aCriterion.ThresholdStr = self.ColorToString(aTreshold)
+ aCriterion.ThresholdStr = self.ColorToString(aThreshold)
except:
print "Error: The threshold value should be of SALOMEDS.Color type"
return None
pass
- elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_BadOrientedVolume, FT_FreeNodes,
- FT_FreeFaces, FT_LinearOrQuadratic,
+ elif CritType in [FT_FreeBorders, FT_FreeEdges, FT_FreeNodes, FT_FreeFaces,
+ FT_LinearOrQuadratic, FT_BadOrientedVolume,
FT_BareBorderFace, FT_BareBorderVolume,
- FT_OverConstrainedFace, FT_OverConstrainedVolume]:
- # At this point the treshold is unnecessary
- if aTreshold == FT_LogicalNOT:
+ FT_OverConstrainedFace, FT_OverConstrainedVolume,
+ FT_EqualNodes,FT_EqualEdges,FT_EqualFaces,FT_EqualVolumes ]:
+ # At this point the Threshold is unnecessary
+ if aThreshold == FT_LogicalNOT:
aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
- elif aTreshold in [FT_LogicalAND, FT_LogicalOR]:
- aCriterion.BinaryOp = aTreshold
+ elif aThreshold in [FT_LogicalAND, FT_LogicalOR]:
+ aCriterion.BinaryOp = aThreshold
else:
- # Check treshold
+ # Check Threshold
try:
- aTreshold = float(aTreshold)
- aCriterion.Threshold = aTreshold
+ aThreshold = float(aThreshold)
+ aCriterion.Threshold = aThreshold
except:
- print "Error: The treshold should be a number."
+ print "Error: The Threshold should be a number."
return None
- if Treshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT:
+ if Threshold == FT_LogicalNOT or UnaryOp == FT_LogicalNOT:
aCriterion.UnaryOp = self.EnumToLong(FT_LogicalNOT)
- if Treshold in [FT_LogicalAND, FT_LogicalOR]:
- aCriterion.BinaryOp = self.EnumToLong(Treshold)
+ if Threshold in [FT_LogicalAND, FT_LogicalOR]:
+ aCriterion.BinaryOp = self.EnumToLong(Threshold)
if UnaryOp in [FT_LogicalAND, FT_LogicalOR]:
aCriterion.BinaryOp = self.EnumToLong(UnaryOp)
# @param elementType the type of elements in the group
# @param CritType the type of criterion ( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
# @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
- # @param Treshold the threshold value (range of id ids as string, shape, numeric)
+ # @param Threshold the threshold value (range of id ids as string, shape, numeric)
# @param UnaryOp FT_LogicalNOT or FT_Undefined
# @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface,
- # FT_LyingOnGeom, FT_CoplanarFaces criteria
+ # FT_LyingOnGeom, FT_CoplanarFaces and FT_EqualNodes criteria
# @return SMESH_Filter
#
# <a href="../tui_filters_page.html#tui_filters">Example of Filters usage</a>
def GetFilter(self,elementType,
CritType=FT_Undefined,
Compare=FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
Tolerance=1e-07):
- aCriterion = self.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance)
+ aCriterion = self.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
aFilterMgr = self.CreateFilterManager()
aFilter = aFilterMgr.CreateFilter()
aCriteria = []
def SetShape(self, geom):
self.mesh = self.smeshpyD.CreateMesh(geom)
+ ## Loads mesh from the study after opening the study
+ def Load(self):
+ self.mesh.Load()
+
## Returns true if the hypotheses are defined well
- # @param theSubObject a subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return True or False
# @ingroup l2_construct
def IsReadyToCompute(self, theSubObject):
## Returns errors of hypotheses definition.
# The list of errors is empty if everything is OK.
- # @param theSubObject a subshape of a mesh shape
+ # @param theSubObject a sub-shape of a mesh shape
# @return a list of errors
# @ingroup l2_construct
def GetAlgoState(self, theSubObject):
## Creates a segment discretization 1D algorithm.
# If the optional \a algo parameter is not set, this algorithm is REGULAR.
# \n If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo the type of the required algorithm. Possible values are:
# - smesh.REGULAR,
# - smesh.PYTHON for discretization via a python function,
# - smesh.COMPOSITE for meshing a set of edges on one face side as a whole.
- # @param geom If defined is the subshape to be meshed
+ # @param geom If defined is the sub-shape to be meshed
# @return an instance of Mesh_Segment or Mesh_Segment_Python, or Mesh_CompositeSegment class
# @ingroup l3_algos_basic
def Segment(self, algo=REGULAR, geom=0):
## Creates 1D algorithm importing segments conatined in groups of other mesh.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param geom If defined the subshape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
## Creates 2D algorithm importing faces conatined in groups of other mesh.
# If the optional \a geom parameter is not set, this algorithm is global.
# Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined the subshape is to be meshed
+ # @param geom If defined the sub-shape is to be meshed
# @return an instance of Mesh_UseExistingElements class
# @ingroup l3_algos_basic
def UseExisting2DElements(self, geom=0):
# The added nodes and segments must be bound to edges and vertices by
# SetNodeOnVertex(), SetNodeOnEdge() and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_1D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingSegments(self, geom=0):
# The added nodes and faces must be bound to geom faces by SetNodeOnFace()
# and SetMeshElementOnShape()
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom the subshape to be manually meshed
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom the sub-shape to be manually meshed
# @return StdMeshers_UseExisting_2D algorithm that generates nothing
# @ingroup l3_algos_basic
def UseExistingFaces(self, geom=0):
## Creates a triangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.MEFISTO || smesh.NETGEN_1D2D || smesh.NETGEN_2D || smesh.BLSURF
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Triangle algorithm
# @ingroup l3_algos_basic
def Triangle(self, algo=MEFISTO, geom=0):
## Creates a quadrangle 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @param algo values are: smesh.QUADRANGLE || smesh.RADIAL_QUAD
# @return an instance of Mesh_Quadrangle algorithm
# @ingroup l3_algos_basic
## Creates a tetrahedron 3D algorithm for solids.
# The parameter \a algo permits to choose the algorithm: NETGEN or GHS3D
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo values are: smesh.NETGEN, smesh.GHS3D, smesh.GHS3DPRL, smesh.FULL_NETGEN
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Tetrahedron algorithm
# @ingroup l3_algos_basic
def Tetrahedron(self, algo=NETGEN, geom=0):
## Creates a hexahedron 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # \n Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # \n Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# @param algo possible values are: smesh.Hexa, smesh.Hexotic
- # @param geom If defined, the subshape to be meshed (GEOM_Object)
+ # @param geom If defined, the sub-shape to be meshed (GEOM_Object)
# @return an instance of Mesh_Hexahedron algorithm
# @ingroup l3_algos_basic
def Hexahedron(self, algo=Hexa, geom=0):
## Creates a projection 1D algorithm for edges.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection1D algorithm
# @ingroup l3_algos_proj
def Projection1D(self, geom=0):
## Creates a projection 1D-2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection2D algorithm
# @ingroup l3_algos_proj
def Projection1D2D(self, geom=0):
## Creates a projection 2D algorithm for faces.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection2D algorithm
# @ingroup l3_algos_proj
def Projection2D(self, geom=0):
## Creates a projection 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Projection3D algorithm
# @ingroup l3_algos_proj
def Projection3D(self, geom=0):
## Creates a 3D extrusion (Prism 3D) or RadialPrism 3D algorithm for solids.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
- # @param geom If defined, the subshape to be meshed
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Prism3D or Mesh_RadialPrism3D algorithm
# @ingroup l3_algos_radialp l3_algos_3dextr
def Prism(self, geom=0):
# 3D structured Cartesian mesh in the internal part of a solid shape
# and polyhedral volumes near the shape boundary.
# If the optional \a geom parameter is not set, this algorithm is global.
- # Otherwise, this algorithm defines a submesh based on \a geom subshape.
+ # Otherwise, this algorithm defines a submesh based on \a geom sub-shape.
# The algorithm does not support submeshes.
# Generally usage of this algorithm as a local one is useless since
- # it does not discretize 1D and 2D subshapes in a usual way acceptable
+ # it does not discretize 1D and 2D sub-shapes in a usual way acceptable
# for other algorithms.
- # @param geom If defined, the subshape to be meshed
+ # @param geom If defined, the sub-shape to be meshed
# @return an instance of Mesh_Cartesian_3D algorithm
# @ingroup l3_algos_basic
def BodyFitted(self, geom=0):
## Unassigns a hypothesis
# @param hyp a hypothesis to unassign
- # @param geom a subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return SMESH.Hypothesis_Status
# @ingroup l2_hypotheses
def RemoveHypothesis(self, hyp, geom=0):
return status
## Gets the list of hypotheses added on a geometry
- # @param geom a subshape of mesh geometry
+ # @param geom a sub-shape of mesh geometry
# @return the sequence of SMESH_Hypothesis
# @ingroup l2_hypotheses
def GetHypothesisList(self, geom):
# @param elementType the type of elements in the group
# @param CritType the type of criterion( FT_Taper, FT_Area, FT_RangeOfIds, FT_LyingOnGeom etc. )
# @param Compare belongs to {FT_LessThan, FT_MoreThan, FT_EqualTo}
- # @param Treshold the threshold value (range of id ids as string, shape, numeric)
+ # @param Threshold the threshold value (range of id ids as string, shape, numeric)
# @param UnaryOp FT_LogicalNOT or FT_Undefined
# @param Tolerance the tolerance used by FT_BelongToGeom, FT_BelongToSurface,
# FT_LyingOnGeom, FT_CoplanarFaces criteria
elementType,
CritType=FT_Undefined,
Compare=FT_EqualTo,
- Treshold="",
+ Threshold="",
UnaryOp=FT_Undefined,
Tolerance=1e-07):
- aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Treshold, UnaryOp, FT_Undefined,Tolerance)
+ aCriterion = self.smeshpyD.GetCriterion(elementType, CritType, Compare, Threshold, UnaryOp, FT_Undefined,Tolerance)
group = self.MakeGroupByCriterion(groupName, aCriterion)
return group
def NbQuadranglesOfOrder(self, elementOrder):
return self.mesh.NbQuadranglesOfOrder(elementOrder)
+ ## Returns the number of biquadratic quadrangles in the mesh
+ # @return an integer value
+ # @ingroup l1_meshinfo
+ def NbBiQuadQuadrangles(self):
+ return self.mesh.NbBiQuadQuadrangles()
+
## Returns the number of polygons in the mesh
# @return an integer value
# @ingroup l1_meshinfo
def NbHexasOfOrder(self, elementOrder):
return self.mesh.NbHexasOfOrder(elementOrder)
+ ## Returns the number of triquadratic hexahedrons in the mesh
+ # @return an integer value
+ # @ingroup l1_meshinfo
+ def NbTriQuadraticHexas(self):
+ return self.mesh.NbTriQuadraticHexas()
+
## Returns the number of pyramids in the mesh
# @return an integer value
# @ingroup l1_meshinfo
def NbPrismsOfOrder(self, elementOrder):
return self.mesh.NbPrismsOfOrder(elementOrder)
+ ## Returns the number of hexagonal prisms in the mesh
+ # @return an integer value
+ # @ingroup l1_meshinfo
+ def NbHexagonalPrisms(self):
+ return self.mesh.NbHexagonalPrisms()
+
## Returns the number of polyhedrons in the mesh
# @return an integer value
# @ingroup l1_meshinfo
return self.mesh.GetElementGeomType(id)
## Returns the list of submesh elements IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be the sub-shape of a ShapeToMesh()
# @return the list of integer values
# @ingroup l1_meshinfo
def GetSubMeshElementsId(self, Shape):
return self.mesh.GetSubMeshElementsId(ShapeID)
## Returns the list of submesh nodes IDs
- # @param Shape a geom object(subshape) IOR
- # Shape must be the subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be the sub-shape of a ShapeToMesh()
# @param all If true, gives all nodes of submesh elements, otherwise gives only submesh nodes
# @return the list of integer values
# @ingroup l1_meshinfo
return self.mesh.GetSubMeshNodesId(ShapeID, all)
## Returns type of elements on given shape
- # @param Shape a geom object(subshape) IOR
- # Shape must be a subshape of a ShapeToMesh()
+ # @param Shape a geom object(sub-shape) IOR
+ # Shape must be a sub-shape of a ShapeToMesh()
# @return element type
# @ingroup l1_meshinfo
def GetSubMeshElementType(self, Shape):
# @param StepVector vector or DirStruct, 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):
+ def ExtrusionSweep(self, IDsOfElements, StepVector, NbOfSteps, MakeGroups=False, IsNodes = False):
if IDsOfElements == []:
IDsOfElements = self.GetElementsId()
if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
Parameters = StepVectorParameters + var_separator + Parameters
self.mesh.SetParameters(Parameters)
if MakeGroups:
- return self.editor.ExtrusionSweepMakeGroups(IDsOfElements, StepVector, NbOfSteps)
- self.editor.ExtrusionSweep(IDsOfElements, StepVector, NbOfSteps)
+ 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 []
## Generates new elements by extrusion of the elements with given ids
# @param StepVector vector, 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 which belong to the object 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):
+ def ExtrusionSweepObject(self, theObject, StepVector, NbOfSteps, MakeGroups=False, IsNodes=False):
if ( isinstance( theObject, Mesh )):
theObject = theObject.GetMesh()
if ( isinstance( StepVector, geompyDC.GEOM._objref_GEOM_Object)):
Parameters = StepVectorParameters + var_separator + Parameters
self.mesh.SetParameters(Parameters)
if MakeGroups:
- return self.editor.ExtrusionSweepObjectMakeGroups(theObject, StepVector, NbOfSteps)
- self.editor.ExtrusionSweepObject(theObject, StepVector, NbOfSteps)
+ 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 []
## Generates new elements by extrusion of the elements which belong to the object
UseExisting=0)
#UseExisting=UseExisting, CompareMethod=self.CompareSourceEdge)
hyp.SetSourceEdge( edge )
- if not mesh is None and isinstance(mesh, Mesh):
+ if isinstance(mesh, Mesh):
mesh = mesh.GetMesh()
hyp.SetSourceMesh( mesh )
hyp.SetVertexAssociation( srcV, tgtV )
UseExisting=0)
#UseExisting=UseExisting, CompareMethod=self.CompareSourceShape3D)
hyp.SetSource3DShape( solid )
- if not mesh is None and isinstance(mesh, Mesh):
+ if isinstance(mesh, Mesh):
mesh = mesh.GetMesh()
hyp.SetSourceMesh( mesh )
if srcV1 and srcV2 and tgtV1 and tgtV2:
