# -*- coding: iso-8859-1 -*-
-# Copyright (C) 2007-2014 CEA/DEN, EDF R&D, OPEN CASCADE
+# Copyright (C) 2007-2016 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
## by means of \ref geomBuilder.geomBuilder.addToStudy() "addToStudy()"
## or \ref geomBuilder.geomBuilder.addToStudyInFather() "addToStudyInFather()"
## functions.
-##
+##
## However, it is possible to publish result data in the study
## automatically. For this, almost each function of
## \ref geomBuilder.geomBuilder "geomBuilder" class has
## an additional @a theName parameter (@c None by default).
## As soon as non-empty string value is passed to this parameter,
## the result object is published in the study automatically.
-##
+##
## For example, consider the following Python script:
-##
+##
## @code
## import salome
## from salome.geom import geomBuilder
## box = geompy.MakeBoxDXDYDZ(100, 100, 100) # box is not published in the study yet
## geompy.addToStudy(box, "box") # explicit publishing
## @endcode
-##
+##
## Last two lines can be replaced by one-line instruction:
-##
+##
## @code
## box = geompy.MakeBoxDXDYDZ(100, 100, 100, theName="box") # box is published in the study with "box" name
## @endcode
-##
+##
## ... or simply
-##
+##
## @code
## box = geompy.MakeBoxDXDYDZ(100, 100, 100, "box") # box is published in the study with "box" name
## @endcode
## # create and publish cylinder
## cyl = geompy.MakeCylinderRH(100, 100, "cylinder")
## # get non blocks from cylinder
-## g1, g2 = geompy.GetNonBlocks(cyl, "nonblock")
+## g1, g2 = geompy.GetNonBlocks(cyl, theName="nonblock")
## @endcode
##
## Above example will publish both result compounds (first with non-hexa solids and
## However, if second command is invoked as
##
## @code
-## g1, g2 = geompy.GetNonBlocks(cyl, ("nonhexa", "nonquad"))
+## g1, g2 = geompy.GetNonBlocks(cyl, theName=("nonhexa", "nonquad"))
## @endcode
##
## ... the first compound will be published with "nonhexa" name, and second will be named "nonquad".
## value passed as parameter has the same effect.
## - if @a maxNbSubShapes is any positive value, automatic publishing is enabled and
## maximum number of sub-shapes allowed for publishing is set to specified value.
-##
-## When automatic publishing is enabled, you even do not need to pass @a theName parameter
+##
+## When automatic publishing is enabled, you even do not need to pass @a theName parameter
## to the functions creating objects, instead default names will be used. However, you
## can always change the behavior, by passing explicit name to the @a theName parameter
## and it will be used instead default one.
## from salome.geom import geomBuilder
## geompy = geomBuilder.New(salome.myStudy)
## geompy.addToStudyAuto() # enable automatic publication
-## box = geompy.MakeBoxDXDYDZ(100, 100, 100)
+## box = geompy.MakeBoxDXDYDZ(100, 100, 100)
## # the box is created and published in the study with default name
## geompy.addToStudyAuto(5) # set max allowed number of sub-shapes to 5
## vertices = geompy.SubShapeAll(box, geomBuilder.ShapeType['VERTEX'])
## # only 5 first vertices will be published, with default names
## print len(vertices)
-## # note, that result value still containes all 8 vertices
+## # note, that result value still contains all 8 vertices
## geompy.addToStudyAuto(-1) # disable automatic publication
## @endcode
##
##
## It is possible to customize the representation of the geometrical
## data in the data tree; this can be done by using folders. A folder can
-## be created in the study tree using function
-## \ref geomBuilder.geomBuilder.NewFolder() "NewFolder()"
-## (by default it is created under the "Geometry" root object).
-## As soon as folder is created, any published geometry object
+## be created in the study tree using function
+## \ref geomBuilder.geomBuilder.NewFolder() "NewFolder()"
+## (by default it is created under the "Geometry" root object).
+## As soon as folder is created, any published geometry object
## can be moved into it.
-##
+##
## For example:
-##
+##
## @code
## import salome
## from salome.geom import geomBuilder
## geompy = geomBuilder.New(salome.myStudy)
-## box = geompy.MakeBoxDXDYDZ(100, 100, 100, "Box")
+## box = geompy.MakeBoxDXDYDZ(100, 100, 100, "Box")
## # the box was created and published in the study
## folder = geompy.NewFolder("Primitives")
## # an empty "Primitives" folder was created under default "Geometry" root object
## geompy.PutToFolder(box, folder)
## # the box was moved into "Primitives" folder
## @endcode
-##
+##
## Subfolders are also can be created by specifying another folder as a parent:
-##
+##
## @code
## subfolder = geompy.NewFolder("3D", folder)
## # "3D" folder was created under "Primitives" folder
## @endcode
-##
+##
## @note
## - Folder container is just a representation layer object that
-## deals with already published objects only. So, any geometry object
-## should be published in the study (for example, with
+## deals with already published objects only. So, any geometry object
+## should be published in the study (for example, with
## \ref geomBuilder.geomBuilder.PutToFolder() "addToStudy()" function)
## BEFORE moving it into any existing folder.
## - \ref geomBuilder.geomBuilder.PutToFolder() "PutToFolder()" function
## does not change physical position of geometry object in the study tree,
## it only affects on the representation of the data tree.
## - It is impossible to publish geometry object using any folder as father.
-##
+##
## \defgroup l1_publish_data
## \defgroup l1_geomBuilder_auxiliary
## \defgroup l1_geomBuilder_purpose
import GEOM
import math
import os
+import functools
-from salome.geom.gsketcher import Sketcher3D, Sketcher2D
+from salome.geom.gsketcher import Sketcher3D, Sketcher2D, Polyline2D
# service function
def _toListOfNames(_names, _size=-1):
for i in range(len(l), _size): l.append("%s_%d"%(l[0],i))
return l
+# Decorator function to manage transactions for all geometric operations.
+def ManageTransactions(theOpeName):
+ def MTDecorator(theFunction):
+ # To keep the original function name an documentation.
+ @functools.wraps(theFunction)
+ def OpenCallClose(self, *args, **kwargs):
+ # Open transaction
+ anOperation = getattr(self, theOpeName)
+ anOperation.StartOperation()
+ try:
+ # Call the function
+ res = theFunction(self, *args, **kwargs)
+ # Commit transaction
+ anOperation.FinishOperation()
+ return res
+ except:
+ # Abort transaction
+ anOperation.AbortOperation()
+ raise
+ return OpenCallClose
+ return MTDecorator
+
## Raise an Error, containing the Method_name, if Operation is Failed
## @ingroup l1_geomBuilder_auxiliary
def RaiseIfFailed (Method_name, Operation):
- if Operation.IsDone() == 0 and Operation.GetErrorCode() != "NOT_FOUND_ANY":
- Operation.AbortOperation()
+ if not Operation.IsDone() and Operation.GetErrorCode() != "NOT_FOUND_ANY":
raise RuntimeError, Method_name + " : " + Operation.GetErrorCode()
- else:
- Operation.FinishOperation()
- pass
## Return list of variables value from salome notebook
## @ingroup l1_geomBuilder_auxiliary
Returns:
data packed to the byte stream
-
+
Example of usage:
val = PackData("10001110") # val = 0xAE
val = PackData("1") # val = 0x80
texture bitmap itself.
This function can be used to read the texture to the byte stream in order to pass it to
the AddTexture() function of geomBuilder class.
-
+
Parameters:
fname texture file name
Returns:
sequence of tree values: texture's width, height in pixels and its byte stream
-
+
Example of usage:
from salome.geom import geomBuilder
geompy = geomBuilder.New(salome.myStudy)
if hasattr(theItem, "_v"): ret = theItem._v
return ret
+## Pack an argument into a list
+def ToList( arg ):
+ if isinstance( arg, list ):
+ return arg
+ if hasattr( arg, "__getitem__" ):
+ return list( arg )
+ return [ arg ]
+
## Information about closed/unclosed state of shell or wire
# @ingroup l1_geomBuilder_auxiliary
class info:
self.function = function
pass
+ @ManageTransactions("operation")
def __call__(self, *args):
res = self.function(self.operation, *args)
RaiseIfFailed(self.function.__name__, self.operation)
## Enumeration ShapeType as a dictionary. \n
## Topological types of shapes (like Open Cascade types). See GEOM::shape_type for details.
# @ingroup l1_geomBuilder_auxiliary
- ShapeType = {"AUTO":-1, "COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}
+ ShapeType = {"AUTO":-1, "COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8, "FLAT":9}
## Kinds of shape in terms of <VAR>GEOM.GEOM_IKindOfShape.shape_kind</VAR> enumeration
# and a list of parameters, describing the shape.
# - EDGE: [nb_vertices]
#
# - VERTEX: [x y z]
+ #
+ # - LCS: [x y z xx xy xz yx yy yz zx zy zz]
# @ingroup l1_geomBuilder_auxiliary
kind = GEOM.GEOM_IKindOfShape
self.MeasuOp = None
self.BlocksOp = None
self.GroupOp = None
- self.AdvOp = None
self.FieldOp = None
pass
self.GroupOp = self.GetIGroupOperations (self.myStudyId)
self.FieldOp = self.GetIFieldOperations (self.myStudyId)
- # The below line is a right way to map all plugin functions to geomBuilder,
- # but AdvancedOperations are already mapped, that is why this line is commented
- # and presents here only as an axample
- #self.AdvOp = self.GetPluginOperations (self.myStudyId, "AdvancedEngine")
-
- # self.AdvOp is used by functions MakePipeTShape*, MakeDividedDisk, etc.
- self.AdvOp = GEOM._objref_GEOM_Gen.GetPluginOperations (self, self.myStudyId, "AdvancedEngine")
-
# set GEOM as root in the use case tree
self.myUseCaseBuilder = self.myStudy.GetUseCaseBuilder()
self.myUseCaseBuilder.SetRootCurrent()
self.myUseCaseBuilder.Append(self.father)
+
+ # load data from the study file, if necessary
+ self.myBuilder.LoadWith(self.father, self)
pass
def GetPluginOperations(self, studyID, libraryName):
op = GEOM._objref_GEOM_Gen.GetPluginOperations(self, studyID, libraryName)
- if op:
- # bind methods of operations to self
- methods = op.__class__.__dict__['__methods__']
- avoid_methods = self.BasicOp.__class__.__dict__['__methods__']
- for meth_name in methods:
- if not meth_name in avoid_methods: # avoid basic methods
- function = getattr(op.__class__, meth_name)
- if callable(function):
- #self.__dict__[meth_name] = self.__PluginOperation(op, function)
- self.__dict__[meth_name] = PluginOperation(op, function)
return op
## Enable / disable results auto-publishing
- #
+ #
# The automatic publishing is managed in the following way:
# - if @a maxNbSubShapes = 0, automatic publishing is disabled.
# - if @a maxNbSubShapes = -1 (default), automatic publishing is enabled and
## Get name for sub-shape aSubObj of shape aMainObj
#
# @ref swig_SubShapeName "Example"
+ @ManageTransactions("ShapesOp")
def SubShapeName(self,aSubObj, aMainObj):
"""
Get name for sub-shape aSubObj of shape aMainObj
genericAttribute = self.myBuilder.FindOrCreateAttribute(aSObject, "AttributeDrawable")
drwAttribute = genericAttribute._narrow(SALOMEDS.AttributeDrawable)
drwAttribute.SetDrawable(False)
+ # hide references if any
+ vso = self.myStudy.FindDependances(aSObject);
+ for refObj in vso :
+ genericAttribute = self.myBuilder.FindOrCreateAttribute(refObj, "AttributeDrawable")
+ drwAttribute = genericAttribute._narrow(SALOMEDS.AttributeDrawable)
+ drwAttribute.SetDrawable(False)
+ pass
pass
# end of l1_geomBuilder_auxiliary
# in place of sub-shapes of the first argument,
# because the whole shape corresponds to the first argument.
# Mainly to be used after transformations, but it also can be
- # usefull after partition with one object shape, and some other
+ # useful after partition with one object shape, and some other
# operations, where only the first argument has to be considered.
# If theObject has only one argument shape, this flag is automatically
# considered as True, not regarding really passed value.
in place of sub-shapes of the first argument,
because the whole shape corresponds to the first argument.
Mainly to be used after transformations, but it also can be
- usefull after partition with one object shape, and some other
+ useful after partition with one object shape, and some other
operations, where only the first argument has to be considered.
If theObject has only one argument shape, this flag is automatically
considered as True, not regarding really passed value.
# in place of sub-shapes of the first argument,
# because the whole shape corresponds to the first argument.
# Mainly to be used after transformations, but it also can be
- # usefull after partition with one object shape, and some other
+ # useful after partition with one object shape, and some other
# operations, where only the first argument has to be considered.
# If theObject has only one argument shape, this flag is automatically
# considered as True, not regarding really passed value.
in place of sub-shapes of the first argument,
because the whole shape corresponds to the first argument.
Mainly to be used after transformations, but it also can be
- usefull after partition with one object shape, and some other
+ useful after partition with one object shape, and some other
operations, where only the first argument has to be considered.
If theObject has only one argument shape, this flag is automatically
considered as True, not regarding really passed value.
theAddPrefix add prefix "from_" to names of restored sub-shapes,
and prefix "from_subshapes_of_" to names of partially restored sub-shapes.
- Returns:
+ Returns:
list of published sub-shapes
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
+ @ManageTransactions("BasicOp")
def MakeVertex(self, theX, theY, theZ, theName=None):
"""
Create point by three coordinates.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
- Returns:
+
+ Returns:
New GEOM.GEOM_Object, containing the created point.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexWithRef(self, theReference, theX, theY, theZ, theName=None):
"""
Create a point, distant from the referenced point
## Create a point, corresponding to the given parameter on the given curve.
# @param theRefCurve The referenced curve.
# @param theParameter Value of parameter on the referenced curve.
+ # @param takeOrientationIntoAccount flag that tells if it is necessary
+ # to take the curve's orientation into account for the
+ # operation. I.e. if this flag is set, the results for the same
+ # parameters (except the value 0.5) is different for forward
+ # and reversed curves. If it is not set the result is the same.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
- def MakeVertexOnCurve(self, theRefCurve, theParameter, theName=None):
+ @ManageTransactions("BasicOp")
+ def MakeVertexOnCurve(self, theRefCurve, theParameter,
+ takeOrientationIntoAccount=False, theName=None):
"""
Create a point, corresponding to the given parameter on the given curve.
Parameters:
theRefCurve The referenced curve.
theParameter Value of parameter on the referenced curve.
+ takeOrientationIntoAccount flag that tells if it is necessary
+ to take the curve's orientation into account for the
+ operation. I.e. if this flag is set, the results for
+ the same parameters (except the value 0.5) is different
+ for forward and reversed curves. If it is not set
+ the result is the same.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
p_on_arc = geompy.MakeVertexOnCurve(Arc, 0.25)
"""
# Example: see GEOM_TestAll.py
- theParameter, Parameters = ParseParameters(theParameter)
- anObj = self.BasicOp.MakePointOnCurve(theRefCurve, theParameter)
+ theParameter, takeOrientationIntoAccount, Parameters = ParseParameters(
+ theParameter, takeOrientationIntoAccount)
+ anObj = self.BasicOp.MakePointOnCurve(theRefCurve, theParameter,
+ takeOrientationIntoAccount)
RaiseIfFailed("MakePointOnCurve", self.BasicOp)
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "vertex")
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexOnCurveByCoord(self, theRefCurve, theX, theY, theZ, theName=None):
"""
Create a point by projection give coordinates on the given curve
-
+
Parameters:
theRefCurve The referenced curve.
theX X-coordinate in 3D space
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref tui_creation_point "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None, theName=None):
"""
Create a point, corresponding to the given length on the given curve.
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref swig_MakeVertexOnSurface "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexOnSurface(self, theRefSurf, theUParameter, theVParameter, theName=None):
"""
Create a point, corresponding to the given parameters on the
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref swig_MakeVertexOnSurfaceByCoord "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexOnSurfaceByCoord(self, theRefSurf, theX, theY, theZ, theName=None):
"""
Create a point by projection give coordinates on the given surface
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref swig_MakeVertexInsideFace "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexInsideFace (self, theFace, theName=None):
"""
Create a point, which lays on the given face.
# @return New GEOM.GEOM_Object, containing the created point.
#
# @ref swig_MakeVertexOnLinesIntersection "Example"
+ @ManageTransactions("BasicOp")
def MakeVertexOnLinesIntersection(self, theRefLine1, theRefLine2, theName=None):
"""
Create a point on intersection of two lines.
# @return New GEOM.GEOM_Object, containing the created tangent.
#
# @ref swig_MakeTangentOnCurve "Example"
+ @ManageTransactions("BasicOp")
def MakeTangentOnCurve(self, theRefCurve, theParameter, theName=None):
"""
Create a tangent, corresponding to the given parameter on the given curve.
# @return New GEOM.GEOM_Object, containing the created tangent.
#
# @ref swig_MakeTangentPlaneOnFace "Example"
+ @ManageTransactions("BasicOp")
def MakeTangentPlaneOnFace(self, theFace, theParameterU, theParameterV, theTrimSize, theName=None):
"""
Create a tangent plane, corresponding to the given parameter on the given face.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created tangent.
Example of usage:
# @return New GEOM.GEOM_Object, containing the created vector.
#
# @ref tui_creation_vector "Example"
+ @ManageTransactions("BasicOp")
def MakeVectorDXDYDZ(self, theDX, theDY, theDZ, theName=None):
"""
Create a vector with the given components.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created vector.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created vector.
#
# @ref tui_creation_vector "Example"
+ @ManageTransactions("BasicOp")
def MakeVector(self, thePnt1, thePnt2, theName=None):
"""
Create a vector between two points.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created vector.
"""
# Example: see GEOM_TestAll.py
return anObj
## Create a line, passing through the given point
- # and parrallel to the given direction
+ # and parallel to the given direction
# @param thePnt Point. The resulting line will pass through it.
# @param theDir Direction. The resulting line will be parallel to it.
# @param theName Object name; when specified, this parameter is used
# @return New GEOM.GEOM_Object, containing the created line.
#
# @ref tui_creation_line "Example"
+ @ManageTransactions("BasicOp")
def MakeLine(self, thePnt, theDir, theName=None):
"""
Create a line, passing through the given point
- and parrallel to the given direction
+ and parallel to the given direction
Parameters:
thePnt Point. The resulting line will pass through it.
# @return New GEOM.GEOM_Object, containing the created line.
#
# @ref tui_creation_line "Example"
+ @ManageTransactions("BasicOp")
def MakeLineTwoPnt(self, thePnt1, thePnt2, theName=None):
"""
Create a line, passing through the given points
# @return New GEOM.GEOM_Object, containing the created line.
#
# @ref swig_MakeLineTwoFaces "Example"
+ @ManageTransactions("BasicOp")
def MakeLineTwoFaces(self, theFace1, theFace2, theName=None):
"""
Create a line on two faces intersection.
# @return New GEOM.GEOM_Object, containing the created plane.
#
# @ref tui_creation_plane "Example"
+ @ManageTransactions("BasicOp")
def MakePlane(self, thePnt, theVec, theTrimSize, theName=None):
"""
Create a plane, passing through the given point
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created plane.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created plane.
#
# @ref tui_creation_plane "Example"
+ @ManageTransactions("BasicOp")
def MakePlaneThreePnt(self, thePnt1, thePnt2, thePnt3, theTrimSize, theName=None):
"""
Create a plane, passing through the three given points
# @return New GEOM.GEOM_Object, containing the created plane.
#
# @ref tui_creation_plane "Example"
+ @ManageTransactions("BasicOp")
def MakePlaneFace(self, theFace, theTrimSize, theName=None):
"""
Create a plane, similar to the existing one, but with another size of representing face.
# @return New GEOM.GEOM_Object, containing the created plane.
#
# @ref tui_creation_plane "Example"
+ @ManageTransactions("BasicOp")
def MakePlane2Vec(self, theVec1, theVec2, theTrimSize, theName=None):
"""
Create a plane, passing through the 2 vectors
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created plane.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created plane.
#
# @ref tui_creation_plane "Example"
+ @ManageTransactions("BasicOp")
def MakePlaneLCS(self, theLCS, theTrimSize, theOrientation, theName=None):
"""
Create a plane, based on a Local coordinate system.
- Parameters:
+ Parameters:
theLCS coordinate system, defining plane.
theTrimSize Half size of a side of quadrangle face, representing the plane.
theOrientation OXY, OYZ or OZX orientation - (1, 2 or 3)
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created plane.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created coordinate system.
#
# @ref swig_MakeMarker "Example"
+ @ManageTransactions("BasicOp")
def MakeMarker(self, OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ, theName=None):
"""
Create a local coordinate system.
- Parameters:
+ Parameters:
OX,OY,OZ Three coordinates of coordinate system origin.
XDX,XDY,XDZ Three components of OX direction
YDX,YDY,YDZ Three components of OY direction
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created coordinate system.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created coordinate system.
#
# @ref tui_creation_lcs "Example"
+ @ManageTransactions("BasicOp")
def MakeMarkerFromShape(self, theShape, theName=None):
"""
Create a local coordinate system from shape.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
- Returns:
+
+ Returns:
New GEOM.GEOM_Object, containing the created coordinate system.
"""
anObj = self.BasicOp.MakeMarkerFromShape(theShape)
# @return New GEOM.GEOM_Object, containing the created coordinate system.
#
# @ref tui_creation_lcs "Example"
+ @ManageTransactions("BasicOp")
def MakeMarkerPntTwoVec(self, theOrigin, theXVec, theYVec, theName=None):
"""
Create a local coordinate system from point and two vectors.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created coordinate system.
"""
# @return New GEOM.GEOM_Object, containing the created arc.
#
# @ref swig_MakeArc "Example"
+ @ManageTransactions("CurvesOp")
def MakeArc(self, thePnt1, thePnt2, thePnt3, theName=None):
"""
Create an arc of circle, passing through three given points.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created arc.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created arc.
#
# @ref swig_MakeArc "Example"
+ @ManageTransactions("CurvesOp")
def MakeArcCenter(self, thePnt1, thePnt2, thePnt3, theSense=False, theName=None):
"""
Create an arc of circle from a center and 2 points.
# @return New GEOM.GEOM_Object, containing the created arc.
#
# @ref swig_MakeArc "Example"
+ @ManageTransactions("CurvesOp")
def MakeArcOfEllipse(self, theCenter, thePnt1, thePnt2, theName=None):
"""
Create an arc of ellipse, of center and two points.
# @return New GEOM.GEOM_Object, containing the created circle.
#
# @ref tui_creation_circle "Example"
+ @ManageTransactions("CurvesOp")
def MakeCircle(self, thePnt, theVec, theR, theName=None):
"""
Create a circle with given center, normal vector and radius.
# publication is switched on, default value is used for result name.
#
# @return New GEOM.GEOM_Object, containing the created circle.
+ @ManageTransactions("CurvesOp")
def MakeCircleR(self, theR, theName=None):
"""
Create a circle with given radius.
# @return New GEOM.GEOM_Object, containing the created circle.
#
# @ref tui_creation_circle "Example"
+ @ManageTransactions("CurvesOp")
def MakeCircleThreePnt(self, thePnt1, thePnt2, thePnt3, theName=None):
"""
Create a circle, passing through three given points
# @return New GEOM.GEOM_Object, containing the created circle.
#
# @ref swig_MakeCircle "Example"
+ @ManageTransactions("CurvesOp")
def MakeCircleCenter2Pnt(self, thePnt1, thePnt2, thePnt3, theName=None):
"""
Create a circle, with given point1 as center,
# @return New GEOM.GEOM_Object, containing the created ellipse.
#
# @ref tui_creation_ellipse "Example"
+ @ManageTransactions("CurvesOp")
def MakeEllipse(self, thePnt, theVec, theRMajor, theRMinor, theVecMaj=None, theName=None):
"""
Create an ellipse with given center, normal vector and radiuses.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created ellipse.
"""
# Example: see GEOM_TestAll.py
# publication is switched on, default value is used for result name.
#
# @return New GEOM.GEOM_Object, containing the created ellipse.
+ @ManageTransactions("CurvesOp")
def MakeEllipseRR(self, theRMajor, theRMinor, theName=None):
"""
Create an ellipse with given radiuses.
# @return New GEOM.GEOM_Object, containing the created polyline.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakePolyline(self, thePoints, theIsClosed=False, theName=None):
"""
Create a polyline on the set of points.
# @return New GEOM.GEOM_Object, containing the created bezier curve.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakeBezier(self, thePoints, theIsClosed=False, theName=None):
"""
Create bezier curve on the set of points.
# @return New GEOM.GEOM_Object, containing the created B-Spline curve.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakeInterpol(self, thePoints, theIsClosed=False, theDoReordering=False, theName=None):
"""
Create B-Spline curve on the set of points.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created B-Spline curve.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created B-Spline curve.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakeInterpolWithTangents(self, thePoints, theFirstVec, theLastVec, theName=None):
"""
Create B-Spline curve on the set of points.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created B-Spline curve.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created curve.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakeCurveParametric(self, thexExpr, theyExpr, thezExpr,
theParamMin, theParamMax, theParamStep, theCurveType, theNewMethod=False, theName=None ):
"""
if theNewMethod:
anObj = self.CurvesOp.MakeCurveParametricNew(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
else:
- anObj = self.CurvesOp.MakeCurveParametric(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
- RaiseIfFailed("MakeSplineInterpolation", self.CurvesOp)
+ anObj = self.CurvesOp.MakeCurveParametric(thexExpr,theyExpr,thezExpr,theParamMin,theParamMax,theParamStep,theCurveType)
+ RaiseIfFailed("MakeCurveParametric", self.CurvesOp)
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "curve")
return anObj
# a compound of edges.
#
# @ref tui_creation_curve "Example"
+ @ManageTransactions("CurvesOp")
def MakeIsoline(self, theFace, IsUIsoline, theParameter, theName=None):
"""
Create an isoline curve on a face.
# @return New GEOM.GEOM_Object, containing the created wire.
#
# @ref tui_sketcher_page "Example"
+ @ManageTransactions("CurvesOp")
def MakeSketcher(self, theCommand, theWorkingPlane = [0,0,0, 0,0,1, 1,0,0], theName=None):
"""
Create a sketcher (wire or face), following the textual description, passed
- CMD is one of
- "R angle" : Set the direction by angle
- "D dx dy" : Set the direction by DX & DY
-
+
- "TT x y" : Create segment by point at X & Y
- "T dx dy" : Create segment by point with DX & DY
- "L length" : Create segment by direction & Length
- "WW" : Close Wire (to finish)
- "WF" : Close Wire and build face (to finish)
-
+
- Flag1 (= reverse) is 0 or 2 ...
- if 0 the drawn arc is the one of lower angle (< Pi)
- if 2 the drawn arc ius the one of greater angle (> Pi)
-
+
- Flag2 (= control tolerance) is 0 or 1 ...
- if 0 the specified end point can be at a distance of the arc greater than the tolerance (10^-7)
- if 1 the wire is built only if the end point is on the arc
# @return New GEOM.GEOM_Object, containing the created wire.
#
# @ref tui_sketcher_page "Example"
+ @ManageTransactions("CurvesOp")
def MakeSketcherOnPlane(self, theCommand, theWorkingPlane, theName=None):
"""
Create a sketcher (wire or face), following the textual description,
return anObj
## Obtain a 2D sketcher interface
- # @return An instance of @ref gsketcher.Sketcher2D "Sketcher2D" interface
+ # @return An instance of @ref gsketcher.Sketcher2D "Sketcher2D" interface
def Sketcher2D (self):
"""
Obtain a 2D sketcher interface.
"""
sk = Sketcher2D (self)
return sk
-
+
## Create a sketcher wire, following the numerical description,
# passed through <VAR>theCoordinates</VAR> argument. \n
# @param theCoordinates double values, defining points to create a wire,
# @return New GEOM.GEOM_Object, containing the created wire.
#
# @ref tui_3dsketcher_page "Example"
+ @ManageTransactions("CurvesOp")
def Make3DSketcher(self, theCoordinates, theName=None):
"""
Create a sketcher wire, following the numerical description,
sk = Sketcher3D (self)
return sk
+ ## Obtain a 2D polyline creation interface
+ # @return An instance of @ref gsketcher.Polyline2D "Polyline2D" interface
+ #
+ # @ref tui_3dsketcher_page "Example"
+ def Polyline2D (self):
+ """
+ Obtain a 2D polyline creation interface.
+
+ Example of usage:
+ pl = geompy.Polyline2D()
+ pl.addSection("section 1", GEOM.Polyline, True)
+ pl.addPoints(0, 0, 10, 0, 10, 10)
+ pl.addSection("section 2", GEOM.Interpolation, False)
+ pl.addPoints(20, 0, 30, 0, 30, 10)
+ resultObj = pl.result(WorkingPlane)
+ """
+ pl = Polyline2D (self)
+ return pl
+
# end of l3_sketcher
## @}
def MakeBox(self, x1, y1, z1, x2, y2, z2, theName=None):
"""
Create a box by coordinates of two opposite vertices.
-
+
Parameters:
x1,y1,z1 double values, defining first point.
x2,y2,z2 double values, defining second point.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
+
Returns:
New GEOM.GEOM_Object, containing the created box.
"""
# @return New GEOM.GEOM_Object, containing the created box.
#
# @ref tui_creation_box "Example"
+ @ManageTransactions("PrimOp")
def MakeBoxDXDYDZ(self, theDX, theDY, theDZ, theName=None):
"""
Create a box with specified dimensions along the coordinate axes
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created box.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created box.
#
# @ref tui_creation_box "Example"
+ @ManageTransactions("PrimOp")
def MakeBoxTwoPnt(self, thePnt1, thePnt2, theName=None):
"""
Create a box with two specified opposite vertices,
# @return New GEOM.GEOM_Object, containing the created face.
#
# @ref tui_creation_face "Example"
+ @ManageTransactions("PrimOp")
def MakeFaceHW(self, theH, theW, theOrientation, theName=None):
"""
Create a face with specified dimensions with edges parallel to coordinate axes.
# @return New GEOM.GEOM_Object, containing the created face.
#
# @ref tui_creation_face "Example"
+ @ManageTransactions("PrimOp")
def MakeFaceObjHW(self, theObj, theH, theW, theName=None):
"""
Create a face from another plane and two sizes,
# @return New GEOM.GEOM_Object, containing the created disk.
#
# @ref tui_creation_disk "Example"
+ @ManageTransactions("PrimOp")
def MakeDiskPntVecR(self, thePnt, theVec, theR, theName=None):
"""
Create a disk with given center, normal vector and radius.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created disk.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created disk.
#
# @ref tui_creation_disk "Example"
+ @ManageTransactions("PrimOp")
def MakeDiskThreePnt(self, thePnt1, thePnt2, thePnt3, theName=None):
"""
Create a disk, passing through three given points
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created disk.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created disk.
#
# @ref tui_creation_face "Example"
+ @ManageTransactions("PrimOp")
def MakeDiskR(self, theR, theOrientation, theName=None):
"""
Create a disk with specified dimensions along OX-OY coordinate axes.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created disk.
Example of usage:
# @return New GEOM.GEOM_Object, containing the created cylinder.
#
# @ref tui_creation_cylinder "Example"
+ @ManageTransactions("PrimOp")
def MakeCylinder(self, thePnt, theAxis, theR, theH, theName=None):
"""
Create a cylinder with given base point, axis, radius and height.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created cylinder.
"""
# Example: see GEOM_TestAll.py
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "cylinder")
return anObj
+
+ ## Create a portion of cylinder with given base point, axis, radius, height and angle.
+ # @param thePnt Central point of cylinder base.
+ # @param theAxis Cylinder axis.
+ # @param theR Cylinder radius.
+ # @param theH Cylinder height.
+ # @param theA Cylinder angle in radians.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the created cylinder.
+ #
+ # @ref tui_creation_cylinder "Example"
+ @ManageTransactions("PrimOp")
+ def MakeCylinderA(self, thePnt, theAxis, theR, theH, theA, theName=None):
+ """
+ Create a portion of cylinder with given base point, axis, radius, height and angle.
+
+ Parameters:
+ thePnt Central point of cylinder base.
+ theAxis Cylinder axis.
+ theR Cylinder radius.
+ theH Cylinder height.
+ theA Cylinder angle in radians.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created cylinder.
+ """
+ # Example: see GEOM_TestAll.py
+ flag = False
+ if isinstance(theA,str):
+ flag = True
+ theR,theH,theA,Parameters = ParseParameters(theR, theH, theA)
+ if flag:
+ theA = theA*math.pi/180.
+ if theA<=0. or theA>=2*math.pi:
+ raise ValueError("The angle parameter should be strictly between 0 and 2*pi.")
+ anObj = self.PrimOp.MakeCylinderPntVecRHA(thePnt, theAxis, theR, theH, theA)
+ RaiseIfFailed("MakeCylinderPntVecRHA", self.PrimOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "cylinder")
+ return anObj
## Create a cylinder with given radius and height at
# the origin of coordinate system. Axis of the cylinder
# @return New GEOM.GEOM_Object, containing the created cylinder.
#
# @ref tui_creation_cylinder "Example"
+ @ManageTransactions("PrimOp")
def MakeCylinderRH(self, theR, theH, theName=None):
"""
Create a cylinder with given radius and height at
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created cylinder.
"""
# Example: see GEOM_TestAll.py
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "cylinder")
return anObj
+
+ ## Create a portion of cylinder with given radius, height and angle at
+ # the origin of coordinate system. Axis of the cylinder
+ # will be collinear to the OZ axis of the coordinate system.
+ # @param theR Cylinder radius.
+ # @param theH Cylinder height.
+ # @param theA Cylinder angle in radians.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the created cylinder.
+ #
+ # @ref tui_creation_cylinder "Example"
+ @ManageTransactions("PrimOp")
+ def MakeCylinderRHA(self, theR, theH, theA, theName=None):
+ """
+ Create a portion of cylinder with given radius, height and angle at
+ the origin of coordinate system. Axis of the cylinder
+ will be collinear to the OZ axis of the coordinate system.
+
+ Parameters:
+ theR Cylinder radius.
+ theH Cylinder height.
+ theA Cylinder angle in radians.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created cylinder.
+ """
+ # Example: see GEOM_TestAll.py
+ flag = False
+ if isinstance(theA,str):
+ flag = True
+ theR,theH,theA,Parameters = ParseParameters(theR, theH, theA)
+ if flag:
+ theA = theA*math.pi/180.
+ if theA<=0. or theA>=2*math.pi:
+ raise ValueError("The angle parameter should be strictly between 0 and 2*pi.")
+ anObj = self.PrimOp.MakeCylinderRHA(theR, theH, theA)
+ RaiseIfFailed("MakeCylinderRHA", self.PrimOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "cylinder")
+ return anObj
## Create a sphere with given center and radius.
# @param thePnt Sphere center.
# @return New GEOM.GEOM_Object, containing the created sphere.
#
# @ref tui_creation_sphere "Example"
+ @ManageTransactions("PrimOp")
def MakeSpherePntR(self, thePnt, theR, theName=None):
"""
Create a sphere with given center and radius.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created sphere.
+ Returns:
+ New GEOM.GEOM_Object, containing the created sphere.
"""
# Example: see GEOM_TestAll.py
theR,Parameters = ParseParameters(theR)
"""
Create a sphere with given center and radius.
- Parameters:
+ Parameters:
x,y,z Coordinates of sphere center.
theR Sphere radius.
theName Object name; when specified, this parameter is used
# @return New GEOM.GEOM_Object, containing the created sphere.
#
# @ref tui_creation_sphere "Example"
+ @ManageTransactions("PrimOp")
def MakeSphereR(self, theR, theName=None):
"""
Create a sphere with given radius at the origin of coordinate system.
- Parameters:
+ Parameters:
theR Sphere radius.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created sphere.
+ New GEOM.GEOM_Object, containing the created sphere.
"""
# Example: see GEOM_TestAll.py
theR,Parameters = ParseParameters(theR)
# @return New GEOM.GEOM_Object, containing the created cone.
#
# @ref tui_creation_cone "Example"
+ @ManageTransactions("PrimOp")
def MakeCone(self, thePnt, theAxis, theR1, theR2, theH, theName=None):
"""
Create a cone with given base point, axis, height and radiuses.
- Parameters:
+ Parameters:
thePnt Central point of the first cone base.
theAxis Cone axis.
theR1 Radius of the first cone base.
# @return New GEOM.GEOM_Object, containing the created cone.
#
# @ref tui_creation_cone "Example"
+ @ManageTransactions("PrimOp")
def MakeConeR1R2H(self, theR1, theR2, theH, theName=None):
"""
Create a cone with given height and radiuses at
the origin of coordinate system. Axis of the cone will
be collinear to the OZ axis of the coordinate system.
- Parameters:
+ Parameters:
theR1 Radius of the first cone base.
theR2 Radius of the second cone base.
theH Cone height.
# @return New GEOM.GEOM_Object, containing the created torus.
#
# @ref tui_creation_torus "Example"
+ @ManageTransactions("PrimOp")
def MakeTorus(self, thePnt, theVec, theRMajor, theRMinor, theName=None):
"""
Create a torus with given center, normal vector and radiuses.
- Parameters:
+ Parameters:
thePnt Torus central point.
theVec Torus axis of symmetry.
theRMajor Torus major radius.
# @return New GEOM.GEOM_Object, containing the created torus.
#
# @ref tui_creation_torus "Example"
+ @ManageTransactions("PrimOp")
def MakeTorusRR(self, theRMajor, theRMinor, theName=None):
"""
Create a torus with given radiuses at the origin of coordinate system.
- Parameters:
+ Parameters:
theRMajor Torus major radius.
theRMinor Torus minor radius.
theName Object name; when specified, this parameter is used
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created torus.
+ New GEOM.GEOM_Object, containing the created torus.
"""
# Example: see GEOM_TestAll.py
theRMajor,theRMinor,Parameters = ParseParameters(theRMajor,theRMinor)
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrism(self, theBase, thePoint1, thePoint2, theScaleFactor = -1.0, theName=None):
"""
Create a shape by extrusion of the base shape along a vector, defined by two points.
- Parameters:
+ Parameters:
theBase Base shape to be extruded.
thePoint1 First end of extrusion vector.
thePoint2 Second end of extrusion vector.
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrism2Ways(self, theBase, thePoint1, thePoint2, theName=None):
"""
Create a shape by extrusion of the base shape along a
vector, defined by two points, in 2 Ways (forward/backward).
- Parameters:
+ Parameters:
theBase Base shape to be extruded.
thePoint1 First end of extrusion vector.
thePoint2 Second end of extrusion vector.
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrismVecH(self, theBase, theVec, theH, theScaleFactor = -1.0, theName=None):
"""
Create a shape by extrusion of the base shape along the vector,
i.e. all the space, transfixed by the base shape during its translation
along the vector on the given distance.
- Parameters:
+ Parameters:
theBase Base shape to be extruded.
theVec Direction of extrusion.
theH Prism dimension along theVec.
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrismVecH2Ways(self, theBase, theVec, theH, theName=None):
"""
Create a shape by extrusion of the base shape along the vector,
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrismDXDYDZ(self, theBase, theDX, theDY, theDZ, theScaleFactor = -1.0, theName=None):
"""
Create a shape by extrusion of the base shape along the dx, dy, dz direction
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created prism.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created prism.
#
# @ref tui_creation_prism "Example"
+ @ManageTransactions("PrimOp")
def MakePrismDXDYDZ2Ways(self, theBase, theDX, theDY, theDZ, theName=None):
"""
Create a shape by extrusion of the base shape along the dx, dy, dz direction
# @return New GEOM.GEOM_Object, containing the created revolution.
#
# @ref tui_creation_revolution "Example"
+ @ManageTransactions("PrimOp")
def MakeRevolution(self, theBase, theAxis, theAngle, theName=None):
"""
Create a shape by revolution of the base shape around the axis
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created revolution.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created revolution.
#
# @ref tui_creation_revolution "Example"
+ @ManageTransactions("PrimOp")
def MakeRevolution2Ways(self, theBase, theAxis, theAngle, theName=None):
"""
Create a shape by revolution of the base shape around the axis
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created revolution.
"""
theAngle,Parameters = ParseParameters(theAngle)
self._autoPublish(anObj, theName, "revolution")
return anObj
- ## Create a filling from the given compound of contours.
- # @param theShape the compound of contours
- # @param theMinDeg a minimal degree of BSpline surface to create
- # @param theMaxDeg a maximal degree of BSpline surface to create
- # @param theTol2D a 2d tolerance to be reached
- # @param theTol3D a 3d tolerance to be reached
- # @param theNbIter a number of iteration of approximation algorithm
- # @param theMethod Kind of method to perform filling operation(see GEOM::filling_oper_method())
+ ## Create a face from a given set of contours.
+ # @param theContours either a list or a compound of edges/wires.
+ # @param theMinDeg a minimal degree of BSpline surface to create.
+ # @param theMaxDeg a maximal degree of BSpline surface to create.
+ # @param theTol2D a 2d tolerance to be reached.
+ # @param theTol3D a 3d tolerance to be reached.
+ # @param theNbIter a number of iteration of approximation algorithm.
+ # @param theMethod Kind of method to perform filling operation
+ # (see GEOM.filling_oper_method enum).
# @param isApprox if True, BSpline curves are generated in the process
# of surface construction. By default it is False, that means
# the surface is created using given curves. The usage of
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created filling surface.
+ # @return New GEOM.GEOM_Object (face), containing the created filling surface.
#
# @ref tui_creation_filling "Example"
- def MakeFilling(self, theShape, theMinDeg=2, theMaxDeg=5, theTol2D=0.0001,
+ @ManageTransactions("PrimOp")
+ def MakeFilling(self, theContours, theMinDeg=2, theMaxDeg=5, theTol2D=0.0001,
theTol3D=0.0001, theNbIter=0, theMethod=GEOM.FOM_Default, isApprox=0, theName=None):
"""
- Create a filling from the given compound of contours.
+ Create a face from a given set of contours.
Parameters:
- theShape the compound of contours
- theMinDeg a minimal degree of BSpline surface to create
- theMaxDeg a maximal degree of BSpline surface to create
- theTol2D a 2d tolerance to be reached
- theTol3D a 3d tolerance to be reached
- theNbIter a number of iteration of approximation algorithm
- theMethod Kind of method to perform filling operation(see GEOM::filling_oper_method())
+ theContours either a list or a compound of edges/wires.
+ theMinDeg a minimal degree of BSpline surface to create.
+ theMaxDeg a maximal degree of BSpline surface to create.
+ theTol2D a 2d tolerance to be reached.
+ theTol3D a 3d tolerance to be reached.
+ theNbIter a number of iteration of approximation algorithm.
+ theMethod Kind of method to perform filling operation
+ (see GEOM.filling_oper_method enum).
isApprox if True, BSpline curves are generated in the process
of surface construction. By default it is False, that means
the surface is created using given curves. The usage of
Approximation makes the algorithm work slower, but allows
- building the surface for rather complex cases
+ building the surface for rather complex cases.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created filling surface.
+ Returns:
+ New GEOM.GEOM_Object (face), containing the created filling surface.
Example of usage:
filling = geompy.MakeFilling(compound, 2, 5, 0.0001, 0.0001, 5)
"""
# Example: see GEOM_TestAll.py
theMinDeg,theMaxDeg,theTol2D,theTol3D,theNbIter,Parameters = ParseParameters(theMinDeg, theMaxDeg, theTol2D, theTol3D, theNbIter)
- anObj = self.PrimOp.MakeFilling(theShape, theMinDeg, theMaxDeg,
+ anObj = self.PrimOp.MakeFilling(ToList(theContours), theMinDeg, theMaxDeg,
theTol2D, theTol3D, theNbIter,
theMethod, isApprox)
RaiseIfFailed("MakeFilling", self.PrimOp)
return anObj
- ## Create a filling from the given compound of contours.
- # This method corresponds to MakeFilling with isApprox=True
- # @param theShape the compound of contours
- # @param theMinDeg a minimal degree of BSpline surface to create
- # @param theMaxDeg a maximal degree of BSpline surface to create
- # @param theTol3D a 3d tolerance to be reached
+ ## Create a face from a given set of contours.
+ # This method corresponds to MakeFilling() with isApprox=True.
+ # @param theContours either a list or a compound of edges/wires.
+ # @param theMinDeg a minimal degree of BSpline surface to create.
+ # @param theMaxDeg a maximal degree of BSpline surface to create.
+ # @param theTol3D a 3d tolerance to be reached.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created filling surface.
+ # @return New GEOM.GEOM_Object (face), containing the created filling surface.
#
# @ref tui_creation_filling "Example"
- def MakeFillingNew(self, theShape, theMinDeg=2, theMaxDeg=5, theTol3D=0.0001, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakeFillingNew(self, theContours, theMinDeg=2, theMaxDeg=5, theTol3D=0.0001, theName=None):
"""
Create a filling from the given compound of contours.
- This method corresponds to MakeFilling with isApprox=True
+ This method corresponds to MakeFilling() with isApprox=True.
Parameters:
- theShape the compound of contours
- theMinDeg a minimal degree of BSpline surface to create
- theMaxDeg a maximal degree of BSpline surface to create
- theTol3D a 3d tolerance to be reached
+ theContours either a list or a compound of edges/wires.
+ theMinDeg a minimal degree of BSpline surface to create.
+ theMaxDeg a maximal degree of BSpline surface to create.
+ theTol3D a 3d tolerance to be reached.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created filling surface.
+ Returns:
+ New GEOM.GEOM_Object (face), containing the created filling surface.
Example of usage:
filling = geompy.MakeFillingNew(compound, 2, 5, 0.0001)
"""
# Example: see GEOM_TestAll.py
theMinDeg,theMaxDeg,theTol3D,Parameters = ParseParameters(theMinDeg, theMaxDeg, theTol3D)
- anObj = self.PrimOp.MakeFilling(theShape, theMinDeg, theMaxDeg,
+ anObj = self.PrimOp.MakeFilling(ToList(theContours), theMinDeg, theMaxDeg,
0, theTol3D, 0, GEOM.FOM_Default, True)
RaiseIfFailed("MakeFillingNew", self.PrimOp)
anObj.SetParameters(Parameters)
# @return New GEOM.GEOM_Object, containing the created shell or solid.
#
# @ref swig_todo "Example"
+ @ManageTransactions("PrimOp")
def MakeThruSections(self, theSeqSections, theModeSolid, thePreci, theRuled, theName=None):
"""
Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
return anObj
## Create a shape by extrusion of the base shape along
- # the path shape. The path shape can be a wire or an edge.
+ # the path shape. The path shape can be a wire or an edge. It is
+ # possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups.<BR>
+ # If \a thePath is a closed edge or wire and \a IsGenerateGroups is
+ # set, an error is occurred. If \a thePath is not closed edge/wire,
+ # the following groups are returned:
+ # - If \a theBase is unclosed edge or wire: "Down", "Up", "Side1",
+ # "Side2";
+ # - If \a theBase is closed edge or wire, face or shell: "Down", "Up",
+ # "Other".
+ # .
+ # "Down" and "Up" groups contain:
+ # - Edges if \a theBase is edge or wire;
+ # - Faces if \a theBase is face or shell.<BR>
+ # .
+ # "Side1" and "Side2" groups contain edges generated from the first
+ # and last vertices of \a theBase. The first and last vertices are
+ # determined taking into account edge/wire orientation.<BR>
+ # "Other" group represents faces generated from the bounding edges of
+ # \a theBase.
+ #
# @param theBase Base shape to be extruded.
# @param thePath Path shape to extrude the base shape along it.
+ # @param IsGenerateGroups flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns a
+ # list of GEOM.GEOM_Object. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe "Example"
- def MakePipe(self, theBase, thePath, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakePipe(self, theBase, thePath,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the base shape along
- the path shape. The path shape can be a wire or an edge.
+ the path shape. The path shape can be a wire or an edge. It is
+ possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups.
+ If thePath is a closed edge or wire and IsGenerateGroups is
+ set, an error is occurred. If thePath is not closed edge/wire,
+ the following groups are returned:
+ - If theBase is unclosed edge or wire: "Down", "Up", "Side1",
+ "Side2";
+ - If theBase is closed edge or wire, face or shell: "Down", "Up",
+ "Other".
+ "Down" and "Up" groups contain:
+ - Edges if theBase is edge or wire;
+ - Faces if theBase is face or shell.
+ "Side1" and "Side2" groups contain edges generated from the first
+ and last vertices of theBase. The first and last vertices are
+ determined taking into account edge/wire orientation.
+ "Other" group represents faces generated from the bounding edges of
+ theBase.
Parameters:
theBase Base shape to be extruded.
thePath Path shape to extrude the base shape along it.
+ IsGenerateGroups flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns a
+ list of GEOM.GEOM_Object. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakePipe(theBase, thePath)
+ aList = self.PrimOp.MakePipe(theBase, thePath, IsGenerateGroups)
RaiseIfFailed("MakePipe", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
# the path shape. The path shape can be a wire or an edge.
# the several profiles can be specified in the several locations of path.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of Bases shape to be extruded.
# @param theLocations - list of locations on the path corresponding
# specified list of the Bases shapes. Number of locations
# contact with the spine.
# @param theWithCorrection - defining that the section is rotated to be
# orthogonal to the spine tangent in the correspondent point
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_with_diff_sec "Example"
+ @ManageTransactions("PrimOp")
def MakePipeWithDifferentSections(self, theSeqBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
the path shape. The path shape can be a wire or an edge.
the several profiles can be specified in the several locations of path.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of Bases shape to be extruded.
contact with the spine(0/1)
theWithCorrection - defining that the section is rotated to be
orthogonal to the spine tangent in the correspondent point (0/1)
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
+ aList = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
theLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ False, IsGenerateGroups)
RaiseIfFailed("MakePipeWithDifferentSections", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
+
+ ## Create a shape by extrusion of the profile shape along
+ # the path shape. This function is a version of
+ # MakePipeWithDifferentSections() with the same parameters, except
+ # eliminated theWithContact and theWithCorrection. So it is
+ # possible to find the description of all parameters is in this
+ # method. The difference is that this method performs the operation
+ # step by step, i.e. it creates pipes between each pair of neighbor
+ # sections and fuses them into a single shape.
+ #
+ # @ref tui_creation_pipe_with_diff_sec "Example"
+ @ManageTransactions("PrimOp")
+ def MakePipeWithDifferentSectionsBySteps(self, theSeqBases,
+ theLocations, thePath,
+ IsGenerateGroups=False, theName=None):
+ """
+ Create a shape by extrusion of the profile shape along
+ the path shape. This function is a version of
+ MakePipeWithDifferentSections() with the same parameters, except
+ eliminated theWithContact and theWithCorrection. So it is
+ possible to find the description of all parameters is in this
+ method. The difference is that this method performs the operation
+ step by step, i.e. it creates pipes between each pair of neighbor
+ sections and fuses them into a single shape.
+ """
+ aList = self.PrimOp.MakePipeWithDifferentSections(theSeqBases,
+ theLocations, thePath,
+ False, False,
+ True, IsGenerateGroups)
+ RaiseIfFailed("MakePipeWithDifferentSectionsBySteps", self.PrimOp)
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
- # the path shape. The path shape can be a wire or a edge.
+ # the path shape. The path shape can be a wire or an edge.
# the several profiles can be specified in the several locations of path.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of Bases shape to be extruded. Base shape must be
# shell or face. If number of faces in neighbour sections
# aren't coincided result solid between such sections will
# contact with the spine.
# @param theWithCorrection - defining that the section is rotated to be
# orthogonal to the spine tangent in the correspondent point
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created solids.
+ # @return New GEOM.GEOM_Object, containing the created solids if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created solids, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_with_shell_sec "Example"
+ @ManageTransactions("PrimOp")
def MakePipeWithShellSections(self, theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
- the path shape. The path shape can be a wire or a edge.
+ the path shape. The path shape can be a wire or an edge.
the several profiles can be specified in the several locations of path.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of Bases shape to be extruded. Base shape must be
contact with the spine (0/1)
theWithCorrection - defining that the section is rotated to be
orthogonal to the spine tangent in the correspondent point (0/1)
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created solids.
+ Returns:
+ New GEOM.GEOM_Object, containing the created solids if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created solids, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
+ aList = self.PrimOp.MakePipeWithShellSections(theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ IsGenerateGroups)
RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the profile shape along
# the path shape. This function is used only for debug pipe
# functionality - it is a version of function MakePipeWithShellSections()
- # which give a possibility to recieve information about
+ # which give a possibility to receive information about
# creating pipe between each pair of sections step by step.
+ @ManageTransactions("PrimOp")
def MakePipeWithShellSectionsBySteps(self, theSeqBases, theSeqSubBases,
theLocations, thePath,
- theWithContact, theWithCorrection, theName=None):
+ theWithContact, theWithCorrection,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the profile shape along
the path shape. This function is used only for debug pipe
functionality - it is a version of previous function
geompy.MakePipeWithShellSections() which give a possibility to
- recieve information about creating pipe between each pair of
+ receive information about creating pipe between each pair of
sections step by step.
"""
res = []
tmpLocations = [ theLocations[i-1], theLocations[i] ]
tmpSeqSubBases = []
if nbsubsect>0: tmpSeqSubBases = [ theSeqSubBases[i-1], theSeqSubBases[i] ]
- anObj = self.PrimOp.MakePipeWithShellSections(tmpSeqBases, tmpSeqSubBases,
+ aList = self.PrimOp.MakePipeWithShellSections(tmpSeqBases, tmpSeqSubBases,
tmpLocations, thePath,
- theWithContact, theWithCorrection)
+ theWithContact, theWithCorrection,
+ IsGenerateGroups)
if self.PrimOp.IsDone() == 0:
print "Problems with pipe creation between ",i," and ",i+1," sections"
RaiseIfFailed("MakePipeWithShellSections", self.PrimOp)
break
else:
print "Pipe between ",i," and ",i+1," sections is OK"
- res.append(anObj)
+ res.append(aList[0])
pass
pass
self._autoPublish(resc, theName, "pipe")
return resc
- ## Create solids between given sections
+ ## Create solids between given sections.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theSeqBases - list of sections (shell or face).
# @param theLocations - list of corresponding vertexes
+ # @param IsGenerateGroups - flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created solids.
+ # @return New GEOM.GEOM_Object, containing the created solids if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created solids, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe_without_path "Example"
- def MakePipeShellsWithoutPath(self, theSeqBases, theLocations, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakePipeShellsWithoutPath(self, theSeqBases, theLocations,
+ IsGenerateGroups=False, theName=None):
"""
- Create solids between given sections
+ Create solids between given sections.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theSeqBases - list of sections (shell or face).
theLocations - list of corresponding vertexes
+ IsGenerateGroups - flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created solids.
+ New GEOM.GEOM_Object, containing the created solids if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created solids, the
+ remaining ones are created groups.
"""
- anObj = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations)
+ aList = self.PrimOp.MakePipeShellsWithoutPath(theSeqBases, theLocations,
+ IsGenerateGroups)
RaiseIfFailed("MakePipeShellsWithoutPath", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
## Create a shape by extrusion of the base shape along
# the path shape with constant bi-normal direction along the given vector.
# The path shape can be a wire or an edge.
+ # It is possible to generate groups along with the result by means of
+ # setting the flag \a IsGenerateGroups. For detailed information on
+ # groups that can be created please see the method MakePipe().
# @param theBase Base shape to be extruded.
# @param thePath Path shape to extrude the base shape along it.
# @param theVec Vector defines a constant binormal direction to keep the
# same angle beetween the direction and the sections
# along the sweep surface.
+ # @param IsGenerateGroups flag that tells if it is necessary to
+ # create groups. It is equal to False by default.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created pipe.
+ # @return New GEOM.GEOM_Object, containing the created pipe if
+ # \a IsGenerateGroups is not set. Otherwise it returns new
+ # GEOM.ListOfGO. Its first element is the created pipe, the
+ # remaining ones are created groups.
#
# @ref tui_creation_pipe "Example"
- def MakePipeBiNormalAlongVector(self, theBase, thePath, theVec, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakePipeBiNormalAlongVector(self, theBase, thePath, theVec,
+ IsGenerateGroups=False, theName=None):
"""
Create a shape by extrusion of the base shape along
the path shape with constant bi-normal direction along the given vector.
The path shape can be a wire or an edge.
+ It is possible to generate groups along with the result by means of
+ setting the flag IsGenerateGroups. For detailed information on
+ groups that can be created please see the method geompy.MakePipe().
Parameters:
theBase Base shape to be extruded.
theVec Vector defines a constant binormal direction to keep the
same angle beetween the direction and the sections
along the sweep surface.
+ IsGenerateGroups flag that tells if it is necessary to
+ create groups. It is equal to False by default.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created pipe.
+ Returns:
+ New GEOM.GEOM_Object, containing the created pipe if
+ IsGenerateGroups is not set. Otherwise it returns new
+ GEOM.ListOfGO. Its first element is the created pipe, the
+ remaining ones are created groups.
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath, theVec)
+ aList = self.PrimOp.MakePipeBiNormalAlongVector(theBase, thePath,
+ theVec, IsGenerateGroups)
RaiseIfFailed("MakePipeBiNormalAlongVector", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
- return anObj
-
- ## Makes a thick solid from a face or a shell
- # @param theShape Face or Shell to be thicken
+
+ if IsGenerateGroups:
+ self._autoPublish(aList, theName, "pipe")
+ return aList
+
+ self._autoPublish(aList[0], theName, "pipe")
+ return aList[0]
+
+ ## Makes a thick solid from a shape. If the input is a surface shape
+ # (face or shell) the result is a thick solid. If an input shape is
+ # a solid the result is a hollowed solid with removed faces.
+ # @param theShape Face or Shell to get thick solid or solid to get
+ # hollowed solid.
# @param theThickness Thickness of the resulting solid
+ # @param theFacesIDs the list of face IDs to be removed from the
+ # result. It is ignored if \a theShape is a face or a shell.
+ # It is empty by default.
+ # @param theInside If true the thickness is applied towards inside
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
# @return New GEOM.GEOM_Object, containing the created solid
#
- def MakeThickSolid(self, theShape, theThickness, theName=None):
+ # @ref tui_creation_thickness "Example"
+ @ManageTransactions("PrimOp")
+ def MakeThickSolid(self, theShape, theThickness,
+ theFacesIDs=[], theInside=False, theName=None):
"""
- Make a thick solid from a face or a shell
+ Make a thick solid from a shape. If the input is a surface shape
+ (face or shell) the result is a thick solid. If an input shape is
+ a solid the result is a hollowed solid with removed faces.
Parameters:
- theShape Face or Shell to be thicken
+ theShape Face or Shell to get thick solid or solid to get
+ hollowed solid.
theThickness Thickness of the resulting solid
+ theFacesIDs the list of face IDs to be removed from the
+ result. It is ignored if theShape is a face or a
+ shell. It is empty by default.
+ theInside If true the thickness is applied towards inside
theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
Returns:
New GEOM.GEOM_Object, containing the created solid
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakeThickening(theShape, theThickness, True)
- RaiseIfFailed("MakeThickening", self.PrimOp)
- self._autoPublish(anObj, theName, "pipe")
+ theThickness,Parameters = ParseParameters(theThickness)
+ anObj = self.PrimOp.MakeThickening(theShape, theFacesIDs,
+ theThickness, True, theInside)
+ RaiseIfFailed("MakeThickSolid", self.PrimOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "thickSolid")
return anObj
-
- ## Modifies a face or a shell to make it a thick solid
- # @param theShape Face or Shell to be thicken
+
+ ## Modifies a shape to make it a thick solid. If the input is a surface
+ # shape (face or shell) the result is a thick solid. If an input shape
+ # is a solid the result is a hollowed solid with removed faces.
+ # @param theShape Face or Shell to get thick solid or solid to get
+ # hollowed solid.
# @param theThickness Thickness of the resulting solid
+ # @param theFacesIDs the list of face IDs to be removed from the
+ # result. It is ignored if \a theShape is a face or a shell.
+ # It is empty by default.
+ # @param theInside If true the thickness is applied towards inside
#
# @return The modified shape
#
- def Thicken(self, theShape, theThickness):
+ # @ref tui_creation_thickness "Example"
+ @ManageTransactions("PrimOp")
+ def Thicken(self, theShape, theThickness, theFacesIDs=[], theInside=False):
"""
- Modifies a face or a shell to make it a thick solid
+ Modifies a shape to make it a thick solid. If the input is a
+ surface shape (face or shell) the result is a thick solid. If
+ an input shape is a solid the result is a hollowed solid with
+ removed faces.
Parameters:
- theBase Base shape to be extruded.
- thePath Path shape to extrude the base shape along it.
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
+ theShape Face or Shell to get thick solid or solid to get
+ hollowed solid.
+ theThickness Thickness of the resulting solid
+ theFacesIDs the list of face IDs to be removed from the
+ result. It is ignored if \a theShape is a face or
+ a shell. It is empty by default.
+ theInside If true the thickness is applied towards inside
Returns:
The modified shape
"""
# Example: see GEOM_TestAll.py
- anObj = self.PrimOp.MakeThickening(theShape, theThickness, False)
- RaiseIfFailed("MakeThickening", self.PrimOp)
+ theThickness,Parameters = ParseParameters(theThickness)
+ anObj = self.PrimOp.MakeThickening(theShape, theFacesIDs,
+ theThickness, False, theInside)
+ RaiseIfFailed("Thicken", self.PrimOp)
+ anObj.SetParameters(Parameters)
return anObj
## Build a middle path of a pipe-like shape.
# source pipe's "path".
#
# @ref tui_creation_pipe_path "Example"
+ @ManageTransactions("PrimOp")
def RestorePath (self, theShape, theBase1, theBase2, theName=None):
"""
Build a middle path of a pipe-like shape.
# source pipe's "path".
#
# @ref tui_creation_pipe_path "Example"
+ @ManageTransactions("PrimOp")
def RestorePathEdges (self, theShape, listEdges1, listEdges2, theName=None):
"""
Build a middle path of a pipe-like shape.
# end of l3_complex
## @}
- ## @addtogroup l3_advanced
+ ## @addtogroup l3_basic_go
## @{
## Create a linear edge with specified ends.
# @return New GEOM.GEOM_Object, containing the created edge.
#
# @ref tui_creation_edge "Example"
+ @ManageTransactions("ShapesOp")
def MakeEdge(self, thePnt1, thePnt2, theName=None):
"""
Create a linear edge with specified ends.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created edge.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created edge.
#
# @ref tui_creation_edge "Example"
+ @ManageTransactions("ShapesOp")
def MakeEdgeOnCurveByLength(self, theRefCurve, theLength, theStartPoint = None, theName=None):
"""
Create a new edge, corresponding to the given length on the given curve.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created edge.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the created edge.
#
# @ref tui_creation_edge "Example"
+ @ManageTransactions("ShapesOp")
def MakeEdgeWire(self, theWire, theLinearTolerance = 1e-07, theAngularTolerance = 1e-12, theName=None):
"""
Create an edge from specified wire.
# @return New GEOM.GEOM_Object, containing the created wire.
#
# @ref tui_creation_wire "Example"
+ @ManageTransactions("ShapesOp")
def MakeWire(self, theEdgesAndWires, theTolerance = 1e-07, theName=None):
"""
Create a wire from the set of edges and wires.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created wire.
"""
# Example: see GEOM_TestAll.py
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created face.
+ # @return New GEOM.GEOM_Object, containing the created face (compound of faces).
#
# @ref tui_creation_face "Example"
+ @ManageTransactions("ShapesOp")
def MakeFace(self, theWire, isPlanarWanted, theName=None):
"""
Create a face on the given wire.
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created face.
+ New GEOM.GEOM_Object, containing the created face (compound of faces).
"""
# Example: see GEOM_TestAll.py
anObj = self.ShapesOp.MakeFace(theWire, isPlanarWanted)
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created face.
+ # @return New GEOM.GEOM_Object, containing the created face (compound of faces).
#
# @ref tui_creation_face "Example"
+ @ManageTransactions("ShapesOp")
def MakeFaceWires(self, theWires, isPlanarWanted, theName=None):
"""
Create a face on the given wires set.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing the created face.
+ Returns:
+ New GEOM.GEOM_Object, containing the created face (compound of faces).
"""
# Example: see GEOM_TestAll.py
- anObj = self.ShapesOp.MakeFaceWires(theWires, isPlanarWanted)
+ anObj = self.ShapesOp.MakeFaceWires(ToList(theWires), isPlanarWanted)
if isPlanarWanted and anObj is not None and self.ShapesOp.GetErrorCode() == "MAKE_FACE_TOLERANCE_TOO_BIG":
print "WARNING: Cannot build a planar face: required tolerance is too big. Non-planar face is built."
else:
anObj = self.MakeFaceWires(theWires, isPlanarWanted, theName)
return anObj
- ## Create a shell from the set of faces and shells.
- # @param theFacesAndShells List of faces and/or shells.
+ ## Create a face based on a surface from given face bounded
+ # by given wire.
+ # @param theFace the face whose surface is used to create a new face.
+ # @param theWire the wire that will bound a new face.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created shell.
+ # @return New GEOM.GEOM_Object, containing the created face.
#
- # @ref tui_creation_shell "Example"
- def MakeShell(self, theFacesAndShells, theName=None):
+ # @ref tui_creation_face "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeFaceFromSurface(self, theFace, theWire, theName=None):
"""
- Create a shell from the set of faces and shells.
+ Create a face based on a surface from given face bounded
+ by given wire.
Parameters:
- theFacesAndShells List of faces and/or shells.
+ theFace the face whose surface is used to create a new face.
+ theWire the wire that will bound a new face.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created shell.
+ New GEOM.GEOM_Object, containing the created face.
"""
# Example: see GEOM_TestAll.py
- anObj = self.ShapesOp.MakeShell(theFacesAndShells)
- RaiseIfFailed("MakeShell", self.ShapesOp)
- self._autoPublish(anObj, theName, "shell")
+ anObj = self.ShapesOp.MakeFaceFromSurface(theFace, theWire)
+ RaiseIfFailed("MakeFaceFromSurface", self.ShapesOp)
+ self._autoPublish(anObj, theName, "face")
return anObj
-
- ## Create a solid, bounded by the given shells.
- # @param theShells Sequence of bounding shells.
+
+ ## Create a face from a set of edges with the given constraints.
+ # @param theConstraints List of edges and constraint faces (as a sequence of a Edge + Face couples):
+ # - edges should form a closed wire;
+ # - for each edge, constraint face is optional: if a constraint face is missing
+ # for some edge, this means that there no constraint associated with this edge.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
- #
- # @return New GEOM.GEOM_Object, containing the created solid.
- #
- # @ref tui_creation_solid "Example"
- def MakeSolid(self, theShells, theName=None):
+ #
+ # @return New GEOM.GEOM_Object, containing the created face.
+ #
+ # @ref tui_creation_face "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeFaceWithConstraints(self, theConstraints, theName=None):
"""
- Create a solid, bounded by the given shells.
+ Create a face from a set of edges with the given constraints.
Parameters:
- theShells Sequence of bounding shells.
+ theConstraints List of edges and constraint faces (as a sequence of a Edge + Face couples):
+ - edges should form a closed wire;
+ - for each edge, constraint face is optional: if a constraint face is missing
+ for some edge, this means that there no constraint associated with this edge.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing the created solid.
+ New GEOM.GEOM_Object, containing the created face.
"""
# Example: see GEOM_TestAll.py
- if len(theShells) == 1:
- descr = self.MeasuOp.IsGoodForSolid(theShells[0])
- #if len(descr) > 0:
- # raise RuntimeError, "MakeSolidShells : " + descr
- if descr == "WRN_SHAPE_UNCLOSED":
- raise RuntimeError, "MakeSolidShells : Unable to create solid from unclosed shape"
- anObj = self.ShapesOp.MakeSolidShells(theShells)
- RaiseIfFailed("MakeSolidShells", self.ShapesOp)
- self._autoPublish(anObj, theName, "solid")
+ anObj = self.ShapesOp.MakeFaceWithConstraints(theConstraints)
+ if anObj is None:
+ RaiseIfFailed("MakeFaceWithConstraints", self.ShapesOp)
+ self._autoPublish(anObj, theName, "face")
return anObj
- ## Create a compound of the given shapes.
- # @param theShapes List of shapes to put in compound.
+ ## Create a shell from the set of faces, shells and/or compounds of faces.
+ # @param theFacesAndShells List of faces, shells and/or compounds of faces.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the created compound.
+ # @return New GEOM.GEOM_Object, containing the created shell (compound of shells).
#
- # @ref tui_creation_compound "Example"
+ # @ref tui_creation_shell "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeShell(self, theFacesAndShells, theName=None):
+ """
+ Create a shell from the set of faces and shells.
+
+ Parameters:
+ theFacesAndShells List of faces and/or shells.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created shell (compound of shells).
+ """
+ # Example: see GEOM_TestAll.py
+ anObj = self.ShapesOp.MakeShell( ToList( theFacesAndShells ))
+ RaiseIfFailed("MakeShell", self.ShapesOp)
+ self._autoPublish(anObj, theName, "shell")
+ return anObj
+
+ ## Create a solid, bounded by the given shells.
+ # @param theShells Sequence of bounding shells.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the created solid.
+ #
+ # @ref tui_creation_solid "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeSolid(self, theShells, theName=None):
+ """
+ Create a solid, bounded by the given shells.
+
+ Parameters:
+ theShells Sequence of bounding shells.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created solid.
+ """
+ # Example: see GEOM_TestAll.py
+ theShells = ToList(theShells)
+ if len(theShells) == 1:
+ descr = self._IsGoodForSolid(theShells[0])
+ #if len(descr) > 0:
+ # raise RuntimeError, "MakeSolidShells : " + descr
+ if descr == "WRN_SHAPE_UNCLOSED":
+ raise RuntimeError, "MakeSolidShells : Unable to create solid from unclosed shape"
+ anObj = self.ShapesOp.MakeSolidShells(theShells)
+ RaiseIfFailed("MakeSolidShells", self.ShapesOp)
+ self._autoPublish(anObj, theName, "solid")
+ return anObj
+
+ ## Create a compound of the given shapes.
+ # @param theShapes List of shapes to put in compound.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the created compound.
+ #
+ # @ref tui_creation_compound "Example"
+ @ManageTransactions("ShapesOp")
def MakeCompound(self, theShapes, theName=None):
"""
Create a compound of the given shapes.
New GEOM.GEOM_Object, containing the created compound.
"""
# Example: see GEOM_TestAll.py
- self.ShapesOp.StartOperation()
- anObj = self.ShapesOp.MakeCompound(theShapes)
+ anObj = self.ShapesOp.MakeCompound(ToList(theShapes))
RaiseIfFailed("MakeCompound", self.ShapesOp)
self._autoPublish(anObj, theName, "compound")
return anObj
+
+ ## Create a solid (or solids) from the set of faces and/or shells.
+ # @param theFacesOrShells List of faces and/or shells.
+ # @param isIntersect If TRUE, forces performing intersections
+ # between arguments; otherwise (default) intersection is not performed.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the created solid (or compound of solids).
+ #
+ # @ref tui_creation_solid_from_faces "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeSolidFromConnectedFaces(self, theFacesOrShells, isIntersect = False, theName=None):
+ """
+ Create a solid (or solids) from the set of connected faces and/or shells.
+
+ Parameters:
+ theFacesOrShells List of faces and/or shells.
+ isIntersect If TRUE, forces performing intersections
+ between arguments; otherwise (default) intersection is not performed
+ theName Object name; when specified, this parameter is used.
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created solid (or compound of solids).
+ """
+ # Example: see GEOM_TestAll.py
+ anObj = self.ShapesOp.MakeSolidFromConnectedFaces(theFacesOrShells, isIntersect)
+ RaiseIfFailed("MakeSolidFromConnectedFaces", self.ShapesOp)
+ self._autoPublish(anObj, theName, "solid")
+ return anObj
- # end of l3_advanced
+ # end of l3_basic_go
## @}
## @addtogroup l2_measure
# @return Quantity of faces.
#
# @ref swig_NumberOf "Example"
+ @ManageTransactions("ShapesOp")
def NumberOfFaces(self, theShape):
"""
Gives quantity of faces in the given shape.
Parameters:
theShape Shape to count faces of.
- Returns:
+ Returns:
Quantity of faces.
"""
# Example: see GEOM_TestOthers.py
# @return Quantity of edges.
#
# @ref swig_NumberOf "Example"
+ @ManageTransactions("ShapesOp")
def NumberOfEdges(self, theShape):
"""
Gives quantity of edges in the given shape.
Parameters:
theShape Shape to count edges of.
- Returns:
+ Returns:
Quantity of edges.
"""
# Example: see GEOM_TestOthers.py
# @return Quantity of sub-shapes of given type.
#
# @ref swig_NumberOf "Example"
+ @ManageTransactions("ShapesOp")
def NumberOfSubShapes(self, theShape, theShapeType):
"""
Gives quantity of sub-shapes of type theShapeType in the given shape.
# @return Quantity of solids.
#
# @ref swig_NumberOf "Example"
+ @ManageTransactions("ShapesOp")
def NumberOfSolids(self, theShape):
"""
Gives quantity of solids in the given shape.
# @return The reversed copy of theShape.
#
# @ref swig_ChangeOrientation "Example"
+ @ManageTransactions("ShapesOp")
def ChangeOrientation(self, theShape, theName=None):
"""
Reverses an orientation the given shape.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
The reversed copy of theShape.
"""
# Example: see GEOM_TestAll.py
# @param theShape Shape to find free faces in.
# @return List of IDs of all free faces, contained in theShape.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_free_faces_page "Example"
+ @ManageTransactions("ShapesOp")
def GetFreeFacesIDs(self,theShape):
"""
Retrieve all free faces from the given shape.
# @return List of sub-shapes of theShape1, shared with theShape2.
#
# @ref swig_GetSharedShapes "Example"
+ @ManageTransactions("ShapesOp")
def GetSharedShapes(self, theShape1, theShape2, theShapeType, theName=None):
"""
Get all sub-shapes of theShape1 of the given type, shared with theShape2.
self._autoPublish(aList, theName, "shared")
return aList
- ## Get all sub-shapes, shared by all shapes in the list <VAR>theShapes</VAR>.
- # @param theShapes Shapes to find common sub-shapes of.
- # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
+ ## Get sub-shapes, shared by input shapes.
+ # @param theShapes Either a list or compound of shapes to find common sub-shapes of.
+ # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType()).
+ # @param theMultiShare Specifies what type of shares should be checked:
+ # - @c True (default): search sub-shapes from 1st input shape shared with all other input shapes;
+ # - @c False: causes to search sub-shapes shared between couples of input shapes.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return List of objects, that are sub-shapes of all given shapes.
+ # @note If @a theShapes contains single compound, the shares between all possible couples of
+ # its top-level shapes are returned; otherwise, only shares between 1st input shape
+ # and all rest input shapes are returned.
#
- # @ref swig_GetSharedShapes "Example"
- def GetSharedShapesMulti(self, theShapes, theShapeType, theName=None):
+ # @return List of all found sub-shapes.
+ #
+ # Examples:
+ # - @ref tui_shared_shapes "Example 1"
+ # - @ref swig_GetSharedShapes "Example 2"
+ @ManageTransactions("ShapesOp")
+ def GetSharedShapesMulti(self, theShapes, theShapeType, theMultiShare=True, theName=None):
"""
- Get all sub-shapes, shared by all shapes in the list theShapes.
+ Get sub-shapes, shared by input shapes.
Parameters:
- theShapes Shapes to find common sub-shapes of.
- theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType)
+ theShapes Either a list or compound of shapes to find common sub-shapes of.
+ theShapeType Type of sub-shapes to be retrieved (see geompy.ShapeType).
+ theMultiShare Specifies what type of shares should be checked:
+ - True (default): search sub-shapes from 1st input shape shared with all other input shapes;
+ - False: causes to search sub-shapes shared between couples of input shapes.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- List of GEOM.GEOM_Object, that are sub-shapes of all given shapes.
+ Note: if theShapes contains single compound, the shares between all possible couples of
+ its top-level shapes are returned; otherwise, only shares between 1st input shape
+ and all rest input shapes are returned.
+
+ Returns:
+ List of all found sub-shapes.
"""
# Example: see GEOM_TestOthers.py
- aList = self.ShapesOp.GetSharedShapesMulti(theShapes, theShapeType)
+ aList = self.ShapesOp.GetSharedShapesMulti(ToList(theShapes), theShapeType, theMultiShare)
RaiseIfFailed("GetSharedShapesMulti", self.ShapesOp)
self._autoPublish(aList, theName, "shared")
return aList
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnPlane "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnPlane(self, theShape, theShapeType, theAx1, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnPlaneIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnPlaneIDs(self, theShape, theShapeType, theAx1, theState):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnPlaneWithLocation "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnPlaneWithLocation(self, theShape, theShapeType, theAx1, thePnt, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnPlaneWithLocationIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnPlaneWithLocationIDs(self, theShape, theShapeType, theAx1, thePnt, theState):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnCylinder "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnCylinder(self, theShape, theShapeType, theAxis, theRadius, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnCylinderIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnCylinderIDs(self, theShape, theShapeType, theAxis, theRadius, theState):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnCylinderWithLocation "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnCylinderWithLocation(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes indices
#
# @ref swig_GetShapesOnCylinderWithLocationIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnCylinderWithLocationIDs(self, theShape, theShapeType, theAxis, thePnt, theRadius, theState):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
theState The state of the sub-shapes to find (see GEOM::shape_state)
Returns:
- List of all found sub-shapes indices.
+ List of all found sub-shapes indices.
"""
# Example: see GEOM_TestOthers.py
aList = self.ShapesOp.GetShapesOnCylinderWithLocationIDs(theShape, theShapeType, theAxis, thePnt, theRadius, theState)
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnSphere "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnSphere(self, theShape, theShapeType, theCenter, theRadius, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnSphereIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnSphereIDs(self, theShape, theShapeType, theCenter, theRadius, theState):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnQuadrangle "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnQuadrangle(self, theShape, theShapeType,
theTopLeftPoint, theTopRigthPoint,
theBottomLeftPoint, theBottomRigthPoint, theState, theName=None):
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnQuadrangleIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnQuadrangleIDs(self, theShape, theShapeType,
theTopLeftPoint, theTopRigthPoint,
theBottomLeftPoint, theBottomRigthPoint, theState):
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnBox "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnBox(self, theBox, theShape, theShapeType, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnBoxIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnBoxIDs(self, theBox, theShape, theShapeType, theState):
"""
Find in theShape all sub-shapes of type theShapeType, situated relatively
# certain way, defined through \a theState parameter.
# @param theCheckShape Shape for relative comparing. It must be a solid.
# @param theShape Shape to find sub-shapes of.
- # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
+ # @param theShapeType Type of sub-shapes to be retrieved (see ShapeType())
# @param theState The state of the sub-shapes to find (see GEOM::shape_state)
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# @return List of all found sub-shapes.
#
# @ref swig_GetShapesOnShape "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnShape(self, theCheckShape, theShape, theShapeType, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return All found sub-shapes as compound.
#
# @ref swig_GetShapesOnShapeAsCompound "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnShapeAsCompound(self, theCheckShape, theShape, theShapeType, theState, theName=None):
"""
Find in theShape all sub-shapes of type theShapeType,
# @return List of all found sub-shapes indices.
#
# @ref swig_GetShapesOnShapeIDs "Example"
+ @ManageTransactions("ShapesOp")
def GetShapesOnShapeIDs(self, theCheckShape, theShape, theShapeType, theState):
"""
Find in theShape all sub-shapes of type theShapeType,
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return Group of all found sub-shapes or a single found sub-shape.
+ # @return Compound which includes all found sub-shapes if they have different types;
+ # or group of all found shapes of the equal type; or a single found sub-shape.
#
# @note This function has a restriction on argument shapes.
# If \a theShapeWhere has curved parts with significantly
# @image html get_in_place_lost_part.png
#
# @ref swig_GetInPlace "Example"
+ @ManageTransactions("ShapesOp")
def GetInPlace(self, theShapeWhere, theShapeWhat, isNewImplementation = False, theName=None):
"""
Get sub-shape(s) of theShapeWhere, which are
publication is switched on, default value is used for result name.
Returns:
- Group of all found sub-shapes or a single found sub-shape.
+ Compound which includes all found sub-shapes if they have different types;
+ or group of all found shapes of the equal type; or a single found sub-shape.
+
-
Note:
This function has a restriction on argument shapes.
If theShapeWhere has curved parts with significantly
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return Group of all found sub-shapes or a single found sub-shape.
+ # @return Compound which includes all found sub-shapes if they have different types;
+ # or group of all found shapes of the equal type; or a single found sub-shape.
#
# @ref swig_GetInPlace "Example"
+ @ManageTransactions("ShapesOp")
def GetInPlaceByHistory(self, theShapeWhere, theShapeWhat, theName=None):
"""
Implementation of this method is based on a saved history of an operation,
publication is switched on, default value is used for result name.
Returns:
- Group of all found sub-shapes or a single found sub-shape.
+ Compound which includes all found sub-shapes if they have different types;
+ or group of all found shapes of the equal type; or a single found sub-shape.
"""
# Example: see GEOM_TestOthers.py
anObj = self.ShapesOp.GetInPlaceByHistory(theShapeWhere, theShapeWhat)
# @return New GEOM.GEOM_Object for found sub-shape.
#
# @ref swig_GetSame "Example"
+ @ManageTransactions("ShapesOp")
def GetSame(self, theShapeWhere, theShapeWhat, theName=None):
"""
Get sub-shape of theShapeWhere, which is
# equal to \a theShapeWhat.
# @param theShapeWhere Shape to find sub-shape of.
# @param theShapeWhat Shape, specifying what to find.
- # @return List of all found sub-shapes indices.
+ # @return List of all found sub-shapes indices.
#
# @ref swig_GetSame "Example"
+ @ManageTransactions("ShapesOp")
def GetSameIDs(self, theShapeWhere, theShapeWhat):
"""
Get sub-shape indices of theShapeWhere, which is
RaiseIfFailed("GetSameIDs", self.ShapesOp)
return anObj
+ ## Resize the input edge with the new Min and Max parameters.
+ # The input edge parameters range is [0, 1]. If theMin parameter is
+ # negative, the input edge is extended, otherwise it is shrinked by
+ # theMin parameter. If theMax is greater than 1, the edge is extended,
+ # otherwise it is shrinked by theMax parameter.
+ # @param theEdge the input edge to be resized.
+ # @param theMin the minimal parameter value.
+ # @param theMax the maximal parameter value.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ # @return New GEOM.GEOM_Object, containing the created edge.
+ #
+ # @ref tui_extend "Example"
+ @ManageTransactions("ShapesOp")
+ def ExtendEdge(self, theEdge, theMin, theMax, theName=None):
+ """
+ Resize the input edge with the new Min and Max parameters.
+ The input edge parameters range is [0, 1]. If theMin parameter is
+ negative, the input edge is extended, otherwise it is shrinked by
+ theMin parameter. If theMax is greater than 1, the edge is extended,
+ otherwise it is shrinked by theMax parameter.
+
+ Parameters:
+ theEdge the input edge to be resized.
+ theMin the minimal parameter value.
+ theMax the maximal parameter value.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created edge.
+ """
+ theMin, theMax, Parameters = ParseParameters(theMin, theMax)
+ anObj = self.ShapesOp.ExtendEdge(theEdge, theMin, theMax)
+ RaiseIfFailed("ExtendEdge", self.ShapesOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "edge")
+ return anObj
+
+ ## Resize the input face with the new UMin, UMax, VMin and VMax
+ # parameters. The input face U and V parameters range is [0, 1]. If
+ # theUMin parameter is negative, the input face is extended, otherwise
+ # it is shrinked along U direction by theUMin parameter. If theUMax is
+ # greater than 1, the face is extended, otherwise it is shrinked along
+ # U direction by theUMax parameter. So as for theVMin, theVMax and
+ # V direction of the input face.
+ # @param theFace the input face to be resized.
+ # @param theUMin the minimal U parameter value.
+ # @param theUMax the maximal U parameter value.
+ # @param theVMin the minimal V parameter value.
+ # @param theVMax the maximal V parameter value.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ # @return New GEOM.GEOM_Object, containing the created face.
+ #
+ # @ref tui_extend "Example"
+ @ManageTransactions("ShapesOp")
+ def ExtendFace(self, theFace, theUMin, theUMax,
+ theVMin, theVMax, theName=None):
+ """
+ Resize the input face with the new UMin, UMax, VMin and VMax
+ parameters. The input face U and V parameters range is [0, 1]. If
+ theUMin parameter is negative, the input face is extended, otherwise
+ it is shrinked along U direction by theUMin parameter. If theUMax is
+ greater than 1, the face is extended, otherwise it is shrinked along
+ U direction by theUMax parameter. So as for theVMin, theVMax and
+ V direction of the input face.
+
+ Parameters:
+ theFace the input face to be resized.
+ theUMin the minimal U parameter value.
+ theUMax the maximal U parameter value.
+ theVMin the minimal V parameter value.
+ theVMax the maximal V parameter value.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created face.
+ """
+ theUMin, theUMax, theVMin, theVMax, Parameters = ParseParameters(theUMin, theUMax, theVMin, theVMax)
+ anObj = self.ShapesOp.ExtendFace(theFace, theUMin, theUMax,
+ theVMin, theVMax)
+ RaiseIfFailed("ExtendFace", self.ShapesOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "face")
+ return anObj
+
+ ## This function takes some face as input parameter and creates new
+ # GEOM_Object, i.e. topological shape by extracting underlying surface
+ # of the source face and limiting it by the Umin, Umax, Vmin, Vmax
+ # parameters of the source face (in the parametrical space).
+ # @param theFace the input face.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ # @return New GEOM.GEOM_Object, containing the created face.
+ #
+ # @ref tui_creation_surface "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeSurfaceFromFace(self, theFace, theName=None):
+ """
+ This function takes some face as input parameter and creates new
+ GEOM_Object, i.e. topological shape by extracting underlying surface
+ of the source face and limiting it by the Umin, Umax, Vmin, Vmax
+ parameters of the source face (in the parametrical space).
+
+ Parameters:
+ theFace the input face.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the created face.
+ """
+ anObj = self.ShapesOp.MakeSurfaceFromFace(theFace)
+ RaiseIfFailed("MakeSurfaceFromFace", self.ShapesOp)
+ self._autoPublish(anObj, theName, "surface")
+ return anObj
# end of l4_obtain
## @}
# @return ID of found sub-shape.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("LocalOp")
def GetSubShapeID(self, aShape, aSubShape):
"""
Obtain unique ID of sub-shape aSubShape inside aShape
anID = self.LocalOp.GetSubShapeIndex(aShape, aSubShape)
RaiseIfFailed("GetSubShapeIndex", self.LocalOp)
return anID
-
+
## Obtain unique IDs of sub-shapes <VAR>aSubShapes</VAR> inside <VAR>aShape</VAR>
# This function is provided for performance purpose. The complexity is O(n) with n
# the number of subobjects of aShape
# @return list of IDs of found sub-shapes.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def GetSubShapesIDs(self, aShape, aSubShapes):
"""
Obtain a list of IDs of sub-shapes aSubShapes inside aShape
# @return List of existing sub-objects of \a theShape.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def GetExistingSubObjects(self, theShape, theGroupsOnly = False):
"""
Get all sub-shapes and groups of theShape,
# @return List of existing groups of \a theShape.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def GetGroups(self, theShape):
"""
Get all groups of theShape,
## Explode a shape on sub-shapes of a given type.
# If the shape itself matches the type, it is also returned.
# @param aShape Shape to be exploded.
- # @param aType Type of sub-shapes to be retrieved (see ShapeType())
+ # @param aType Type of sub-shapes to be retrieved (see ShapeType())
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return List of sub-shapes of type theShapeType, contained in theShape.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def SubShapeAll(self, aShape, aType, theName=None):
"""
Explode a shape on sub-shapes of a given type.
Parameters:
aShape Shape to be exploded.
- aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
+ aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
# @return List of IDs of sub-shapes.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def SubShapeAllIDs(self, aShape, aType):
"""
Explode a shape on sub-shapes of a given type.
Obtain a compound of sub-shapes of aShape,
selected by their indices in list of all sub-shapes of type aType.
Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
-
+
Parameters:
aShape Shape to get sub-shape of.
ListOfID List of sub-shapes indices.
return anObj
## Explode a shape on sub-shapes of a given type.
- # Sub-shapes will be sorted by coordinates of their gravity centers.
+ # Sub-shapes will be sorted taking into account their gravity centers,
+ # to provide stable order of sub-shapes. Please see
+ # @ref sorting_shapes_page "Description of Sorting Shapes Algorithm".
# If the shape itself matches the type, it is also returned.
# @param aShape Shape to be exploded.
# @param aType Type of sub-shapes to be retrieved (see ShapeType())
# @return List of sub-shapes of type theShapeType, contained in theShape.
#
# @ref swig_SubShapeAllSorted "Example"
+ @ManageTransactions("ShapesOp")
def SubShapeAllSortedCentres(self, aShape, aType, theName=None):
"""
Explode a shape on sub-shapes of a given type.
- Sub-shapes will be sorted by coordinates of their gravity centers.
+ Sub-shapes will be sorted taking into account their gravity centers,
+ to provide stable order of sub-shapes.
If the shape itself matches the type, it is also returned.
- Parameters:
+ Parameters:
aShape Shape to be exploded.
aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
List of sub-shapes of type theShapeType, contained in theShape.
"""
# Example: see GEOM_TestAll.py
return ListObj
## Explode a shape on sub-shapes of a given type.
- # Sub-shapes will be sorted by coordinates of their gravity centers.
+ # Sub-shapes will be sorted taking into account their gravity centers,
+ # to provide stable order of sub-shapes. Please see
+ # @ref sorting_shapes_page "Description of Sorting Shapes Algorithm".
# @param aShape Shape to be exploded.
# @param aType Type of sub-shapes to be retrieved (see ShapeType())
# @return List of IDs of sub-shapes.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def SubShapeAllSortedCentresIDs(self, aShape, aType):
"""
Explode a shape on sub-shapes of a given type.
- Sub-shapes will be sorted by coordinates of their gravity centers.
+ Sub-shapes will be sorted taking into account their gravity centers,
+ to provide stable order of sub-shapes.
- Parameters:
+ Parameters:
aShape Shape to be exploded.
aType Type of sub-shapes to be retrieved (see geompy.ShapeType)
- Returns:
+ Returns:
List of IDs of sub-shapes.
"""
ListIDs = self.ShapesOp.GetAllSubShapesIDs(aShape, EnumToLong( aType ), True)
## Obtain a compound of sub-shapes of <VAR>aShape</VAR>,
# selected by they indices in sorted list of all sub-shapes of type <VAR>aType</VAR>.
+ # Please see @ref sorting_shapes_page "Description of Sorting Shapes Algorithm".
# Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
# @param aShape Shape to get sub-shape of.
# @param ListOfInd List of sub-shapes indices.
## Extract shapes (excluding the main shape) of given type.
# @param aShape The shape.
# @param aType The shape type (see ShapeType())
- # @param isSorted Boolean flag to switch sorting on/off.
+ # @param isSorted Boolean flag to switch sorting on/off. Please see
+ # @ref sorting_shapes_page "Description of Sorting Shapes Algorithm".
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return List of sub-shapes of type aType, contained in aShape.
#
# @ref swig_FilletChamfer "Example"
+ @ManageTransactions("ShapesOp")
def ExtractShapes(self, aShape, aType, isSorted = False, theName=None):
"""
Extract shapes (excluding the main shape) of given type.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
List of sub-shapes of type aType, contained in aShape.
"""
# Example: see GEOM_TestAll.py
# @return List of GEOM.GEOM_Object, corresponding to found sub-shapes.
#
# @ref swig_all_decompose "Example"
+ @ManageTransactions("ShapesOp")
def SubShapes(self, aShape, anIDs, theName=None):
"""
Get a set of sub-shapes defined by their unique IDs inside theMainShape
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
List of GEOM.GEOM_Object, corresponding to found sub-shapes.
"""
# Example: see GEOM_TestAll.py
self._autoPublish(ListObj, theName, "subshape")
return ListObj
+ ## Explode a shape into edges sorted in a row from a starting point.
+ # @param theShape the shape to be exploded on edges.
+ # @param theStartPoint the starting point.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ # @return List of GEOM.GEOM_Object that is actually an ordered list
+ # of edges sorted in a row from a starting point.
+ #
+ # @ref swig_GetSubShapeEdgeSorted "Example"
+ @ManageTransactions("ShapesOp")
+ def GetSubShapeEdgeSorted(self, theShape, theStartPoint, theName=None):
+ """
+ Explode a shape into edges sorted in a row from a starting point.
+
+ Parameters:
+ theShape the shape to be exploded on edges.
+ theStartPoint the starting point.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ List of GEOM.GEOM_Object that is actually an ordered list
+ of edges sorted in a row from a starting point.
+ """
+ # Example: see GEOM_TestAll.py
+ ListObj = self.ShapesOp.GetSubShapeEdgeSorted(theShape, theStartPoint)
+ RaiseIfFailed("GetSubShapeEdgeSorted", self.ShapesOp)
+ self._autoPublish(ListObj, theName, "SortedEdges")
+ return ListObj
+
+ ##
+ # Return the list of subshapes that satisfies a certain tolerance
+ # criterion. The user defines the type of shapes to be returned, the
+ # condition and the tolerance value. The operation is defined for
+ # faces, edges and vertices only. E.g. for theShapeType FACE,
+ # theCondition GEOM::CC_GT and theTolerance 1.e-7 this method returns
+ # all faces of theShape that have tolerances greater then 1.e7.
+ #
+ # @param theShape the shape to be exploded
+ # @param theShapeType the type of sub-shapes to be returned (see
+ # ShapeType()). Can have the values FACE, EDGE and VERTEX only.
+ # @param theCondition the condition type (see GEOM::comparison_condition).
+ # @param theTolerance the tolerance filter.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ # @return the list of shapes that satisfy the conditions.
+ #
+ # @ref swig_GetSubShapesWithTolerance "Example"
+ @ManageTransactions("ShapesOp")
+ def GetSubShapesWithTolerance(self, theShape, theShapeType,
+ theCondition, theTolerance, theName=None):
+ """
+ Return the list of subshapes that satisfies a certain tolerance
+ criterion. The user defines the type of shapes to be returned, the
+ condition and the tolerance value. The operation is defined for
+ faces, edges and vertices only. E.g. for theShapeType FACE,
+ theCondition GEOM::CC_GT and theTolerance 1.e-7 this method returns
+ all faces of theShape that have tolerances greater then 1.e7.
+
+ Parameters:
+ theShape the shape to be exploded
+ theShapeType the type of sub-shapes to be returned (see
+ ShapeType()). Can have the values FACE,
+ EDGE and VERTEX only.
+ theCondition the condition type (see GEOM::comparison_condition).
+ theTolerance the tolerance filter.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ The list of shapes that satisfy the conditions.
+ """
+ # Example: see GEOM_TestAll.py
+ ListObj = self.ShapesOp.GetSubShapesWithTolerance(theShape, EnumToLong(theShapeType),
+ theCondition, theTolerance)
+ RaiseIfFailed("GetSubShapesWithTolerance", self.ShapesOp)
+ self._autoPublish(ListObj, theName, "SubShapeWithTolerance")
+ return ListObj
+
+ ## Check if the object is a sub-object of another GEOM object.
+ # @param aSubObject Checked sub-object (or its parent object, in case if
+ # \a theSubObjectIndex is non-zero).
+ # @param anObject An object that is checked for ownership (or its parent object,
+ # in case if \a theObjectIndex is non-zero).
+ # @param aSubObjectIndex When non-zero, specifies a sub-shape index that
+ # identifies a sub-object within its parent specified via \a theSubObject.
+ # @param anObjectIndex When non-zero, specifies a sub-shape index that
+ # identifies an object within its parent specified via \a theObject.
+ # @return TRUE, if the given object contains sub-object.
+ @ManageTransactions("ShapesOp")
+ def IsSubShapeBelongsTo(self, aSubObject, anObject, aSubObjectIndex = 0, anObjectIndex = 0):
+ """
+ Check if the object is a sub-object of another GEOM object.
+
+ Parameters:
+ aSubObject Checked sub-object (or its parent object, in case if
+ \a theSubObjectIndex is non-zero).
+ anObject An object that is checked for ownership (or its parent object,
+ in case if \a theObjectIndex is non-zero).
+ aSubObjectIndex When non-zero, specifies a sub-shape index that
+ identifies a sub-object within its parent specified via \a theSubObject.
+ anObjectIndex When non-zero, specifies a sub-shape index that
+ identifies an object within its parent specified via \a theObject.
+
+ Returns
+ TRUE, if the given object contains sub-object.
+ """
+ IsOk = self.ShapesOp.IsSubShapeBelongsTo(aSubObject, aSubObjectIndex, anObject, anObjectIndex)
+ RaiseIfFailed("IsSubShapeBelongsTo", self.ShapesOp)
+ return IsOk
+
+ ## Perform extraction of sub-shapes from the main shape.
+ #
+ # @param theShape the main shape
+ # @param theListOfID the list of sub-shape IDs to be extracted from
+ # the main shape.
+ # @return New GEOM.GEOM_Object, containing the shape without
+ # extracted sub-shapes.
+ #
+ # @ref swig_MakeExtraction "Example"
+ @ManageTransactions("ShapesOp")
+ def MakeExtraction(self, theShape, theListOfID, theName=None):
+ """
+ Perform extraction of sub-shapes from the main shape.
+
+ Parameters:
+ theShape the main shape
+ theListOfID the list of sub-shape IDs to be extracted from
+ the main shape.
+
+ Returns
+ New GEOM.GEOM_Object, containing the shape without
+ extracted sub-shapes.
+ """
+ # Example: see GEOM_TestAll.py
+ (anObj, aStat) = self.ShapesOp.MakeExtraction(theShape, theListOfID)
+ RaiseIfFailed("MakeExtraction", self.ShapesOp)
+ self._autoPublish(anObj, theName, "Extraction")
+ return anObj
+
# end of l4_decompose
## @}
## Deprecated method
# It works like SubShapeAllSortedCentres(), but wrongly
# defines centres of faces, shells and solids.
+ @ManageTransactions("ShapesOp")
def SubShapeAllSorted(self, aShape, aType, theName=None):
"""
Deprecated method
## Deprecated method
# It works like SubShapeAllSortedCentresIDs(), but wrongly
# defines centres of faces, shells and solids.
+ @ManageTransactions("ShapesOp")
def SubShapeAllSortedIDs(self, aShape, aType):
"""
Deprecated method
# - \b FixFaceSize.Tolerance - defines minimum possible face size. \n
# - \b DropSmallEdges - removes edges, which merge with neighbouring edges. \n
# - \b DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.\n
+ # - \b DropSmallSolids - either removes small solids or merges them with neighboring ones. \n
+ # - \b DropSmallSolids.WidthFactorThreshold - defines maximum value of <em>2V/S</em> of a solid which is considered small, where \a V is volume and \a S is surface area of the solid. \n
+ # - \b DropSmallSolids.VolumeThreshold - defines maximum volume of a solid which is considered small. If the both tolerances are privided a solid is considered small if it meets the both criteria. \n
+ # - \b DropSmallSolids.MergeSolids - if "1", small solids are removed; if "0" small solids are merged to adjacent non-small solids or left untouched if cannot be merged. \n
#
# * \b SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical
# surfaces in segments using a certain angle. \n
# are coincidental. The curves or surfaces may still meet at an angle, giving rise to a sharp corner or edge).\n
# \b C1 (Tangential Continuity): first derivatives are equal (the end vectors of curves or surfaces are parallel,
# ruling out sharp edges).\n
- # \b C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves or surfaces
+ # \b C2 (Curvature Continuity): first and second derivatives are equal (the end vectors of curves or surfaces
# are of the same magnitude).\n
# \b CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of curves
# or surfaces (d/du C(u)) are the same at junction. \n
# @return New GEOM.GEOM_Object, containing processed shape.
#
# \n @ref tui_shape_processing "Example"
+ @ManageTransactions("HealOp")
def ProcessShape(self, theShape, theOperators, theParameters, theValues, theName=None):
"""
Apply a sequence of Shape Healing operators to the given object.
theShape Shape to be processed.
theValues List of values of parameters, in the same order
as parameters are listed in theParameters list.
- theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
+ theOperators List of names of operators ('FixShape', 'SplitClosedFaces', etc.).
theParameters List of names of parameters
- ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
+ ('FixShape.Tolerance3d', 'SplitClosedFaces.NbSplitPoints', etc.).
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
* FixShape.MaxTolerance3d - maximal possible tolerance of the shape after correction.
* FixFaceSize - removes small faces, such as spots and strips.
* FixFaceSize.Tolerance - defines minimum possible face size.
- * DropSmallEdges - removes edges, which merge with neighbouring edges.
+ * DropSmallEdges - removes edges, which merge with neighbouring edges.
* DropSmallEdges.Tolerance3d - defines minimum possible distance between two parallel edges.
+ * DropSmallSolids - either removes small solids or merges them with neighboring ones.
+ * DropSmallSolids.WidthFactorThreshold - defines maximum value of 2V/S of a solid which is considered small, where V is volume and S is surface area of the solid.
+ * DropSmallSolids.VolumeThreshold - defines maximum volume of a solid which is considered small. If the both tolerances are privided a solid is considered small if it meets the both criteria.
+ * DropSmallSolids.MergeSolids - if '1', small solids are removed; if '0' small solids are merged to adjacent non-small solids or left untouched if cannot be merged.
+
* SplitAngle - splits faces based on conical surfaces, surfaces of revolution and cylindrical surfaces
in segments using a certain angle.
* SplitAngle.Angle - the central angle of the resulting segments (i.e. we obtain two segments
* SplitContinuity.SurfaceContinuity - required continuity for surfaces.
* SplitContinuity.CurveContinuity - required continuity for curves.
This and the previous parameters can take the following values:
-
+
Parametric Continuity:
C0 (Positional Continuity): curves are joined (the end positions of curves or surfaces are
coincidental. The curves or surfaces may still meet at an angle,
or surfaces are of the same magnitude).
CN N-th derivatives are equal (both the direction and the magnitude of the Nth derivatives of
curves or surfaces (d/du C(u)) are the same at junction.
-
+
Geometric Continuity:
G1: first derivatives are proportional at junction.
The curve tangents thus have the same direction, but not necessarily the same magnitude.
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_suppress_faces "Example"
+ @ManageTransactions("HealOp")
def SuppressFaces(self, theObject, theFaces, theName=None):
"""
Remove faces from the given object (shape).
self._autoPublish(anObj, theName, "suppressFaces")
return anObj
- ## Sewing of some shapes into single shape.
+ ## Sewing of faces into a single shell.
# @param ListShape Shapes to be processed.
# @param theTolerance Required tolerance value.
# @param AllowNonManifold Flag that allows non-manifold sewing.
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing processed shape.
+ # @return New GEOM.GEOM_Object, containing a result shell.
#
# @ref tui_sewing "Example"
def MakeSewing(self, ListShape, theTolerance, AllowNonManifold=False, theName=None):
"""
- Sewing of some shapes into single shape.
+ Sewing of faces into a single shell.
Parameters:
ListShape Shapes to be processed.
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing processed shape.
+ New GEOM.GEOM_Object, containing containing a result shell.
"""
# Example: see GEOM_TestHealing.py
- comp = self.MakeCompound(ListShape)
# note: auto-publishing is done in self.Sew()
- anObj = self.Sew(comp, theTolerance, AllowNonManifold, theName)
+ anObj = self.Sew(ListShape, theTolerance, AllowNonManifold, theName)
return anObj
- ## Sewing of the given object.
- # @param theObject Shape to be processed.
+ ## Sewing of faces into a single shell.
+ # @param ListShape Shapes to be processed.
# @param theTolerance Required tolerance value.
# @param AllowNonManifold Flag that allows non-manifold sewing.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing processed shape.
- def Sew(self, theObject, theTolerance, AllowNonManifold=False, theName=None):
+ # @return New GEOM.GEOM_Object, containing a result shell.
+ @ManageTransactions("HealOp")
+ def Sew(self, ListShape, theTolerance, AllowNonManifold=False, theName=None):
"""
- Sewing of the given object.
+ Sewing of faces into a single shell.
Parameters:
- theObject Shape to be processed.
+ ListShape Shapes to be processed.
theTolerance Required tolerance value.
AllowNonManifold Flag that allows non-manifold sewing.
theName Object name; when specified, this parameter is used
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing processed shape.
+ New GEOM.GEOM_Object, containing a result shell.
"""
# Example: see MakeSewing() above
theTolerance,Parameters = ParseParameters(theTolerance)
if AllowNonManifold:
- anObj = self.HealOp.SewAllowNonManifold(theObject, theTolerance)
+ anObj = self.HealOp.SewAllowNonManifold( ToList( ListShape ), theTolerance)
else:
- anObj = self.HealOp.Sew(theObject, theTolerance)
+ anObj = self.HealOp.Sew( ToList( ListShape ), theTolerance)
# To avoid script failure in case of good argument shape
+ # (Fix of test cases geom/bugs11/L7,L8)
if self.HealOp.GetErrorCode() == "ShHealOper_NotError_msg":
- return theObject
+ return anObj
RaiseIfFailed("Sew", self.HealOp)
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "sewed")
return anObj
- ## Rebuild the topology of theCompound of solids by removing
- # of the faces that are shared by several solids.
- # @param theCompound Shape to be processed.
+ ## Rebuild the topology of theSolids by removing
+ # the faces that are shared by several solids.
+ # @param theSolids A compound or a list of solids to be processed.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_remove_webs "Example"
- def RemoveInternalFaces (self, theCompound, theName=None):
+ @ManageTransactions("HealOp")
+ def RemoveInternalFaces (self, theSolids, theName=None):
"""
- Rebuild the topology of theCompound of solids by removing
- of the faces that are shared by several solids.
+ Rebuild the topology of theSolids by removing
+ the faces that are shared by several solids.
Parameters:
- theCompound Shape to be processed.
+ theSolids A compound or a list of solids to be processed.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
New GEOM.GEOM_Object, containing processed shape.
"""
# Example: see GEOM_TestHealing.py
- anObj = self.HealOp.RemoveInternalFaces(theCompound)
+ anObj = self.HealOp.RemoveInternalFaces(ToList(theSolids))
RaiseIfFailed("RemoveInternalFaces", self.HealOp)
self._autoPublish(anObj, theName, "removeWebs")
return anObj
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_suppress_internal_wires "Example"
+ @ManageTransactions("HealOp")
def SuppressInternalWires(self, theObject, theWires, theName=None):
"""
Remove internal wires and edges from the given object (face).
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing processed shape.
"""
# Example: see GEOM_TestHealing.py
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_suppress_holes "Example"
+ @ManageTransactions("HealOp")
def SuppressHoles(self, theObject, theWires, theName=None):
"""
Remove internal closed contours (holes) from the given object.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing processed shape.
"""
# Example: see GEOM_TestHealing.py
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_close_contour "Example"
+ @ManageTransactions("HealOp")
def CloseContour(self,theObject, theWires, isCommonVertex, theName=None):
"""
Close an open wire.
- Parameters:
+ Parameters:
theObject Shape to be processed.
theWires Indexes of edge(s) and wire(s) to be closed within theObject's shape,
if [ ], then theObject itself is a wire.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing processed shape.
+ Returns:
+ New GEOM.GEOM_Object, containing processed shape.
"""
# Example: see GEOM_TestHealing.py
anObj = self.HealOp.CloseContour(theObject, theWires, isCommonVertex)
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_add_point_on_edge "Example"
+ @ManageTransactions("HealOp")
def DivideEdge(self, theObject, theEdgeIndex, theValue, isByParameter, theName=None):
"""
Addition of a point to a given edge object.
- Parameters:
+ Parameters:
theObject Shape to be processed.
theEdgeIndex Index of edge to be divided within theObject's shape,
if -1, then theObject itself is the edge.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing processed shape.
"""
# Example: see GEOM_TestHealing.py
self._autoPublish(anObj, theName, "divideEdge")
return anObj
+ ## Addition of points to a given edge of \a theObject by projecting
+ # other points to the given edge.
+ # @param theObject Shape to be processed.
+ # @param theEdgeIndex Index of edge to be divided within theObject's shape,
+ # if -1, then theObject itself is the edge.
+ # @param thePoints List of points to project to theEdgeIndex-th edge.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing processed shape.
+ #
+ # @ref tui_add_point_on_edge "Example"
+ @ManageTransactions("HealOp")
+ def DivideEdgeByPoint(self, theObject, theEdgeIndex, thePoints, theName=None):
+ """
+ Addition of points to a given edge of \a theObject by projecting
+ other points to the given edge.
+
+ Parameters:
+ theObject Shape to be processed.
+ theEdgeIndex The edge or its index to be divided within theObject's shape,
+ if -1, then theObject itself is the edge.
+ thePoints List of points to project to theEdgeIndex-th edge.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing processed shape.
+ """
+ # Example: see GEOM_TestHealing.py
+ if isinstance( theEdgeIndex, GEOM._objref_GEOM_Object ):
+ theEdgeIndex = self.GetSubShapeID( theObject, theEdgeIndex )
+ anObj = self.HealOp.DivideEdgeByPoint(theObject, theEdgeIndex, ToList( thePoints ))
+ RaiseIfFailed("DivideEdgeByPoint", self.HealOp)
+ self._autoPublish(anObj, theName, "divideEdge")
+ return anObj
+
## Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
# @param theWire Wire to minimize the number of C1 continuous edges in.
# @param theVertices A list of vertices to suppress. If the list
# @return New GEOM.GEOM_Object with modified wire.
#
# @ref tui_fuse_collinear_edges "Example"
+ @ManageTransactions("HealOp")
def FuseCollinearEdgesWithinWire(self, theWire, theVertices = [], theName=None):
"""
Suppress the vertices in the wire in case if adjacent edges are C1 continuous.
- Parameters:
+ Parameters:
theWire Wire to minimize the number of C1 continuous edges in.
theVertices A list of vertices to suppress. If the list
is empty, all vertices in a wire will be assumed.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object with modified wire.
"""
anObj = self.HealOp.FuseCollinearEdgesWithinWire(theWire, theVertices)
# @return Updated <var>theObject</var>
#
# @ref swig_todo "Example"
+ @ManageTransactions("HealOp")
def ChangeOrientationShell(self,theObject):
"""
Change orientation of the given object. Updates given shape.
- Parameters:
+ Parameters:
theObject Shape to be processed.
- Returns:
+ Returns:
Updated theObject
"""
theObject = self.HealOp.ChangeOrientation(theObject)
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref swig_todo "Example"
+ @ManageTransactions("HealOp")
def ChangeOrientationShellCopy(self, theObject, theName=None):
"""
Change orientation of the given object.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing processed shape.
"""
anObj = self.HealOp.ChangeOrientationCopy(theObject)
# @return New GEOM.GEOM_Object, containing processed shape.
#
# @ref tui_limit_tolerance "Example"
+ @ManageTransactions("HealOp")
def LimitTolerance(self, theObject, theTolerance = 1e-07, theName=None):
"""
Try to limit tolerance of the given object by value theTolerance.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing processed shape.
"""
anObj = self.HealOp.LimitTolerance(theObject, theTolerance)
# publication is switched on, default value is used for result name.
#
# @return [\a status, \a theClosedWires, \a theOpenWires]
- # \n \a status: FALSE, if an error(s) occured during the method execution.
+ # \n \a status: FALSE, if an error(s) occurred during the method execution.
# \n \a theClosedWires: Closed wires on the free boundary of the given shape.
# \n \a theOpenWires: Open wires on the free boundary of the given shape.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_free_boundaries_page "Example"
+ @ManageTransactions("HealOp")
def GetFreeBoundary(self, theObject, theName=None):
"""
Get a list of wires (wrapped in GEOM.GEOM_Object-s),
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
[status, theClosedWires, theOpenWires]
- status: FALSE, if an error(s) occured during the method execution.
+ status: FALSE, if an error(s) occurred during the method execution.
theClosedWires: Closed wires on the free boundary of the given shape.
theOpenWires: Open wires on the free boundary of the given shape.
"""
# Example: see GEOM_TestHealing.py
- anObj = self.HealOp.GetFreeBoundary(theObject)
+ anObj = self.HealOp.GetFreeBoundary( ToList( theObject ))
RaiseIfFailed("GetFreeBoundary", self.HealOp)
self._autoPublish(anObj[1], theName, "closedWire")
self._autoPublish(anObj[2], theName, "openWire")
return anObj
- ## Replace coincident faces in theShape by one face.
- # @param theShape Initial shape.
+ ## Replace coincident faces in \a theShapes by one face.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between faces, which can be considered as coincident.
# @param doKeepNonSolids If FALSE, only solids will present in the result,
# otherwise all initial shapes.
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
+ # @return New GEOM.GEOM_Object, containing copies of theShapes without coincident faces.
#
# @ref tui_glue_faces "Example"
- def MakeGlueFaces(self, theShape, theTolerance, doKeepNonSolids=True, theName=None):
+ @ManageTransactions("ShapesOp")
+ def MakeGlueFaces(self, theShapes, theTolerance, doKeepNonSolids=True, theName=None):
"""
- Replace coincident faces in theShape by one face.
+ Replace coincident faces in theShapes by one face.
Parameters:
- theShape Initial shape.
+ theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between faces, which can be considered as coincident.
doKeepNonSolids If FALSE, only solids will present in the result,
otherwise all initial shapes.
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing a copy of theShape without coincident faces.
+ New GEOM.GEOM_Object, containing copies of theShapes without coincident faces.
"""
# Example: see GEOM_Spanner.py
theTolerance,Parameters = ParseParameters(theTolerance)
- anObj = self.ShapesOp.MakeGlueFaces(theShape, theTolerance, doKeepNonSolids)
+ anObj = self.ShapesOp.MakeGlueFaces(ToList(theShapes), theTolerance, doKeepNonSolids)
if anObj is None:
raise RuntimeError, "MakeGlueFaces : " + self.ShapesOp.GetErrorCode()
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "glueFaces")
return anObj
- ## Find coincident faces in theShape for possible gluing.
- # @param theShape Initial shape.
+ ## Find coincident faces in \a theShapes for possible gluing.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between faces,
# which can be considered as coincident.
# @param theName Object name; when specified, this parameter is used
# @return GEOM.ListOfGO
#
# @ref tui_glue_faces "Example"
- def GetGlueFaces(self, theShape, theTolerance, theName=None):
+ @ManageTransactions("ShapesOp")
+ def GetGlueFaces(self, theShapes, theTolerance, theName=None):
"""
- Find coincident faces in theShape for possible gluing.
+ Find coincident faces in theShapes for possible gluing.
Parameters:
- theShape Initial shape.
+ theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between faces,
which can be considered as coincident.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
GEOM.ListOfGO
"""
- anObj = self.ShapesOp.GetGlueFaces(theShape, theTolerance)
+ anObj = self.ShapesOp.GetGlueFaces(ToList(theShapes), theTolerance)
RaiseIfFailed("GetGlueFaces", self.ShapesOp)
self._autoPublish(anObj, theName, "facesToGlue")
return anObj
- ## Replace coincident faces in theShape by one face
+ ## Replace coincident faces in \a theShapes by one face
# in compliance with given list of faces
- # @param theShape Initial shape.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between faces,
# which can be considered as coincident.
# @param theFaces List of faces for gluing.
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing a copy of theShape
- # without some faces.
+ # @return New GEOM.GEOM_Object, containing copies of theShapes without coincident faces.
#
# @ref tui_glue_faces "Example"
- def MakeGlueFacesByList(self, theShape, theTolerance, theFaces,
+ @ManageTransactions("ShapesOp")
+ def MakeGlueFacesByList(self, theShapes, theTolerance, theFaces,
doKeepNonSolids=True, doGlueAllEdges=True, theName=None):
"""
- Replace coincident faces in theShape by one face
+ Replace coincident faces in theShapes by one face
in compliance with given list of faces
Parameters:
- theShape Initial shape.
+ theShapes theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between faces,
which can be considered as coincident.
theFaces List of faces for gluing.
publication is switched on, default value is used for result name.
Returns:
- New GEOM.GEOM_Object, containing a copy of theShape
- without some faces.
+ New GEOM.GEOM_Object, containing copies of theShapes without coincident faces.
"""
- anObj = self.ShapesOp.MakeGlueFacesByList(theShape, theTolerance, theFaces,
+ anObj = self.ShapesOp.MakeGlueFacesByList(ToList(theShapes), theTolerance, ToList(theFaces),
doKeepNonSolids, doGlueAllEdges)
if anObj is None:
raise RuntimeError, "MakeGlueFacesByList : " + self.ShapesOp.GetErrorCode()
self._autoPublish(anObj, theName, "glueFaces")
return anObj
- ## Replace coincident edges in theShape by one edge.
- # @param theShape Initial shape.
+ ## Replace coincident edges in \a theShapes by one edge.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between edges, which can be considered as coincident.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
+ # @return New GEOM.GEOM_Object, containing copies of theShapes without coincident edges.
#
# @ref tui_glue_edges "Example"
- def MakeGlueEdges(self, theShape, theTolerance, theName=None):
+ @ManageTransactions("ShapesOp")
+ def MakeGlueEdges(self, theShapes, theTolerance, theName=None):
"""
- Replace coincident edges in theShape by one edge.
+ Replace coincident edges in theShapes by one edge.
Parameters:
- theShape Initial shape.
+ theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between edges, which can be considered as coincident.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing a copy of theShape without coincident edges.
+ Returns:
+ New GEOM.GEOM_Object, containing copies of theShapes without coincident edges.
"""
theTolerance,Parameters = ParseParameters(theTolerance)
- anObj = self.ShapesOp.MakeGlueEdges(theShape, theTolerance)
+ anObj = self.ShapesOp.MakeGlueEdges(ToList(theShapes), theTolerance)
if anObj is None:
raise RuntimeError, "MakeGlueEdges : " + self.ShapesOp.GetErrorCode()
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "glueEdges")
return anObj
- ## Find coincident edges in theShape for possible gluing.
- # @param theShape Initial shape.
+ ## Find coincident edges in \a theShapes for possible gluing.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between edges,
# which can be considered as coincident.
# @param theName Object name; when specified, this parameter is used
# @return GEOM.ListOfGO
#
# @ref tui_glue_edges "Example"
- def GetGlueEdges(self, theShape, theTolerance, theName=None):
+ @ManageTransactions("ShapesOp")
+ def GetGlueEdges(self, theShapes, theTolerance, theName=None):
"""
- Find coincident edges in theShape for possible gluing.
+ Find coincident edges in theShapes for possible gluing.
Parameters:
- theShape Initial shape.
+ theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between edges,
which can be considered as coincident.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
GEOM.ListOfGO
"""
- anObj = self.ShapesOp.GetGlueEdges(theShape, theTolerance)
+ anObj = self.ShapesOp.GetGlueEdges(ToList(theShapes), theTolerance)
RaiseIfFailed("GetGlueEdges", self.ShapesOp)
self._autoPublish(anObj, theName, "edgesToGlue")
return anObj
- ## Replace coincident edges in theShape by one edge
+ ## Replace coincident edges in theShapes by one edge
# in compliance with given list of edges.
- # @param theShape Initial shape.
+ # @param theShapes Initial shapes, either a list or compound of shapes.
# @param theTolerance Maximum distance between edges,
# which can be considered as coincident.
# @param theEdges List of edges for gluing.
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing a copy of theShape
- # without some edges.
+ # @return New GEOM.GEOM_Object, containing copies of theShapes without coincident edges.
#
# @ref tui_glue_edges "Example"
- def MakeGlueEdgesByList(self, theShape, theTolerance, theEdges, theName=None):
+ @ManageTransactions("ShapesOp")
+ def MakeGlueEdgesByList(self, theShapes, theTolerance, theEdges, theName=None):
"""
- Replace coincident edges in theShape by one edge
+ Replace coincident edges in theShapes by one edge
in compliance with given list of edges.
Parameters:
- theShape Initial shape.
+ theShapes Initial shapes, either a list or compound of shapes.
theTolerance Maximum distance between edges,
which can be considered as coincident.
theEdges List of edges for gluing.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
- New GEOM.GEOM_Object, containing a copy of theShape
- without some edges.
+ Returns:
+ New GEOM.GEOM_Object, containing copies of theShapes without coincident edges.
"""
- anObj = self.ShapesOp.MakeGlueEdgesByList(theShape, theTolerance, theEdges)
+ anObj = self.ShapesOp.MakeGlueEdgesByList(ToList(theShapes), theTolerance, theEdges)
if anObj is None:
raise RuntimeError, "MakeGlueEdgesByList : " + self.ShapesOp.GetErrorCode()
self._autoPublish(anObj, theName, "glueEdges")
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_fuse "Example"
+ @ManageTransactions("BoolOp")
def MakeBoolean(self, theShape1, theShape2, theOperation, checkSelfInte=False, theName=None):
"""
Perform one of boolean operations on two given shapes.
- Parameters:
+ Parameters:
theShape1 First argument for boolean operation.
theShape2 Second argument for boolean operation.
theOperation Indicates the operation to be done:
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
"""
# Example: see GEOM_TestAll.py
"""
Perform Common boolean operation on two given shapes.
- Parameters:
+ Parameters:
theShape1 First argument for boolean operation.
theShape2 Second argument for boolean operation.
checkSelfInte The flag that tells if the arguments should
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
"""
# Example: see GEOM_TestOthers.py
"""
Perform Cut boolean operation on two given shapes.
- Parameters:
+ Parameters:
theShape1 First argument for boolean operation.
theShape2 Second argument for boolean operation.
checkSelfInte The flag that tells if the arguments should
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
# note: auto-publishing is done in self.MakeBoolean()
#
# @ref tui_fuse "Example 1"
# \n @ref swig_MakeCommon "Example 2"
+ @ManageTransactions("BoolOp")
def MakeFuse(self, theShape1, theShape2, checkSelfInte=False,
rmExtraEdges=False, theName=None):
"""
Perform Fuse boolean operation on two given shapes.
- Parameters:
+ Parameters:
theShape1 First argument for boolean operation.
theShape2 Second argument for boolean operation.
checkSelfInte The flag that tells if the arguments should
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
anObj = self.BoolOp.MakeFuse(theShape1, theShape2,
# @param theShape2 Second argument for boolean operation.
# @param checkSelfInte The flag that tells if the arguments should
# be checked for self-intersection prior to the operation.
+ # If a self-intersection detected the operation fails.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
- #
- # @note This algorithm doesn't find all types of self-intersections.
- # It is tuned to detect vertex/vertex, vertex/edge, edge/edge,
- # vertex/face and edge/face intersections. Face/face
- # intersections detection is switched off as it is a
- # time-consuming operation that gives an impact on performance.
- # To find all self-intersections please use
- # CheckSelfIntersections() method.
- #
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_section "Example 1"
"""
Perform Section boolean operation on two given shapes.
- Parameters:
+ Parameters:
theShape1 First argument for boolean operation.
theShape2 Second argument for boolean operation.
checkSelfInte The flag that tells if the arguments should
- be checked for self-intersection prior to
- the operation.
+ be checked for self-intersection prior to the operation.
+ If a self-intersection detected the operation fails.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
- Note:
- This algorithm doesn't find all types of self-intersections.
- It is tuned to detect vertex/vertex, vertex/edge, edge/edge,
- vertex/face and edge/face intersections. Face/face
- intersections detection is switched off as it is a
- time-consuming operation that gives an impact on performance.
- To find all self-intersections please use
- CheckSelfIntersections() method.
-
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
# note: auto-publishing is done in self.MakeBoolean()
#
# @ref tui_fuse "Example 1"
# \n @ref swig_MakeCommon "Example 2"
+ @ManageTransactions("BoolOp")
def MakeFuseList(self, theShapesList, checkSelfInte=False,
rmExtraEdges=False, theName=None):
"""
Perform Fuse boolean operation on the list of shapes.
- Parameters:
+ Parameters:
theShapesList Shapes to be fused.
checkSelfInte The flag that tells if the arguments should
be checked for self-intersection prior to
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
anObj = self.BoolOp.MakeFuseList(theShapesList, checkSelfInte,
#
# @ref tui_common "Example 1"
# \n @ref swig_MakeCommon "Example 2"
+ @ManageTransactions("BoolOp")
def MakeCommonList(self, theShapesList, checkSelfInte=False, theName=None):
"""
Perform Common boolean operation on the list of shapes.
- Parameters:
+ Parameters:
theShapesList Shapes for Common operation.
checkSelfInte The flag that tells if the arguments should
be checked for self-intersection prior to
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
anObj = self.BoolOp.MakeCommonList(theShapesList, checkSelfInte)
#
# @ref tui_cut "Example 1"
# \n @ref swig_MakeCommon "Example 2"
+ @ManageTransactions("BoolOp")
def MakeCutList(self, theMainShape, theShapesList, checkSelfInte=False, theName=None):
"""
Perform Cut boolean operation on one object and the list of tools.
- Parameters:
+ Parameters:
theMainShape The object of the operation.
theShapesList The list of tools of the operation.
checkSelfInte The flag that tells if the arguments should
To find all self-intersections please use
CheckSelfIntersections() method.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
-
+
"""
# Example: see GEOM_TestOthers.py
anObj = self.BoolOp.MakeCutList(theMainShape, theShapesList, checkSelfInte)
# @param ListRemoveInside Shapes, inside which the results will be deleted.
# Each shape from theRemoveInside must belong to theShapes also.
# @param RemoveWebs If TRUE, perform Glue 3D algorithm.
- # @param ListMaterials Material indices for each shape. Make sence,
+ # @param ListMaterials Material indices for each shape. Make sense,
# only if theRemoveWebs is TRUE.
#
# @return New GEOM.GEOM_Object, containing the result shapes.
#
# @ref tui_partition "Example"
+ @ManageTransactions("BoolOp")
def MakePartition(self, ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
Limit=ShapeType["AUTO"], RemoveWebs=0, ListMaterials=[],
KeepNonlimitShapes=0, theName=None):
"""
Perform partition operation.
- Parameters:
+ Parameters:
ListShapes Shapes to be intersected.
ListTools Shapes to intersect theShapes.
Limit Type of resulting shapes (see geompy.ShapeType)
Each compound from ListShapes and ListTools will be exploded
in order to avoid possible intersection between shapes from
this compound.
-
+
After implementation new version of PartitionAlgo (October 2006) other
parameters are ignored by current functionality. They are kept in this
function only for support old versions.
-
+
Ignored parameters:
ListKeepInside Shapes, outside which the results will be deleted.
Each shape from theKeepInside must belong to theShapes also.
ListRemoveInside Shapes, inside which the results will be deleted.
Each shape from theRemoveInside must belong to theShapes also.
RemoveWebs If TRUE, perform Glue 3D algorithm.
- ListMaterials Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
+ ListMaterials Material indices for each shape. Make sense, only if theRemoveWebs is TRUE.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shapes.
"""
# Example: see GEOM_TestAll.py
# @return New GEOM.GEOM_Object, containing the result shapes.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BoolOp")
def MakePartitionNonSelfIntersectedShape(self, ListShapes, ListTools=[],
ListKeepInside=[], ListRemoveInside=[],
Limit=ShapeType["AUTO"], RemoveWebs=0,
compound contains nonintersected shapes. Performance will be better
since intersection between shapes from compound is not performed.
- Parameters:
+ Parameters:
Description of all parameters as in method geompy.MakePartition.
One additional parameter is provided:
checkSelfInte The flag that tells if the arguments should
time-consuming operation that gives an impact on performance.
To find all self-intersections please use
CheckSelfIntersections() method.
-
+
NOTE:
Passed compounds (via ListShapes or via ListTools)
have to consist of nonintersecting shapes.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shapes.
"""
if Limit == self.ShapeType["AUTO"]:
#
# @return New GEOM.GEOM_Object, containing the result shape.
#
+ # @note This operation is a shortcut to the more general @ref MakePartition
+ # operation, where @a theShape specifies single "object" (shape being partitioned)
+ # and @a thePlane specifies single "tool" (intersector shape). Other parameters of
+ # @ref MakePartition operation have default values:
+ # - @a Limit: GEOM::SHAPE (shape limit corresponds to the type of @a theShape)
+ # - @a KeepNonlimitShapes: 0
+ # - @a KeepInside, @a RemoveInside, @a RemoveWebs,
+ # @a Materials (obsolete parameters): empty
+ #
+ # @note I.e. the following two operations are equivalent:
+ # @code
+ # Result = geompy.MakeHalfPartition(Object, Plane)
+ # Result = geompy.MakePartition([Object], [Plane])
+ # @endcode
+ #
+ # @sa MakePartition, MakePartitionNonSelfIntersectedShape
+ #
# @ref tui_partition "Example"
+ @ManageTransactions("BoolOp")
def MakeHalfPartition(self, theShape, thePlane, theName=None):
"""
Perform partition of the Shape with the Plane
- Parameters:
+ Parameters:
theShape Shape to be intersected.
thePlane Tool shape, to intersect theShape.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
+
+ Note: This operation is a shortcut to the more general MakePartition
+ operation, where theShape specifies single "object" (shape being partitioned)
+ and thePlane specifies single "tool" (intersector shape). Other parameters of
+ MakePartition operation have default values:
+ - Limit: GEOM::SHAPE (shape limit corresponds to the type of theShape)
+ - KeepNonlimitShapes: 0
+ - KeepInside, RemoveInside, RemoveWebs, Materials (obsolete parameters): empty
+
+ I.e. the following two operations are equivalent:
+ Result = geompy.MakeHalfPartition(Object, Plane)
+ Result = geompy.MakePartition([Object], [Plane])
"""
# Example: see GEOM_TestAll.py
anObj = self.BoolOp.MakeHalfPartition(theShape, thePlane)
# @param theCopy Flag used to translate object itself or create a copy.
# @return Translated @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the translated object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def TranslateTwoPoints(self, theObject, thePoint1, thePoint2, theCopy=False):
"""
Translate the given object along the vector, specified by its end points.
- Parameters:
+ Parameters:
theObject The object to be translated.
thePoint1 Start point of translation vector.
thePoint2 End point of translation vector.
theCopy Flag used to translate object itself or create a copy.
- Returns:
+ Returns:
Translated theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the translated object if theCopy flag is True.
"""
#
# @ref tui_translation "Example 1"
# \n @ref swig_MakeTranslationTwoPoints "Example 2"
+ @ManageTransactions("TrsfOp")
def MakeTranslationTwoPoints(self, theObject, thePoint1, thePoint2, theName=None):
"""
Translate the given object along the vector, specified
by its end points, creating its copy before the translation.
- Parameters:
+ Parameters:
theObject The object to be translated.
thePoint1 Start point of translation vector.
thePoint2 End point of translation vector.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the translated object.
"""
# Example: see GEOM_TestAll.py
# new GEOM.GEOM_Object, containing the translated object if @a theCopy flag is @c True.
#
# @ref tui_translation "Example"
+ @ManageTransactions("TrsfOp")
def TranslateDXDYDZ(self, theObject, theDX, theDY, theDZ, theCopy=False):
"""
Translate the given object along the vector, specified by its components.
- Parameters:
+ Parameters:
theObject The object to be translated.
theDX,theDY,theDZ Components of translation vector.
theCopy Flag used to translate object itself or create a copy.
- Returns:
+ Returns:
Translated theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the translated object if theCopy flag is True.
"""
# @return New GEOM.GEOM_Object, containing the translated object.
#
# @ref tui_translation "Example"
+ @ManageTransactions("TrsfOp")
def MakeTranslation(self,theObject, theDX, theDY, theDZ, theName=None):
"""
Translate the given object along the vector, specified
by its components, creating its copy before the translation.
- Parameters:
+ Parameters:
theObject The object to be translated.
theDX,theDY,theDZ Components of translation vector.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the translated object.
"""
# Example: see GEOM_TestAll.py
# @param theCopy Flag used to translate object itself or create a copy.
# @return Translated @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the translated object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def TranslateVector(self, theObject, theVector, theCopy=False):
"""
Translate the given object along the given vector.
- Parameters:
+ Parameters:
theObject The object to be translated.
theVector The translation vector.
theCopy Flag used to translate object itself or create a copy.
- Returns:
+ Returns:
Translated theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the translated object if theCopy flag is True.
"""
# @return New GEOM.GEOM_Object, containing the translated object.
#
# @ref tui_translation "Example"
+ @ManageTransactions("TrsfOp")
def MakeTranslationVector(self, theObject, theVector, theName=None):
"""
Translate the given object along the given vector,
creating its copy before the translation.
- Parameters:
+ Parameters:
theObject The object to be translated.
theVector The translation vector.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the translated object.
"""
# Example: see GEOM_TestAll.py
# new GEOM.GEOM_Object, containing the translated object if @a theCopy flag is @c True.
#
# @ref tui_translation "Example"
+ @ManageTransactions("TrsfOp")
def TranslateVectorDistance(self, theObject, theVector, theDistance, theCopy=False):
"""
Translate the given object along the given vector on given distance.
- Parameters:
+ Parameters:
theObject The object to be translated.
theVector The translation vector.
theDistance The translation distance.
theCopy Flag used to translate object itself or create a copy.
- Returns:
+ Returns:
Translated theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the translated object if theCopy flag is True.
"""
# @return New GEOM.GEOM_Object, containing the translated object.
#
# @ref tui_translation "Example"
+ @ManageTransactions("TrsfOp")
def MakeTranslationVectorDistance(self, theObject, theVector, theDistance, theName=None):
"""
Translate the given object along the given vector on given distance,
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the translated object.
"""
# Example: see GEOM_TestAll.py
# new GEOM.GEOM_Object, containing the rotated object if @a theCopy flag is @c True.
#
# @ref tui_rotation "Example"
+ @ManageTransactions("TrsfOp")
def Rotate(self, theObject, theAxis, theAngle, theCopy=False):
"""
Rotate the given object around the given axis on the given angle.
return anObj
## Rotate the given object around the given axis
- # on the given angle, creating its copy before the rotatation.
+ # on the given angle, creating its copy before the rotation.
# @param theObject The object to be rotated.
# @param theAxis Rotation axis.
# @param theAngle Rotation angle in radians.
# @return New GEOM.GEOM_Object, containing the rotated object.
#
# @ref tui_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MakeRotation(self, theObject, theAxis, theAngle, theName=None):
"""
Rotate the given object around the given axis
# @param theCopy Flag used to rotate object itself or create a copy.
# @return Rotated @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the rotated object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def RotateThreePoints(self, theObject, theCentPoint, thePoint1, thePoint2, theCopy=False):
"""
Rotate given object around vector perpendicular to plane
# @return New GEOM.GEOM_Object, containing the rotated object.
#
# @ref tui_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MakeRotationThreePoints(self, theObject, theCentPoint, thePoint1, thePoint2, theName=None):
"""
Rotate given object around vector perpendicular to plane
# @param theCopy Flag used to scale object itself or create a copy.
# @return Scaled @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the scaled object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def Scale(self, theObject, thePoint, theFactor, theCopy=False):
"""
Scale the given object by the specified factor.
theFactor Scaling factor value.
theCopy Flag used to scale object itself or create a copy.
- Returns:
+ Returns:
Scaled theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the scaled object if theCopy flag is True.
"""
# @return New GEOM.GEOM_Object, containing the scaled shape.
#
# @ref tui_scale "Example"
+ @ManageTransactions("TrsfOp")
def MakeScaleTransform(self, theObject, thePoint, theFactor, theName=None):
"""
Scale the given object by the factor, creating its copy before the scaling.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the scaled shape.
"""
# Example: see GEOM_TestAll.py
# @param theCopy Flag used to scale object itself or create a copy.
# @return Scaled @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the scaled object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def ScaleAlongAxes(self, theObject, thePoint, theFactorX, theFactorY, theFactorZ, theCopy=False):
"""
Scale the given object by different factors along coordinate axes.
theFactorX,theFactorY,theFactorZ Scaling factors along each axis.
theCopy Flag used to scale object itself or create a copy.
- Returns:
+ Returns:
Scaled theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the scaled object if theCopy flag is True.
"""
# @return New GEOM.GEOM_Object, containing the scaled shape.
#
# @ref swig_scale "Example"
+ @ManageTransactions("TrsfOp")
def MakeScaleAlongAxes(self, theObject, thePoint, theFactorX, theFactorY, theFactorZ, theName=None):
"""
Scale the given object by different factors along coordinate axes,
# @param theCopy Flag used to mirror object itself or create a copy.
# @return Mirrored @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the mirrored object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def MirrorByPlane(self, theObject, thePlane, theCopy=False):
"""
Mirror an object relatively the given plane.
# @return New GEOM.GEOM_Object, containing the mirrored shape.
#
# @ref tui_mirror "Example"
+ @ManageTransactions("TrsfOp")
def MakeMirrorByPlane(self, theObject, thePlane, theName=None):
"""
Create an object, symmetrical to the given one relatively the given plane.
# @param theCopy Flag used to mirror object itself or create a copy.
# @return Mirrored @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the mirrored object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def MirrorByAxis(self, theObject, theAxis, theCopy=False):
"""
Mirror an object relatively the given axis.
# @return New GEOM.GEOM_Object, containing the mirrored shape.
#
# @ref tui_mirror "Example"
+ @ManageTransactions("TrsfOp")
def MakeMirrorByAxis(self, theObject, theAxis, theName=None):
"""
Create an object, symmetrical to the given one relatively the given axis.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the mirrored shape.
"""
# Example: see GEOM_TestAll.py
# @param theCopy Flag used to mirror object itself or create a copy.
# @return Mirrored @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the mirrored object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def MirrorByPoint(self, theObject, thePoint, theCopy=False):
"""
Mirror an object relatively the given point.
# @return New GEOM.GEOM_Object, containing the mirrored shape.
#
# @ref tui_mirror "Example"
+ @ManageTransactions("TrsfOp")
def MakeMirrorByPoint(self, theObject, thePoint, theName=None):
"""
Create an object, symmetrical
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the mirrored shape.
"""
# Example: see GEOM_TestAll.py
# @param theCopy Flag used to displace object itself or create a copy.
# @return Displaced @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the displaced object if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def Position(self, theObject, theStartLCS, theEndLCS, theCopy=False):
"""
Modify the Location of the given object by LCS, creating its copy before the setting.
# @return New GEOM.GEOM_Object, containing the displaced shape.
#
# @ref tui_modify_location "Example"
+ @ManageTransactions("TrsfOp")
def MakePosition(self, theObject, theStartLCS, theEndLCS, theName=None):
"""
Modify the Location of the given object by LCS, creating its copy before the setting.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the displaced shape.
Example of usage:
# new GEOM.GEOM_Object, containing the displaced shape if @a theCopy is @c True.
#
# @ref tui_modify_location "Example"
+ @ManageTransactions("TrsfOp")
def PositionAlongPath(self,theObject, thePath, theDistance, theCopy, theReverse):
"""
Modify the Location of the given object by Path.
theCopy is to create a copy objects if true.
theReverse 0 - for usual direction, 1 - to reverse path direction.
- Returns:
+ Returns:
Displaced theObject (GEOM.GEOM_Object) if theCopy is False or
new GEOM.GEOM_Object, containing the displaced shape if theCopy is True.
# publication is switched on, default value is used for result name.
#
# @return New GEOM.GEOM_Object, containing the displaced shape.
+ @ManageTransactions("TrsfOp")
def MakePositionAlongPath(self, theObject, thePath, theDistance, theReverse, theName=None):
"""
Modify the Location of the given object by Path, creating its copy before the operation.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the displaced shape.
"""
# Example: see GEOM_TestAll.py
# @param theCopy Flag used to offset object itself or create a copy.
# @return Modified @a theObject (GEOM.GEOM_Object) if @a theCopy flag is @c False (default) or
# new GEOM.GEOM_Object, containing the result of offset operation if @a theCopy flag is @c True.
+ @ManageTransactions("TrsfOp")
def Offset(self, theObject, theOffset, theCopy=False):
"""
Offset given shape.
theOffset Offset value.
theCopy Flag used to offset object itself or create a copy.
- Returns:
+ Returns:
Modified theObject (GEOM.GEOM_Object) if theCopy flag is False (default) or
new GEOM.GEOM_Object, containing the result of offset operation if theCopy flag is True.
"""
theOffset, Parameters = ParseParameters(theOffset)
if theCopy:
- anObj = self.TrsfOp.OffsetShapeCopy(theObject, theOffset)
+ anObj = self.TrsfOp.OffsetShapeCopy(theObject, theOffset, True)
else:
- anObj = self.TrsfOp.OffsetShape(theObject, theOffset)
+ anObj = self.TrsfOp.OffsetShape(theObject, theOffset, True)
RaiseIfFailed("Offset", self.TrsfOp)
anObj.SetParameters(Parameters)
return anObj
- ## Create new object as offset of the given one.
+ ## Create new object as offset of the given one. Gap between two adjacent
+ # offset surfaces is filled by a pipe.
# @param theObject The base object for the offset.
# @param theOffset Offset value.
# @param theName Object name; when specified, this parameter is used
#
# @return New GEOM.GEOM_Object, containing the offset object.
#
+ # @sa MakeOffsetIntersectionJoin
# @ref tui_offset "Example"
+ @ManageTransactions("TrsfOp")
def MakeOffset(self, theObject, theOffset, theName=None):
"""
- Create new object as offset of the given one.
+ Create new object as offset of the given one. Gap between adjacent
+ offset surfaces is filled by a pipe.
Parameters:
theObject The base object for the offset.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the offset object.
Example of usage:
"""
# Example: see GEOM_TestAll.py
theOffset, Parameters = ParseParameters(theOffset)
- anObj = self.TrsfOp.OffsetShapeCopy(theObject, theOffset)
+ anObj = self.TrsfOp.OffsetShapeCopy( theObject, theOffset, True )
RaiseIfFailed("OffsetShapeCopy", self.TrsfOp)
anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "offset")
return anObj
- ## Create new object as projection of the given one on a 2D surface.
+ ## Create new object as offset of the given one. Gap between adjacent
+ # offset surfaces is filled by extending and intersecting them.
+ # @param theObject The base object for the offset.
+ # @param theOffset Offset value.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the offset object.
+ #
+ # @sa MakeOffset
+ # @ref tui_offset "Example"
+ @ManageTransactions("TrsfOp")
+ def MakeOffsetIntersectionJoin(self, theObject, theOffset, theName=None):
+ """
+ Create new object as offset of the given one. Gap between adjacent
+ offset surfaces is filled by extending and intersecting them.
+
+ Parameters:
+ theObject The base object for the offset.
+ theOffset Offset value.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the offset object.
+
+ Example of usage:
+ box = geompy.MakeBox(20, 20, 20, 200, 200, 200)
+ # create a new box extended by 70
+ offset = geompy.MakeOffsetIntersectionJoin(box, 70.)
+ """
+ # Example: see GEOM_TestAll.py
+ theOffset, Parameters = ParseParameters( theOffset )
+ anObj = self.TrsfOp.OffsetShapeCopy( theObject, theOffset, False )
+ RaiseIfFailed("OffsetShapeCopy", self.TrsfOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "offset")
+ return anObj
+
+ ## Create new object as projection of the given one on another.
# @param theSource The source object for the projection. It can be a point, edge or wire.
- # @param theTarget The target object. It can be planar or cylindrical face.
+ # Edge and wire are acceptable if @a theTarget is a face.
+ # @param theTarget The target object. It can be planar or cylindrical face, edge or wire.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return New GEOM.GEOM_Object, containing the projection.
#
# @ref tui_projection "Example"
+ @ManageTransactions("TrsfOp")
def MakeProjection(self, theSource, theTarget, theName=None):
"""
- Create new object as projection of the given one on a 2D surface.
+ Create new object as projection of the given one on another.
Parameters:
theSource The source object for the projection. It can be a point, edge or wire.
- theTarget The target object. It can be planar or cylindrical face.
+ Edge and wire are acceptable if theTarget is a face.
+ theTarget The target object. It can be planar or cylindrical face, edge or wire.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the projection.
"""
# Example: see GEOM_TestAll.py
RaiseIfFailed("ProjectShapeCopy", self.TrsfOp)
self._autoPublish(anObj, theName, "projection")
return anObj
-
- ## Create a projection projection of the given point on a wire or an edge.
+
+ ## Create a projection of the given point on a wire or an edge.
# If there are no solutions or there are 2 or more solutions It throws an
# exception.
# @param thePoint the point to be projected.
# \n \a EdgeInWireIndex: The index of an edge in a wire.
#
# @ref tui_projection "Example"
+ @ManageTransactions("TrsfOp")
def MakeProjectionOnWire(self, thePoint, theWire, theName=None):
"""
- Create a projection projection of the given point on a wire or an edge.
+ Create a projection of the given point on a wire or an edge.
If there are no solutions or there are 2 or more solutions It throws an
exception.
-
+
Parameters:
thePoint the point to be projected.
theWire the wire. The edge is accepted as well.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
+
Returns:
[u, PointOnEdge, EdgeInWireIndex]
u: The parameter of projection point on edge.
# the shapes, obtained after each translation.
#
# @ref tui_multi_translation "Example"
+ @ManageTransactions("TrsfOp")
def MakeMultiTranslation1D(self, theObject, theVector, theStep, theNbTimes, theName=None):
"""
Translate the given object along the given vector a given number times
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing compound of all
the shapes, obtained after each translation.
# the shapes, obtained after each translation.
#
# @ref tui_multi_translation "Example"
+ @ManageTransactions("TrsfOp")
def MakeMultiTranslation2D(self, theObject, theVector1, theStep1, theNbTimes1,
theVector2, theStep2, theNbTimes2, theName=None):
"""
# shapes, obtained after each rotation.
#
# @ref tui_multi_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MultiRotate1DNbTimes (self, theObject, theAxis, theNbTimes, theName=None):
"""
Rotate the given object around the given axis a given number times.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing compound of all the
shapes, obtained after each rotation.
# shapes, obtained after each rotation.
#
# @ref tui_multi_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MultiRotate1DByStep(self, theObject, theAxis, theAngleStep, theNbTimes, theName=None):
"""
Rotate the given object around the given axis
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing compound of all the
shapes, obtained after each rotation.
# shapes, obtained after each transformation.
#
# @ref tui_multi_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MultiRotate2DNbTimes(self, theObject, theAxis, theNbTimes1, theRadialStep, theNbTimes2, theName=None):
"""
Rotate the given object around the
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing compound of all the
shapes, obtained after each transformation.
# shapes, obtained after each transformation.
#
# @ref tui_multi_rotation "Example"
+ @ManageTransactions("TrsfOp")
def MultiRotate2DByStep (self, theObject, theAxis, theAngleStep, theNbTimes1, theRadialStep, theNbTimes2, theName=None):
"""
Rotate the given object around the
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing compound of all the
shapes, obtained after each transformation.
def MakeMultiRotation2DNbTimes(self, aShape, aDir, aPoint, nbtimes1, aStep, nbtimes2, theName=None):
"""
The same, as MultiRotate2DNbTimes(), but axis is given by direction and point
-
+
Example of usage:
pz = geompy.MakeVertex(0, 0, 100)
vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
def MakeMultiRotation2DByStep(self, aShape, aDir, aPoint, anAngle, nbtimes1, aStep, nbtimes2, theName=None):
"""
The same, as MultiRotate2DByStep(), but axis is given by direction and point
-
+
Example of usage:
pz = geompy.MakeVertex(0, 0, 100)
vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
anObj = self.MultiRotate2DByStep(aShape, aVec, anAngle, nbtimes1, aStep, nbtimes2, theName)
return anObj
+ ##
+ # Compute a wire or a face that represents a projection of the source
+ # shape onto cylinder. The cylinder's coordinate system is the same
+ # as the global coordinate system.
+ #
+ # @param theObject The object to be projected. It can be either
+ # a planar wire or a face.
+ # @param theRadius The radius of the cylinder.
+ # @param theStartAngle The starting angle in radians from
+ # the cylinder's X axis around Z axis. The angle from which
+ # the projection is started.
+ # @param theAngleLength The projection length angle in radians.
+ # The angle in which to project the total length of the wire.
+ # If it is negative the projection is not scaled and natural
+ # wire length is kept for the projection.
+ # @param theAngleRotation The desired angle in radians between
+ # the tangent vector to the first curve at the first point of
+ # the theObject's projection in 2D space and U-direction of
+ # cylinder's 2D space.
+ # @param theName Object name; when specified, this parameter is used
+ # for result publication in the study. Otherwise, if automatic
+ # publication is switched on, default value is used for result name.
+ #
+ # @return New GEOM.GEOM_Object, containing the result shape. The result
+ # represents a wire or a face that represents a projection of
+ # the source shape onto a cylinder.
+ #
+ # @ref tui_projection "Example"
+ def MakeProjectionOnCylinder (self, theObject, theRadius,
+ theStartAngle=0.0, theAngleLength=-1.0,
+ theAngleRotation=0.0,
+ theName=None):
+ """
+ Compute a wire or a face that represents a projection of the source
+ shape onto cylinder. The cylinder's coordinate system is the same
+ as the global coordinate system.
+
+ Parameters:
+ theObject The object to be projected. It can be either
+ a planar wire or a face.
+ theRadius The radius of the cylinder.
+ theStartAngle The starting angle in radians from the cylinder's X axis
+ around Z axis. The angle from which the projection is started.
+ theAngleLength The projection length angle in radians. The angle in which
+ to project the total length of the wire. If it is negative the
+ projection is not scaled and natural wire length is kept for
+ the projection.
+ theAngleRotation The desired angle in radians between
+ the tangent vector to the first curve at the first
+ point of the theObject's projection in 2D space and
+ U-direction of cylinder's 2D space.
+ theName Object name; when specified, this parameter is used
+ for result publication in the study. Otherwise, if automatic
+ publication is switched on, default value is used for result name.
+
+ Returns:
+ New GEOM.GEOM_Object, containing the result shape. The result
+ represents a wire or a face that represents a projection of
+ the source shape onto a cylinder.
+ """
+ # Example: see GEOM_TestAll.py
+ flagStartAngle = False
+ if isinstance(theStartAngle,str):
+ flagStartAngle = True
+ flagAngleLength = False
+ if isinstance(theAngleLength,str):
+ flagAngleLength = True
+ flagAngleRotation = False
+ if isinstance(theAngleRotation,str):
+ flagAngleRotation = True
+ theRadius, theStartAngle, theAngleLength, theAngleRotation, Parameters = ParseParameters(
+ theRadius, theStartAngle, theAngleLength, theAngleRotation)
+ if flagStartAngle:
+ theStartAngle = theStartAngle*math.pi/180.
+ if flagAngleLength:
+ theAngleLength = theAngleLength*math.pi/180.
+ if flagAngleRotation:
+ theAngleRotation = theAngleRotation*math.pi/180.
+ anObj = self.TrsfOp.MakeProjectionOnCylinder(theObject, theRadius,
+ theStartAngle, theAngleLength, theAngleRotation)
+ RaiseIfFailed("MakeProjectionOnCylinder", self.TrsfOp)
+ anObj.SetParameters(Parameters)
+ self._autoPublish(anObj, theName, "projection")
+ return anObj
+
# end of l3_transform
## @}
## The same, as MultiRotate2DByStep(), but theAngle is in degrees.
# This method is DEPRECATED. Use MultiRotate2DByStep() instead.
+ @ManageTransactions("TrsfOp")
def MultiRotate2D(self, theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2, theName=None):
"""
The same, as MultiRotate2DByStep(), but theAngle is in degrees.
"""
The same, as MultiRotate2D(), but axis is given by direction and point
This method is DEPRECATED. Use MakeMultiRotation2DByStep instead.
-
+
Example of usage:
pz = geompy.MakeVertex(0, 0, 100)
vy = geompy.MakeVectorDXDYDZ(0, 100, 0)
#
# @ref tui_fillet "Example 1"
# \n @ref swig_MakeFilletAll "Example 2"
+ @ManageTransactions("LocalOp")
def MakeFilletAll(self, theShape, theR, theName=None):
"""
Perform a fillet on all edges of the given shape.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
- Example of usage:
+ Example of usage:
filletall = geompy.MakeFilletAll(prism, 10.)
"""
# Example: see GEOM_TestOthers.py
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_fillet "Example"
+ @ManageTransactions("LocalOp")
def MakeFillet(self, theShape, theR, theShapeType, theListShapes, theName=None):
"""
Perform a fillet on the specified edges/faces of the given shape
Note:
Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
Example of usage:
return anObj
## The same that MakeFillet() but with two Fillet Radius R1 and R2
+ @ManageTransactions("LocalOp")
def MakeFilletR1R2(self, theShape, theR1, theR2, theShapeType, theListShapes, theName=None):
"""
The same that geompy.MakeFillet but with two Fillet Radius R1 and R2
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_fillet2d "Example"
+ @ManageTransactions("LocalOp")
def MakeFillet1D(self, theShape, theR, theListOfVertexes, doIgnoreSecantVertices = True, theName=None):
"""
Perform a fillet on the specified edges of the given shape
The list of vertices could be empty,in this case fillet will done done at all vertices in wire
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
- Example of usage:
+ Example of usage:
# create wire
Wire_1 = geompy.MakeWire([Edge_12, Edge_7, Edge_11, Edge_6, Edge_1,Edge_4])
# make fillet at given wire vertices with giver radius
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_fillet2d "Example"
+ @ManageTransactions("LocalOp")
def MakeFillet2D(self, theShape, theR, theListOfVertexes, theName=None):
"""
Perform a fillet at the specified vertices of the given face/shell.
Note:
Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
Example of usage:
#
# @ref tui_chamfer "Example 1"
# \n @ref swig_MakeChamferAll "Example 2"
+ @ManageTransactions("LocalOp")
def MakeChamferAll(self, theShape, theD, theName=None):
"""
Perform a symmetric chamfer on all edges of the given shape.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
Example of usage:
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_chamfer "Example"
+ @ManageTransactions("LocalOp")
def MakeChamferEdge(self, theShape, theD1, theD2, theFace1, theFace2, theName=None):
"""
Perform a chamfer on edges, common to the specified faces,
Note:
Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
Example of usage:
# @note Global index of sub-shape can be obtained, using method GetSubShapeID().
#
# @return New GEOM.GEOM_Object, containing the result shape.
+ @ManageTransactions("LocalOp")
def MakeChamferEdgeAD(self, theShape, theD, theAngle, theFace1, theFace2, theName=None):
"""
Perform a chamfer on edges
Note:
Global index of sub-shape can be obtained, using method geompy.GetSubShapeID
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
Example of usage:
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_chamfer "Example"
+ @ManageTransactions("LocalOp")
def MakeChamferFaces(self, theShape, theD1, theD2, theFaces, theName=None):
"""
Perform a chamfer on all edges of the specified faces,
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
-
+
Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID().
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the result shape.
"""
# Example: see GEOM_TestAll.py
self._autoPublish(anObj, theName, "chamfer")
return anObj
- ## The Same that MakeChamferFaces() but with params theD is chamfer lenght and
+ ## The Same that MakeChamferFaces() but with params theD is chamfer length and
# theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
#
# @ref swig_FilletChamfer "Example"
+ @ManageTransactions("LocalOp")
def MakeChamferFacesAD(self, theShape, theD, theAngle, theFaces, theName=None):
"""
- The Same that geompy.MakeChamferFaces but with params theD is chamfer lenght and
+ The Same that geompy.MakeChamferFaces but with params theD is chamfer length and
theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
"""
flag = False
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref swig_FilletChamfer "Example"
+ @ManageTransactions("LocalOp")
def MakeChamferEdges(self, theShape, theD1, theD2, theEdges, theName=None):
"""
Perform a chamfer on edges,
with distance D1 on the first specified face (if several for one edge)
-
+
Parameters:
theShape Shape, to perform chamfer on.
theD1,theD2 Chamfer size
self._autoPublish(anObj, theName, "chamfer")
return anObj
- ## The Same that MakeChamferEdges() but with params theD is chamfer lenght and
+ ## The Same that MakeChamferEdges() but with params theD is chamfer length and
# theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
+ @ManageTransactions("LocalOp")
def MakeChamferEdgesAD(self, theShape, theD, theAngle, theEdges, theName=None):
"""
- The Same that geompy.MakeChamferEdges but with params theD is chamfer lenght and
+ The Same that geompy.MakeChamferEdges but with params theD is chamfer length and
theAngle is Angle of chamfer (angle in radians or a name of variable which defines angle in degrees)
"""
flag = False
else:
anObj = self.MakeChamferFaces(aShape,d1,d2,ListShape,theName)
return anObj
-
+
## Remove material from a solid by extrusion of the base shape on the given distance.
- # @param theInit Shape to remove material from. It must be a solid or
+ # @param theInit Shape to remove material from. It must be a solid or
# a compound made of a single solid.
# @param theBase Closed edge or wire defining the base shape to be extruded.
# @param theH Prism dimension along the normal to theBase
# @param theAngle Draft angle in degrees.
+ # @param theInvert If true material changes the direction
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the initial shape with removed material
+ # @return New GEOM.GEOM_Object, containing the initial shape with removed material
#
# @ref tui_creation_prism "Example"
- def MakeExtrudedCut(self, theInit, theBase, theH, theAngle, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakeExtrudedCut(self, theInit, theBase, theH, theAngle, theInvert=False, theName=None):
"""
Add material to a solid by extrusion of the base shape on the given distance.
theBase Closed edge or wire defining the base shape to be extruded.
theH Prism dimension along the normal to theBase
theAngle Draft angle in degrees.
+ theInvert If true material changes the direction.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
New GEOM.GEOM_Object, containing the initial shape with removed material.
"""
# Example: see GEOM_TestAll.py
- #theH,Parameters = ParseParameters(theH)
- anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, False)
+ theH,theAngle,Parameters = ParseParameters(theH,theAngle)
+ anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, False, theInvert)
RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
- #anObj.SetParameters(Parameters)
+ anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "extrudedCut")
- return anObj
-
+ return anObj
+
## Add material to a solid by extrusion of the base shape on the given distance.
- # @param theInit Shape to add material to. It must be a solid or
+ # @param theInit Shape to add material to. It must be a solid or
# a compound made of a single solid.
# @param theBase Closed edge or wire defining the base shape to be extruded.
# @param theH Prism dimension along the normal to theBase
# @param theAngle Draft angle in degrees.
+ # @param theInvert If true material changes the direction
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
#
- # @return New GEOM.GEOM_Object, containing the initial shape with added material
+ # @return New GEOM.GEOM_Object, containing the initial shape with added material
#
# @ref tui_creation_prism "Example"
- def MakeExtrudedBoss(self, theInit, theBase, theH, theAngle, theName=None):
+ @ManageTransactions("PrimOp")
+ def MakeExtrudedBoss(self, theInit, theBase, theH, theAngle, theInvert=False, theName=None):
"""
Add material to a solid by extrusion of the base shape on the given distance.
theBase Closed edge or wire defining the base shape to be extruded.
theH Prism dimension along the normal to theBase
theAngle Draft angle in degrees.
+ theInvert If true material changes the direction.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
New GEOM.GEOM_Object, containing the initial shape with added material.
"""
# Example: see GEOM_TestAll.py
- #theH,Parameters = ParseParameters(theH)
- anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, True)
+ theH,theAngle,Parameters = ParseParameters(theH,theAngle)
+ anObj = self.PrimOp.MakeDraftPrism(theInit, theBase, theH, theAngle, True, theInvert)
RaiseIfFailed("MakeExtrudedBoss", self.PrimOp)
- #anObj.SetParameters(Parameters)
+ anObj.SetParameters(Parameters)
self._autoPublish(anObj, theName, "extrudedBoss")
- return anObj
+ return anObj
# end of l3_local
## @}
## Perform an Archimde operation on the given shape with given parameters.
# The object presenting the resulting face is returned.
# @param theShape Shape to be put in water.
- # @param theWeight Weight og the shape.
+ # @param theWeight Weight of the shape.
# @param theWaterDensity Density of the water.
# @param theMeshDeflection Deflection of the mesh, using to compute the section.
# @param theName Object name; when specified, this parameter is used
# by a plane, corresponding to water level.
#
# @ref tui_archimede "Example"
+ @ManageTransactions("LocalOp")
def Archimede(self, theShape, theWeight, theWaterDensity, theMeshDeflection, theName=None):
"""
Perform an Archimde operation on the given shape with given parameters.
The object presenting the resulting face is returned.
- Parameters:
+ Parameters:
theShape Shape to be put in water.
- theWeight Weight og the shape.
+ theWeight Weight of the shape.
theWaterDensity Density of the water.
theMeshDeflection Deflection of the mesh, using to compute the section.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing a section of theShape
by a plane, corresponding to water level.
"""
## Get point coordinates
# @return [x, y, z]
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_point_coordinates_page "Example"
+ @ManageTransactions("MeasuOp")
def PointCoordinates(self,Point):
"""
Get point coordinates
# Example: see GEOM_TestMeasures.py
aTuple = self.MeasuOp.PointCoordinates(Point)
RaiseIfFailed("PointCoordinates", self.MeasuOp)
- return aTuple
-
+ return aTuple
+
## Get vector coordinates
# @return [x, y, z]
#
p1=self.GetFirstVertex(Vector)
p2=self.GetLastVertex(Vector)
-
+
X1=self.PointCoordinates(p1)
X2=self.PointCoordinates(p2)
#
# @ref tui_measurement_tools_page "Example"
def CrossProduct(self, Vector1, Vector2):
- """
+ """
Compute cross product
-
+
Returns: vector w=u^v
"""
u=self.VectorCoordinates(Vector1)
v=self.VectorCoordinates(Vector2)
w=self.MakeVectorDXDYDZ(u[1]*v[2]-u[2]*v[1], u[2]*v[0]-u[0]*v[2], u[0]*v[1]-u[1]*v[0])
-
+
return w
-
+
## Compute cross product
# @return dot product p=u.v
#
# @ref tui_measurement_tools_page "Example"
def DotProduct(self, Vector1, Vector2):
- """
+ """
Compute cross product
-
+
Returns: dot product p=u.v
"""
u=self.VectorCoordinates(Vector1)
v=self.VectorCoordinates(Vector2)
p=u[0]*v[0]+u[1]*v[1]+u[2]*v[2]
-
+
return p
## Get summarized length of all wires,
# area of surface and volume of the given shape.
# @param theShape Shape to define properties of.
+ # @param theTolerance maximal relative error of area
+ # and volume computation.
# @return [theLength, theSurfArea, theVolume]\n
# theLength: Summarized length of all wires of the given shape.\n
# theSurfArea: Area of surface of the given shape.\n
# theVolume: Volume of the given shape.
#
- # @ref tui_measurement_tools_page "Example"
- def BasicProperties(self,theShape):
+ # @ref tui_basic_properties_page "Example"
+ @ManageTransactions("MeasuOp")
+ def BasicProperties(self,theShape, theTolerance=1.e-6):
"""
Get summarized length of all wires,
area of surface and volume of the given shape.
- Parameters:
+ Parameters:
theShape Shape to define properties of.
+ theTolerance maximal relative error of area
+ and volume computation.
Returns:
[theLength, theSurfArea, theVolume]
theVolume: Volume of the given shape.
"""
# Example: see GEOM_TestMeasures.py
- aTuple = self.MeasuOp.GetBasicProperties(theShape)
+ aTuple = self.MeasuOp.GetBasicProperties(theShape, theTolerance)
RaiseIfFailed("GetBasicProperties", self.MeasuOp)
return aTuple
# Ymin,Ymax: Limits of shape along OY axis.
# Zmin,Zmax: Limits of shape along OZ axis.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_bounding_box_page "Example"
+ @ManageTransactions("MeasuOp")
def BoundingBox (self, theShape, precise=False):
"""
Get parameters of bounding box of the given shape
- Parameters:
+ Parameters:
theShape Shape to obtain bounding box of.
precise TRUE for precise computation; FALSE for fast one.
#
# @return New GEOM.GEOM_Object, containing the created box.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_bounding_box_page "Example"
+ @ManageTransactions("MeasuOp")
def MakeBoundingBox (self, theShape, precise=False, theName=None):
"""
Get bounding box of the given shape
- Parameters:
+ Parameters:
theShape Shape to obtain bounding box of.
precise TRUE for precise computation; FALSE for fast one.
theName Object name; when specified, this parameter is used
# I(1-3)(1-3): Components of the inertia matrix of the given shape.
# Ix,Iy,Iz: Moments of inertia of the given shape.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_inertia_page "Example"
+ @ManageTransactions("MeasuOp")
def Inertia(self,theShape):
"""
Get inertia matrix and moments of inertia of theShape.
- Parameters:
+ Parameters:
theShape Shape to calculate inertia of.
Returns:
# @param coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
# @param tolerance to be used (default is 1.0e-7)
# @return list_of_boolean = [res1, res2, ...]
+ @ManageTransactions("MeasuOp")
def AreCoordsInside(self, theShape, coords, tolerance=1.e-7):
"""
Get if coords are included in the shape (ST_IN or ST_ON)
-
- Parameters:
+
+ Parameters:
theShape Shape
coords list of points coordinates [x1, y1, z1, x2, y2, z2, ...]
tolerance to be used (default is 1.0e-7)
# @param theShape1,theShape2 Shapes to find minimal distance between.
# @return Value of the minimal distance between the given shapes.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_min_distance_page "Example"
+ @ManageTransactions("MeasuOp")
def MinDistance(self, theShape1, theShape2):
"""
Get minimal distance between the given shapes.
-
- Parameters:
+
+ Parameters:
theShape1,theShape2 Shapes to find minimal distance between.
- Returns:
+ Returns:
Value of the minimal distance between the given shapes.
"""
# Example: see GEOM_TestMeasures.py
# @return Value of the minimal distance between the given shapes, in form of list
# [Distance, DX, DY, DZ].
#
- # @ref swig_all_measure "Example"
+ # @ref tui_min_distance_page "Example"
+ @ManageTransactions("MeasuOp")
def MinDistanceComponents(self, theShape1, theShape2):
"""
Get minimal distance between the given shapes.
- Parameters:
+ Parameters:
theShape1,theShape2 Shapes to find minimal distance between.
- Returns:
+ Returns:
Value of the minimal distance between the given shapes, in form of list
[Distance, DX, DY, DZ]
"""
# @return The number of found solutions (-1 in case of infinite number of
# solutions) and a list of (X, Y, Z) coordinates for all couples of points.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_min_distance_page "Example"
+ @ManageTransactions("MeasuOp")
def ClosestPoints (self, theShape1, theShape2):
"""
Get closest points of the given shapes.
- Parameters:
+ Parameters:
theShape1,theShape2 Shapes to find closest points of.
- Returns:
+ Returns:
The number of found solutions (-1 in case of infinite number of
solutions) and a list of (X, Y, Z) coordinates for all couples of points.
"""
# with their orientations, otherwise the minimum angle is computed.
# @return Value of the angle between the given shapes in degrees.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_angle_page "Example"
+ @ManageTransactions("MeasuOp")
def GetAngle(self, theShape1, theShape2):
"""
Get angle between the given shapes in degrees.
- Parameters:
+ Parameters:
theShape1,theShape2 Lines or linear edges to find angle between.
Note:
If both arguments are vectors, the angle is computed in accordance
with their orientations, otherwise the minimum angle is computed.
- Returns:
+ Returns:
Value of the angle between the given shapes in degrees.
"""
# Example: see GEOM_TestMeasures.py
# with their orientations, otherwise the minimum angle is computed.
# @return Value of the angle between the given shapes in radians.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_angle_page "Example"
+ @ManageTransactions("MeasuOp")
def GetAngleRadians(self, theShape1, theShape2):
"""
Get angle between the given shapes in radians.
- Parameters:
+ Parameters:
theShape1,theShape2 Lines or linear edges to find angle between.
-
+
Note:
If both arguments are vectors, the angle is computed in accordance
with their orientations, otherwise the minimum angle is computed.
- Returns:
+ Returns:
Value of the angle between the given shapes in radians.
"""
# Example: see GEOM_TestMeasures.py
# if False, the opposite vector to the normal vector is used.
# @return Value of the angle between the given vectors in degrees.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_angle_page "Example"
+ @ManageTransactions("MeasuOp")
def GetAngleVectors(self, theShape1, theShape2, theFlag = True):
"""
Get angle between the given vectors in degrees.
- Parameters:
+ Parameters:
theShape1,theShape2 Vectors to find angle between.
theFlag If True, the normal vector is defined by the two vectors cross,
if False, the opposite vector to the normal vector is used.
- Returns:
+ Returns:
Value of the angle between the given vectors in degrees.
"""
anAngle = self.MeasuOp.GetAngleBtwVectors(theShape1, theShape2)
"""
Get angle between the given vectors in radians.
- Parameters:
+ Parameters:
theShape1,theShape2 Vectors to find angle between.
theFlag If True, the normal vector is defined by the two vectors cross,
if False, the opposite vector to the normal vector is used.
- Returns:
+ Returns:
Value of the angle between the given vectors in radians.
"""
anAngle = self.GetAngleVectors(theShape1, theShape2, theFlag)*math.pi/180.
# @return radius of curvature of \a theCurve.
#
# @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def CurveCurvatureByParam(self, theCurve, theParam):
"""
Measure curvature of a curve at a point, set by parameter.
- Parameters:
+ Parameters:
theCurve a curve.
theParam parameter.
- Returns:
+ Returns:
radius of curvature of theCurve.
"""
# Example: see GEOM_TestMeasures.py
# @return radius of curvature of \a theCurve.
#
# @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def CurveCurvatureByPoint(self, theCurve, thePoint):
"""
Measure curvature of a curve at a point.
- Parameters:
+ Parameters:
theCurve a curve.
thePoint given point.
- Returns:
- radius of curvature of theCurve.
+ Returns:
+ radius of curvature of theCurve.
"""
aCurv = self.MeasuOp.CurveCurvatureByPoint(theCurve,thePoint)
RaiseIfFailed("CurveCurvatureByPoint", self.MeasuOp)
# @return max radius of curvature of theSurf.
#
## @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def MaxSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
"""
Measure max radius of curvature of surface.
- Parameters:
+ Parameters:
theSurf the given surface.
theUParam Value of U-parameter on the referenced surface.
theVParam Value of V-parameter on the referenced surface.
-
- Returns:
+
+ Returns:
max radius of curvature of theSurf.
"""
# Example: see GEOM_TestMeasures.py
# @return max radius of curvature of theSurf.
#
## @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def MaxSurfaceCurvatureByPoint(self, theSurf, thePoint):
"""
Measure max radius of curvature of surface in the given point.
- Parameters:
+ Parameters:
theSurf the given surface.
thePoint given point.
-
- Returns:
- max radius of curvature of theSurf.
+
+ Returns:
+ max radius of curvature of theSurf.
"""
aSurf = self.MeasuOp.MaxSurfaceCurvatureByPoint(theSurf,thePoint)
RaiseIfFailed("MaxSurfaceCurvatureByPoint", self.MeasuOp)
# @param theUParam Value of U-parameter on the referenced surface.
# @param theVParam Value of V-parameter on the referenced surface.
# @return min radius of curvature of theSurf.
- #
+ #
## @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def MinSurfaceCurvatureByParam(self, theSurf, theUParam, theVParam):
"""
Measure min radius of curvature of surface.
- Parameters:
+ Parameters:
theSurf the given surface.
theUParam Value of U-parameter on the referenced surface.
theVParam Value of V-parameter on the referenced surface.
-
- Returns:
+
+ Returns:
Min radius of curvature of theSurf.
"""
aSurf = self.MeasuOp.MinSurfaceCurvatureByParam(theSurf,theUParam,theVParam)
# @return min radius of curvature of theSurf.
#
## @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def MinSurfaceCurvatureByPoint(self, theSurf, thePoint):
"""
Measure min radius of curvature of surface in the given point.
- Parameters:
+ Parameters:
theSurf the given surface.
thePoint given point.
-
- Returns:
- Min radius of curvature of theSurf.
+
+ Returns:
+ Min radius of curvature of theSurf.
"""
aSurf = self.MeasuOp.MinSurfaceCurvatureByPoint(theSurf,thePoint)
RaiseIfFailed("MinSurfaceCurvatureByPoint", self.MeasuOp)
# EdgeMin,EdgeMax: Min and max tolerances of the edges.\n
# VertMin,VertMax: Min and max tolerances of the vertices.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_tolerance_page "Example"
+ @ManageTransactions("MeasuOp")
def Tolerance(self,theShape):
"""
Get min and max tolerances of sub-shapes of theShape
- Parameters:
+ Parameters:
theShape Shape, to get tolerances of.
- Returns:
+ Returns:
[FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]
FaceMin,FaceMax: Min and max tolerances of the faces.
EdgeMin,EdgeMax: Min and max tolerances of the edges.
# @param theShape Shape to be described.
# @return Description of the given shape.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_whatis_page "Example"
+ @ManageTransactions("MeasuOp")
def WhatIs(self,theShape):
"""
Obtain description of the given shape (number of sub-shapes of each type)
return aDict
def GetCreationInformation(self, theShape):
- info = theShape.GetCreationInformation()
- # operationName
- opName = info.operationName
- if not opName: opName = "no info available"
- res = "Operation: " + opName
- # parameters
- for parVal in info.params:
- res += " \n %s = %s" % ( parVal.name, parVal.value )
+ res = ''
+ infos = theShape.GetCreationInformation()
+ for info in infos:
+ # operationName
+ opName = info.operationName
+ if not opName: opName = "no info available"
+ if res: res += "\n"
+ res += "Operation: " + opName
+ # parameters
+ for parVal in info.params:
+ res += "\n \t%s = %s" % ( parVal.name, parVal.value )
return res
## Get a point, situated at the centre of mass of theShape.
#
# @return New GEOM.GEOM_Object, containing the created point.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_center_of_mass_page "Example"
+ @ManageTransactions("MeasuOp")
def MakeCDG(self, theShape, theName=None):
"""
Get a point, situated at the centre of mass of theShape.
# @return New GEOM.GEOM_Object, containing the created vertex.
#
# @ref tui_measurement_tools_page "Example"
+ @ManageTransactions("MeasuOp")
def GetVertexByIndex(self, theShape, theIndex, theName=None):
"""
Get a vertex sub-shape by index depended with orientation.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created vertex.
"""
# Example: see GEOM_TestMeasures.py
# note: auto-publishing is done in self.GetVertexByIndex()
- anObj = self.GetVertexByIndex(theShape, 0, theName)
- RaiseIfFailed("GetFirstVertex", self.MeasuOp)
- return anObj
+ return self.GetVertexByIndex(theShape, 0, theName)
## Get the last vertex of wire/edge depended orientation.
# @param theShape Shape to find last vertex.
"""
Get the last vertex of wire/edge depended orientation.
- Parameters:
+ Parameters:
theShape Shape to find last vertex.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created vertex.
"""
# Example: see GEOM_TestMeasures.py
- nb_vert = self.ShapesOp.NumberOfSubShapes(theShape, self.ShapeType["VERTEX"])
+ nb_vert = self.NumberOfSubShapes(theShape, self.ShapeType["VERTEX"])
# note: auto-publishing is done in self.GetVertexByIndex()
- anObj = self.GetVertexByIndex(theShape, (nb_vert-1), theName)
- RaiseIfFailed("GetLastVertex", self.MeasuOp)
- return anObj
+ return self.GetVertexByIndex(theShape, (nb_vert-1), theName)
## Get a normale to the given face. If the point is not given,
# the normale is calculated at the center of mass.
# @return New GEOM.GEOM_Object, containing the created vector.
#
# @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def GetNormal(self, theFace, theOptionalPoint = None, theName=None):
"""
Get a normale to the given face. If the point is not given,
the normale is calculated at the center of mass.
-
- Parameters:
+
+ Parameters:
theFace Face to define normale of.
theOptionalPoint Point to compute the normale at.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created vector.
"""
# Example: see GEOM_TestMeasures.py
# @return If theReturnStatus is equal to 1 the description is returned.
# Otherwise doesn't return anything.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_check_shape_page "Example"
+ @ManageTransactions("MeasuOp")
def PrintShapeErrors(self, theShape, theShapeErrors, theReturnStatus = 0):
"""
Print shape errors obtained from CheckShape.
# If theReturnStatus is equal to 2 the list of error data is
# returned along with IsValid flag.
#
- # @ref tui_measurement_tools_page "Example"
+ # @ref tui_check_shape_page "Example"
+ @ManageTransactions("MeasuOp")
def CheckShape(self,theShape, theIsCheckGeom = 0, theReturnStatus = 0):
"""
Check a topology of the given shape.
- Parameters:
+ Parameters:
theShape Shape to check validity of.
theIsCheckGeom If FALSE, only the shape's topology will be checked,
if TRUE, the shape's geometry will be checked also.
If 2 IsValid flag and the list of error data
is returned.
- Returns:
+ Returns:
TRUE, if the shape "seems to be valid".
If theShape is invalid, prints a description of problem.
If theReturnStatus is equal to 1 the description is returned
## Detect self-intersections in the given shape.
# @param theShape Shape to check.
+ # @param theCheckLevel is the level of self-intersection check.
+ # Possible input values are:
+ # - GEOM.SI_V_V(0) - only V/V interferences
+ # - GEOM.SI_V_E(1) - V/V and V/E interferences
+ # - GEOM.SI_E_E(2) - V/V, V/E and E/E interferences
+ # - GEOM.SI_V_F(3) - V/V, V/E, E/E and V/F interferences
+ # - GEOM.SI_E_F(4) - V/V, V/E, E/E, V/F and E/F interferences
+ # - GEOM.SI_ALL(5) - all interferences.
# @return TRUE, if the shape contains no self-intersections.
#
- # @ref tui_measurement_tools_page "Example"
- def CheckSelfIntersections(self, theShape):
+ # @ref tui_check_self_intersections_page "Example"
+ @ManageTransactions("MeasuOp")
+ def CheckSelfIntersections(self, theShape, theCheckLevel = GEOM.SI_ALL):
"""
Detect self-intersections in the given shape.
- Parameters:
+ Parameters:
theShape Shape to check.
-
- Returns:
+ theCheckLevel is the level of self-intersection check.
+ Possible input values are:
+ - GEOM.SI_V_V(0) - only V/V interferences
+ - GEOM.SI_V_E(1) - V/V and V/E interferences
+ - GEOM.SI_E_E(2) - V/V, V/E and E/E interferences
+ - GEOM.SI_V_F(3) - V/V, V/E, E/E and V/F interferences
+ - GEOM.SI_E_F(4) - V/V, V/E, E/E, V/F and E/F interferences
+ - GEOM.SI_ALL(5) - all interferences.
+
+ Returns:
TRUE, if the shape contains no self-intersections.
"""
# Example: see GEOM_TestMeasures.py
- (IsValid, Pairs) = self.MeasuOp.CheckSelfIntersections(theShape)
+ (IsValid, Pairs) = self.MeasuOp.CheckSelfIntersections(theShape, EnumToLong(theCheckLevel))
RaiseIfFailed("CheckSelfIntersections", self.MeasuOp)
return IsValid
+ ## Detect self-intersections of the given shape with algorithm based on mesh intersections.
+ # @param theShape Shape to check.
+ # @param theDeflection Linear deflection coefficient that specifies quality of tesselation:
+ # - if \a theDeflection <= 0, default deflection 0.001 is used
+ # @param theTolerance Specifies a distance between sub-shapes used for detecting gaps:
+ # - if \a theTolerance <= 0, algorithm detects intersections (default behavior)
+ # - if \a theTolerance > 0, algorithm detects gaps
+ # @return TRUE, if the shape contains no self-intersections.
+ #
+ # @ref tui_check_self_intersections_fast_page "Example"
+ @ManageTransactions("MeasuOp")
+ def CheckSelfIntersectionsFast(self, theShape, theDeflection = 0.001, theTolerance = 0.0):
+ """
+ Detect self-intersections of the given shape with algorithm based on mesh intersections.
+
+ Parameters:
+ theShape Shape to check.
+ theDeflection Linear deflection coefficient that specifies quality of tesselation:
+ - if theDeflection <= 0, default deflection 0.001 is used
+ theTolerance Specifies a distance between shapes used for detecting gaps:
+ - if theTolerance <= 0, algorithm detects intersections (default behavior)
+ - if theTolerance > 0, algorithm detects gaps
+
+ Returns:
+ TRUE, if the shape contains no self-intersections.
+ """
+ # Example: see GEOM_TestMeasures.py
+ (IsValid, Pairs) = self.MeasuOp.CheckSelfIntersectionsFast(theShape, theDeflection, theTolerance)
+ RaiseIfFailed("CheckSelfIntersectionsFast", self.MeasuOp)
+ return IsValid
+
+ ## Check boolean and partition operations agruments.
+ # @param theShape the agrument of an operation to be checked
+ # @return TRUE if the agrument is valid for a boolean or partition
+ # operation; FALSE otherwise.
+ @ManageTransactions("MeasuOp")
+ def CheckBOPArguments(self, theShape):
+ """
+ Check boolean and partition operations agruments.
+
+ Parameters:
+ theShape the agrument of an operation to be checked
+
+ Returns:
+ TRUE if the agrument is valid for a boolean or partition
+ operation; FALSE otherwise.
+ """
+ return self.MeasuOp.CheckBOPArguments(theShape)
+
+ ## Detect intersections of the given shapes with algorithm based on mesh intersections.
+ # @param theShape1 First source object
+ # @param theShape2 Second source object
+ # @param theTolerance Specifies a distance between shapes used for detecting gaps:
+ # - if \a theTolerance <= 0, algorithm detects intersections (default behavior)
+ # - if \a theTolerance > 0, algorithm detects gaps
+ # @param theDeflection Linear deflection coefficient that specifies quality of tesselation:
+ # - if \a theDeflection <= 0, default deflection 0.001 is used
+ # @return TRUE, if there are intersections (gaps) between source shapes
+ # @return List of sub-shapes IDs from 1st shape that localize intersection.
+ # @return List of sub-shapes IDs from 2nd shape that localize intersection.
+ #
+ # @ref tui_fast_intersection_page "Example"
+ @ManageTransactions("MeasuOp")
+ def FastIntersect(self, theShape1, theShape2, theTolerance = 0.0, theDeflection = 0.001):
+ """
+ Detect intersections of the given shapes with algorithm based on mesh intersections.
+
+ Parameters:
+ theShape1 First source object
+ theShape2 Second source object
+ theTolerance Specifies a distance between shapes used for detecting gaps:
+ - if theTolerance <= 0, algorithm detects intersections (default behavior)
+ - if theTolerance > 0, algorithm detects gaps
+ theDeflection Linear deflection coefficient that specifies quality of tesselation:
+ - if theDeflection <= 0, default deflection 0.001 is used
+
+ Returns:
+ TRUE, if there are intersections (gaps) between source shapes
+ List of sub-shapes IDs from 1st shape that localize intersection.
+ List of sub-shapes IDs from 2nd shape that localize intersection.
+ """
+ # Example: see GEOM_TestMeasures.py
+ IsOk, Res1, Res2 = self.MeasuOp.FastIntersect(theShape1, theShape2, theTolerance, theDeflection)
+ RaiseIfFailed("FastIntersect", self.MeasuOp)
+ return IsOk, Res1, Res2
+
## Get position (LCS) of theShape.
#
# Origin of the LCS is situated at the shape's center of mass.
# Xx,Xy,Xz: Coordinates of shape's LCS X direction.
#
# @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def GetPosition(self,theShape):
"""
Get position (LCS) of theShape.
Axes of the LCS are obtained from shape's location or,
if the shape is a planar face, from position of its plane.
- Parameters:
+ Parameters:
theShape Shape to calculate position of.
- Returns:
+ Returns:
[Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz].
Ox,Oy,Oz: Coordinates of shape's LCS origin.
Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction.
# or \a theDoubles list depends on the kind() of the shape.
#
# @ref swig_todo "Example"
+ @ManageTransactions("MeasuOp")
def KindOfShape(self,theShape):
"""
Get kind of theShape.
-
- Parameters:
+
+ Parameters:
theShape Shape to get a kind of.
Returns:
return aKindTuple
- # end of l2_measure
- ## @}
-
- ## @addtogroup l2_import_export
- ## @{
-
- ## Import a shape from the BREP or IGES or STEP file
- # (depends on given format) with given name.
- # @param theFileName The file, containing the shape.
- # @param theFormatName Specify format for the file reading.
- # Available formats can be obtained with InsertOp.ImportTranslators() method.
- # If format 'IGES_SCALE' is used instead of 'IGES' or
- # format 'STEP_SCALE' is used instead of 'STEP',
- # length unit will be set to 'meter' and result model will be scaled.
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
+ ## Returns the string that describes if the shell is good for solid.
+ # This is a support method for MakeSolid.
#
- # @return New GEOM.GEOM_Object, containing the imported shape.
- # If material names are imported it returns the list of
- # objects. The first one is the imported object followed by
- # material groups.
- # @note Auto publishing is allowed for the shape itself. Imported
- # material groups are not automatically published.
- #
- # @ref swig_Import_Export "Example"
- def ImportFile(self, theFileName, theFormatName, theName=None):
+ # @param theShell the shell to be checked.
+ # @return Returns a string that describes the shell validity for
+ # solid construction.
+ @ManageTransactions("MeasuOp")
+ def _IsGoodForSolid(self, theShell):
"""
- Import a shape from the BREP or IGES or STEP file
- (depends on given format) with given name.
+ Returns the string that describes if the shell is good for solid.
+ This is a support method for MakeSolid.
- Parameters:
- theFileName The file, containing the shape.
- theFormatName Specify format for the file reading.
- Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
- If format 'IGES_SCALE' is used instead of 'IGES' or
- format 'STEP_SCALE' is used instead of 'STEP',
- length unit will be set to 'meter' and result model will be scaled.
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM.GEOM_Object, containing the imported shape.
- If material names are imported it returns the list of
- objects. The first one is the imported object followed by
- material groups.
- Note:
- Auto publishing is allowed for the shape itself. Imported
- material groups are not automatically published.
- """
- # Example: see GEOM_TestOthers.py
- aListObj = self.InsertOp.ImportFile(theFileName, theFormatName)
- RaiseIfFailed("ImportFile", self.InsertOp)
- aNbObj = len(aListObj)
- if aNbObj > 0:
- self._autoPublish(aListObj[0], theName, "imported")
- if aNbObj == 1:
- return aListObj[0]
- return aListObj
-
- ## Deprecated analog of ImportFile()
- def Import(self, theFileName, theFormatName, theName=None):
- """
- Deprecated analog of geompy.ImportFile, kept for backward compatibility only.
- """
- print "WARNING: Function Import is deprecated, use ImportFile instead"
- # note: auto-publishing is done in self.ImportFile()
- return self.ImportFile(theFileName, theFormatName, theName)
-
- ## Shortcut to ImportFile() for BREP format.
- # Import a shape from the BREP file with given name.
- # @param theFileName The file, containing the shape.
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return New GEOM.GEOM_Object, containing the imported shape.
- #
- # @ref swig_Import_Export "Example"
- def ImportBREP(self, theFileName, theName=None):
- """
- geompy.ImportFile(...) function for BREP format
- Import a shape from the BREP file with given name.
-
- Parameters:
- theFileName The file, containing the shape.
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM.GEOM_Object, containing the imported shape.
- """
- # Example: see GEOM_TestOthers.py
- # note: auto-publishing is done in self.ImportFile()
- return self.ImportFile(theFileName, "BREP", theName)
-
- ## Shortcut to ImportFile() for IGES format
- # Import a shape from the IGES file with given name.
- # @param theFileName The file, containing the shape.
- # @param ignoreUnits If True, file length units will be ignored (set to 'meter')
- # and result model will be scaled, if its units are not meters.
- # If False (default), file length units will be taken into account.
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return New GEOM.GEOM_Object, containing the imported shape.
- #
- # @ref swig_Import_Export "Example"
- def ImportIGES(self, theFileName, ignoreUnits = False, theName=None):
- """
- geompy.ImportFile(...) function for IGES format
-
- Parameters:
- theFileName The file, containing the shape.
- ignoreUnits If True, file length units will be ignored (set to 'meter')
- and result model will be scaled, if its units are not meters.
- If False (default), file length units will be taken into account.
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM.GEOM_Object, containing the imported shape.
- """
- # Example: see GEOM_TestOthers.py
- # note: auto-publishing is done in self.ImportFile()
- if ignoreUnits:
- return self.ImportFile(theFileName, "IGES_SCALE", theName)
- return self.ImportFile(theFileName, "IGES", theName)
-
- ## Return length unit from given IGES file
- # @param theFileName The file, containing the shape.
- # @return String, containing the units name.
- #
- # @ref swig_Import_Export "Example"
- def GetIGESUnit(self, theFileName):
- """
- Return length units from given IGES file
-
- Parameters:
- theFileName The file, containing the shape.
+ Parameter:
+ theShell the shell to be checked.
Returns:
- String, containing the units name.
+ Returns a string that describes the shell validity for
+ solid construction.
"""
- # Example: see GEOM_TestOthers.py
- aUnitName = self.InsertOp.ReadValue(theFileName, "IGES", "LEN_UNITS")
- return aUnitName
+ aDescr = self.MeasuOp.IsGoodForSolid(theShell)
+ return aDescr
+
+ # end of l2_measure
+ ## @}
+
+ ## @addtogroup l2_import_export
+ ## @{
- ## Shortcut to ImportFile() for STEP format
- # Import a shape from the STEP file with given name.
+ ## Import a shape from the BREP, IGES, STEP or other file
+ # (depends on given format) with given name.
+ #
+ # Note: this function is deprecated, it is kept for backward compatibility only
+ # Use Import<FormatName> instead, where <FormatName> is a name of desirable format to import.
+ #
# @param theFileName The file, containing the shape.
- # @param ignoreUnits If True, file length units will be ignored (set to 'meter')
- # and result model will be scaled, if its units are not meters.
- # If False (default), file length units will be taken into account.
+ # @param theFormatName Specify format for the file reading.
+ # Available formats can be obtained with InsertOp.ImportTranslators() method.
+ # If format 'IGES_SCALE' is used instead of 'IGES' or
+ # format 'STEP_SCALE' is used instead of 'STEP',
+ # length unit will be set to 'meter' and result model will be scaled.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# material groups are not automatically published.
#
# @ref swig_Import_Export "Example"
- def ImportSTEP(self, theFileName, ignoreUnits = False, theName=None):
+ @ManageTransactions("InsertOp")
+ def ImportFile(self, theFileName, theFormatName, theName=None):
"""
- geompy.ImportFile(...) function for STEP format
+ Import a shape from the BREP, IGES, STEP or other file
+ (depends on given format) with given name.
- Parameters:
+ Note: this function is deprecated, it is kept for backward compatibility only
+ Use Import<FormatName> instead, where <FormatName> is a name of desirable format to import.
+
+ Parameters:
theFileName The file, containing the shape.
- ignoreUnits If True, file length units will be ignored (set to 'meter')
- and result model will be scaled, if its units are not meters.
- If False (default), file length units will be taken into account.
+ theFormatName Specify format for the file reading.
+ Available formats can be obtained with geompy.InsertOp.ImportTranslators() method.
+ If format 'IGES_SCALE' is used instead of 'IGES' or
+ format 'STEP_SCALE' is used instead of 'STEP',
+ length unit will be set to 'meter' and result model will be scaled.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
material groups are not automatically published.
"""
# Example: see GEOM_TestOthers.py
- # note: auto-publishing is done in self.ImportFile()
- if ignoreUnits:
- return self.ImportFile(theFileName, "STEP_SCALE", theName)
- return self.ImportFile(theFileName, "STEP", theName)
-
- ## Return length unit from given IGES or STEP file
- # @param theFileName The file, containing the shape.
- # @return String, containing the units name.
- #
- # @ref swig_Import_Export "Example"
- def GetSTEPUnit(self, theFileName):
+ print """
+ WARNING: Function ImportFile is deprecated, use Import<FormatName> instead,
+ where <FormatName> is a name of desirable format for importing.
"""
- Return length units from given STEP file
-
- Parameters:
- theFileName The file, containing the shape.
+ aListObj = self.InsertOp.ImportFile(theFileName, theFormatName)
+ RaiseIfFailed("ImportFile", self.InsertOp)
+ aNbObj = len(aListObj)
+ if aNbObj > 0:
+ self._autoPublish(aListObj[0], theName, "imported")
+ if aNbObj == 1:
+ return aListObj[0]
+ return aListObj
- Returns:
- String, containing the units name.
+ ## Deprecated analog of ImportFile()
+ def Import(self, theFileName, theFormatName, theName=None):
"""
- # Example: see GEOM_TestOthers.py
- aUnitName = self.InsertOp.ReadValue(theFileName, "STEP", "LEN_UNITS")
- return aUnitName
+ Deprecated analog of geompy.ImportFile, kept for backward compatibility only.
+ """
+ # note: auto-publishing is done in self.ImportFile()
+ return self.ImportFile(theFileName, theFormatName, theName)
## Read a shape from the binary stream, containing its bounding representation (BRep).
- # @note This method will not be dumped to the python script by DumpStudy functionality.
- # @note GEOM.GEOM_Object.GetShapeStream() method can be used to obtain the shape's BRep stream.
+ #
+ # @note As the byte-stream representing the shape data can be quite large, this method
+ # is not automatically dumped to the Python script with the DumpStudy functionality;
+ # so please use this method carefully, only for strong reasons.
+ #
+ # @note GEOM.GEOM_Object.GetShapeStream() method can be used to obtain the shape's
+ # data stream.
+ #
# @param theStream The BRep binary stream.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# @return New GEOM_Object, containing the shape, read from theStream.
#
# @ref swig_Import_Export "Example"
+ @ManageTransactions("InsertOp")
def RestoreShape (self, theStream, theName=None):
"""
Read a shape from the binary stream, containing its bounding representation (BRep).
Note:
shape.GetShapeStream() method can be used to obtain the shape's BRep stream.
- Parameters:
+ Parameters:
theStream The BRep binary stream.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
New GEOM_Object, containing the shape, read from theStream.
"""
# Example: see GEOM_TestOthers.py
+ if not theStream:
+ # this is the workaround to ignore invalid case when data stream is empty
+ if int(os.getenv("GEOM_IGNORE_RESTORE_SHAPE", "0")) > 0:
+ print "WARNING: Result of RestoreShape is a NULL shape!"
+ return None
anObj = self.InsertOp.RestoreShape(theStream)
RaiseIfFailed("RestoreShape", self.InsertOp)
self._autoPublish(anObj, theName, "restored")
return anObj
## Export the given shape into a file with given name.
+ #
+ # Note: this function is deprecated, it is kept for backward compatibility only
+ # Use Export<FormatName> instead, where <FormatName> is a name of desirable format to export.
+ #
# @param theObject Shape to be stored in the file.
# @param theFileName Name of the file to store the given shape in.
# @param theFormatName Specify format for the shape storage.
# geompy.InsertOp.ExportTranslators()[0] method.
#
# @ref swig_Import_Export "Example"
+ @ManageTransactions("InsertOp")
def Export(self, theObject, theFileName, theFormatName):
"""
Export the given shape into a file with given name.
+ Note: this function is deprecated, it is kept for backward compatibility only
+ Use Export<FormatName> instead, where <FormatName> is a name of desirable format to export.
+
Parameters:
theObject Shape to be stored in the file.
theFileName Name of the file to store the given shape in.
geompy.InsertOp.ExportTranslators()[0] method.
"""
# Example: see GEOM_TestOthers.py
+ print """
+ WARNING: Function Export is deprecated, use Export<FormatName> instead,
+ where <FormatName> is a name of desirable format for exporting.
+ """
self.InsertOp.Export(theObject, theFileName, theFormatName)
if self.InsertOp.IsDone() == 0:
raise RuntimeError, "Export : " + self.InsertOp.GetErrorCode()
pass
pass
- ## Shortcut to Export() for BREP format
- #
- # @ref swig_Import_Export "Example"
- def ExportBREP(self,theObject, theFileName):
- """
- geompy.Export(...) function for BREP format
- """
- # Example: see GEOM_TestOthers.py
- return self.Export(theObject, theFileName, "BREP")
-
- ## Shortcut to Export() for IGES format
- #
- # @ref swig_Import_Export "Example"
- def ExportIGES(self,theObject, theFileName):
- """
- geompy.Export(...) function for IGES format
- """
- # Example: see GEOM_TestOthers.py
- return self.Export(theObject, theFileName, "IGES")
-
- ## Shortcut to Export() for STEP format
- #
- # @ref swig_Import_Export "Example"
- def ExportSTEP(self,theObject, theFileName):
- """
- geompy.Export(...) function for STEP format
- """
- # Example: see GEOM_TestOthers.py
- return self.Export(theObject, theFileName, "STEP")
-
# end of l2_import_export
## @}
# @return New GEOM.GEOM_Object, containing the created face.
#
# @ref tui_building_by_blocks_page "Example"
+ @ManageTransactions("BlocksOp")
def MakeQuad(self, E1, E2, E3, E4, theName=None):
"""
Create a quadrangle face from four edges. Order of Edges is not
important. It is not necessary that edges share the same vertex.
- Parameters:
+ Parameters:
E1,E2,E3,E4 Edges for the face bound.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created face.
- Example of usage:
+ Example of usage:
qface1 = geompy.MakeQuad(edge1, edge2, edge3, edge4)
"""
# Example: see GEOM_Spanner.py
# @return New GEOM.GEOM_Object, containing the created face.
#
# @ref tui_building_by_blocks_page "Example"
+ @ManageTransactions("BlocksOp")
def MakeQuad2Edges(self, E1, E2, theName=None):
"""
Create a quadrangle face on two edges.
The missing edges will be built by creating the shortest ones.
- Parameters:
+ Parameters:
E1,E2 Two opposite edges for the face.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created face.
-
+
Example of usage:
# create vertices
p1 = geompy.MakeVertex( 0., 0., 0.)
#
# @ref tui_building_by_blocks_page "Example 1"
# \n @ref swig_MakeQuad4Vertices "Example 2"
+ @ManageTransactions("BlocksOp")
def MakeQuad4Vertices(self, V1, V2, V3, V4, theName=None):
"""
Create a quadrangle face with specified corners.
The missing edges will be built by creating the shortest ones.
- Parameters:
+ Parameters:
V1,V2,V3,V4 Corner vertices for the face.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created face.
Example of usage:
#
# @ref tui_building_by_blocks_page "Example 1"
# \n @ref swig_MakeHexa "Example 2"
+ @ManageTransactions("BlocksOp")
def MakeHexa(self, F1, F2, F3, F4, F5, F6, theName=None):
"""
Create a hexahedral solid, bounded by the six given faces. Order of
faces is not important. It is not necessary that Faces share the same edge.
- Parameters:
+ Parameters:
F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the created solid.
Example of usage:
#
# @ref tui_building_by_blocks_page "Example 1"
# \n @ref swig_MakeHexa2Faces "Example 2"
+ @ManageTransactions("BlocksOp")
def MakeHexa2Faces(self, F1, F2, theName=None):
"""
Create a hexahedral solid between two given faces.
The missing faces will be built by creating the smallest ones.
- Parameters:
+ Parameters:
F1,F2 Two opposite faces for the hexahedral solid.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
# @return New GEOM.GEOM_Object, containing the found vertex.
#
# @ref swig_GetPoint "Example"
+ @ManageTransactions("BlocksOp")
def GetPoint(self, theShape, theX, theY, theZ, theEpsilon, theName=None):
"""
Get a vertex, found in the given shape by its coordinates.
- Parameters:
+ Parameters:
theShape Block or a compound of blocks.
theX,theY,theZ Coordinates of the sought vertex.
theEpsilon Maximum allowed distance between the resulting
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the found vertex.
Example of usage:
# @return New GEOM.GEOM_Object, containing the found vertex.
#
# @ref swig_GetVertexNearPoint "Example"
+ @ManageTransactions("BlocksOp")
def GetVertexNearPoint(self, theShape, thePoint, theName=None):
"""
Find a vertex of the given shape, which has minimal distance to the given point.
- Parameters:
+ Parameters:
theShape Any shape.
thePoint Point, close to the desired vertex.
theName Object name; when specified, this parameter is used
# @return New GEOM.GEOM_Object, containing the found edge.
#
# @ref swig_GetEdge "Example"
+ @ManageTransactions("BlocksOp")
def GetEdge(self, theShape, thePoint1, thePoint2, theName=None):
"""
Get an edge, found in the given shape by two given vertices.
- Parameters:
+ Parameters:
theShape Block or a compound of blocks.
thePoint1,thePoint2 Points, close to the ends of the desired edge.
theName Object name; when specified, this parameter is used
# @return New GEOM.GEOM_Object, containing the found edge.
#
# @ref swig_GetEdgeNearPoint "Example"
+ @ManageTransactions("BlocksOp")
def GetEdgeNearPoint(self, theShape, thePoint, theName=None):
"""
Find an edge of the given shape, which has minimal distance to the given point.
- Parameters:
+ Parameters:
theShape Block or a compound of blocks.
thePoint Point, close to the desired edge.
theName Object name; when specified, this parameter is used
# @return New GEOM.GEOM_Object, containing the found face.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BlocksOp")
def GetFaceByPoints(self, theShape, thePoint1, thePoint2, thePoint3, thePoint4, theName=None):
"""
Returns a face, found in the given shape by four given corner vertices.
# @return New GEOM.GEOM_Object, containing the found face.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BlocksOp")
def GetFaceByEdges(self, theShape, theEdge1, theEdge2, theName=None):
"""
Get a face of block, found in the given shape by two given edges.
# @return New GEOM.GEOM_Object, containing the found face.
#
# @ref swig_GetOppositeFace "Example"
+ @ManageTransactions("BlocksOp")
def GetOppositeFace(self, theBlock, theFace, theName=None):
"""
Find a face, opposite to the given one in the given block.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM.GEOM_Object, containing the found face.
"""
# Example: see GEOM_Spanner.py
# @return New GEOM.GEOM_Object, containing the found face.
#
# @ref swig_GetFaceNearPoint "Example"
+ @ManageTransactions("BlocksOp")
def GetFaceNearPoint(self, theShape, thePoint, theName=None):
"""
Find a face of the given shape, which has minimal distance to the given point.
# @return New GEOM.GEOM_Object, containing the found face.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BlocksOp")
def GetFaceByNormale(self, theBlock, theVector, theName=None):
"""
Find a face of block, whose outside normale has minimal angle with the given vector.
# @return New GEOM_Object, containing a group of all found shapes.
#
# @ref swig_GetShapesNearPoint "Example"
+ @ManageTransactions("BlocksOp")
def GetShapesNearPoint(self, theShape, thePoint, theShapeType, theTolerance = 1e-07, theName=None):
"""
Find all sub-shapes of type theShapeType of the given shape,
## Check, if the compound of blocks is given.
# To be considered as a compound of blocks, the
# given shape must satisfy the following conditions:
- # - Each element of the compound should be a Block (6 faces and 12 edges).
+ # - Each element of the compound should be a Block (6 faces).
+ # - Each face should be a quadrangle, i.e. it should have only 1 wire
+ # with 4 edges. If <VAR>theIsUseC1</VAR> is set to True and
+ # there are more than 4 edges in the only wire of a face,
+ # this face is considered to be quadrangle if it has 4 bounds
+ # (1 or more edge) of C1 continuity.
# - A connection between two Blocks should be an entire quadrangle face or an entire edge.
# - The compound should be connexe.
# - The glue between two quadrangle faces should be applied.
# @param theCompound The compound to check.
+ # @param theIsUseC1 Flag to check if there are 4 bounds on a face
+ # taking into account C1 continuity.
+ # @param theAngTolerance the angular tolerance to check if two neighbor
+ # edges are codirectional in the common vertex with this
+ # tolerance. This parameter is used only if
+ # <VAR>theIsUseC1</VAR> is set to True.
# @return TRUE, if the given shape is a compound of blocks.
# If theCompound is not valid, prints all discovered errors.
#
- # @ref tui_measurement_tools_page "Example 1"
+ # @ref tui_check_compound_of_blocks_page "Example 1"
# \n @ref swig_CheckCompoundOfBlocks "Example 2"
- def CheckCompoundOfBlocks(self,theCompound):
+ @ManageTransactions("BlocksOp")
+ def CheckCompoundOfBlocks(self,theCompound, theIsUseC1 = False,
+ theAngTolerance = 1.e-12):
"""
Check, if the compound of blocks is given.
To be considered as a compound of blocks, the
given shape must satisfy the following conditions:
- - Each element of the compound should be a Block (6 faces and 12 edges).
+ - Each element of the compound should be a Block (6 faces).
+ - Each face should be a quadrangle, i.e. it should have only 1 wire
+ with 4 edges. If theIsUseC1 is set to True and
+ there are more than 4 edges in the only wire of a face,
+ this face is considered to be quadrangle if it has 4 bounds
+ (1 or more edge) of C1 continuity.
- A connection between two Blocks should be an entire quadrangle face or an entire edge.
- The compound should be connexe.
- The glue between two quadrangle faces should be applied.
Parameters:
theCompound The compound to check.
+ theIsUseC1 Flag to check if there are 4 bounds on a face
+ taking into account C1 continuity.
+ theAngTolerance the angular tolerance to check if two neighbor
+ edges are codirectional in the common vertex with this
+ tolerance. This parameter is used only if
+ theIsUseC1 is set to True.
Returns:
TRUE, if the given shape is a compound of blocks.
- If theCompound is not valid, prints all discovered errors.
+ If theCompound is not valid, prints all discovered errors.
"""
# Example: see GEOM_Spanner.py
- (IsValid, BCErrors) = self.BlocksOp.CheckCompoundOfBlocks(theCompound)
+ aTolerance = -1.0
+ if theIsUseC1:
+ aTolerance = theAngTolerance
+ (IsValid, BCErrors) = self.BlocksOp.CheckCompoundOfBlocks(theCompound, aTolerance)
RaiseIfFailed("CheckCompoundOfBlocks", self.BlocksOp)
if IsValid == 0:
Descr = self.BlocksOp.PrintBCErrors(theCompound, BCErrors)
## Retrieve all non blocks solids and faces from \a theShape.
# @param theShape The shape to explore.
+ # @param theIsUseC1 Flag to check if there are 4 bounds on a face
+ # taking into account C1 continuity.
+ # @param theAngTolerance the angular tolerance to check if two neighbor
+ # edges are codirectional in the common vertex with this
+ # tolerance. This parameter is used only if
+ # <VAR>theIsUseC1</VAR> is set to True.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# publication is switched on, default value is used for result name.
# @return A tuple of two GEOM_Objects. The first object is a group of all
# non block solids (= not 6 faces, or with 6 faces, but with the
# presence of non-quadrangular faces). The second object is a
- # group of all non quadrangular faces.
+ # group of all non quadrangular faces (= faces with more then
+ # 1 wire or, if <VAR>theIsUseC1</VAR> is set to True, faces
+ # with 1 wire with not 4 edges that do not form 4 bounds of
+ # C1 continuity).
#
- # @ref tui_measurement_tools_page "Example 1"
+ # @ref tui_get_non_blocks_page "Example 1"
# \n @ref swig_GetNonBlocks "Example 2"
- def GetNonBlocks (self, theShape, theName=None):
+ @ManageTransactions("BlocksOp")
+ def GetNonBlocks (self, theShape, theIsUseC1 = False,
+ theAngTolerance = 1.e-12, theName=None):
"""
Retrieve all non blocks solids and faces from theShape.
Parameters:
theShape The shape to explore.
+ theIsUseC1 Flag to check if there are 4 bounds on a face
+ taking into account C1 continuity.
+ theAngTolerance the angular tolerance to check if two neighbor
+ edges are codirectional in the common vertex with this
+ tolerance. This parameter is used only if
+ theIsUseC1 is set to True.
theName Object name; when specified, this parameter is used
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
A tuple of two GEOM_Objects. The first object is a group of all
non block solids (= not 6 faces, or with 6 faces, but with the
presence of non-quadrangular faces). The second object is a
- group of all non quadrangular faces.
+ group of all non quadrangular faces (= faces with more then
+ 1 wire or, if <VAR>theIsUseC1</VAR> is set to True, faces
+ with 1 wire with not 4 edges that do not form 4 bounds of
+ C1 continuity).
Usage:
(res_sols, res_faces) = geompy.GetNonBlocks(myShape1)
"""
# Example: see GEOM_Spanner.py
- aTuple = self.BlocksOp.GetNonBlocks(theShape)
+ aTolerance = -1.0
+ if theIsUseC1:
+ aTolerance = theAngTolerance
+ aTuple = self.BlocksOp.GetNonBlocks(theShape, aTolerance)
RaiseIfFailed("GetNonBlocks", self.BlocksOp)
self._autoPublish(aTuple, theName, ("groupNonHexas", "groupNonQuads"))
return aTuple
# @return Improved shape.
#
# @ref swig_RemoveExtraEdges "Example"
+ @ManageTransactions("BlocksOp")
def RemoveExtraEdges(self, theShape, doUnionFaces=False, theName=None):
"""
Remove all seam and degenerated edges from theShape.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
Improved shape.
"""
# Example: see GEOM_TestOthers.py
# @return Improved shape.
#
# @ref swig_UnionFaces "Example"
+ @ManageTransactions("BlocksOp")
def UnionFaces(self, theShape, theName=None):
"""
Performs union faces of theShape.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
Improved shape.
"""
# Example: see GEOM_TestOthers.py
# @return Improved compound.
#
# @ref swig_CheckAndImprove "Example"
+ @ManageTransactions("BlocksOp")
def CheckAndImprove(self, theShape, theName=None):
"""
Check, if the given shape is a blocks compound.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
Improved compound.
"""
# Example: see GEOM_TestOthers.py
#
# @ref tui_explode_on_blocks "Example 1"
# \n @ref swig_MakeBlockExplode "Example 2"
+ @ManageTransactions("BlocksOp")
def MakeBlockExplode(self, theCompound, theMinNbFaces, theMaxNbFaces, theName=None):
"""
Get all the blocks, contained in the given compound.
Note:
If theMaxNbFaces = 0, the maximum number of faces is not restricted.
- Returns:
+ Returns:
List of GEOM.GEOM_Object, containing the retrieved blocks.
"""
# Example: see GEOM_TestOthers.py
# @return New GEOM.GEOM_Object, containing the found block.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BlocksOp")
def GetBlockNearPoint(self, theCompound, thePoint, theName=None):
"""
Find block, containing the given point inside its volume or on boundary.
# @return New GEOM.GEOM_Object, containing the found block.
#
# @ref swig_GetBlockByParts "Example"
+ @ManageTransactions("BlocksOp")
def GetBlockByParts(self, theCompound, theParts, theName=None):
"""
Find block, containing all the elements, passed as the parts, or maximum quantity of them.
for result publication in the study. Otherwise, if automatic
publication is switched on, default value is used for result name.
- Returns:
+ Returns:
New GEOM_Object, containing the found block.
"""
# Example: see GEOM_TestOthers.py
# @return List of GEOM.GEOM_Object, containing the found blocks.
#
# @ref swig_todo "Example"
+ @ManageTransactions("BlocksOp")
def GetBlocksByParts(self, theCompound, theParts, theName=None):
"""
Return all blocks, containing all the elements, passed as the parts.
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_multi_transformation "Example"
+ @ManageTransactions("BlocksOp")
def MakeMultiTransformation1D(self, Block, DirFace1, DirFace2, NbTimes, theName=None):
"""
Multi-transformate block and glue the result.
# @return New GEOM.GEOM_Object, containing the result shape.
#
# @ref tui_multi_transformation "Example"
+ @ManageTransactions("BlocksOp")
def MakeMultiTransformation2D(self, Block, DirFace1U, DirFace2U, NbTimesU,
DirFace1V, DirFace2V, NbTimesV, theName=None):
"""
## Build all possible propagation groups.
# Propagation group is a set of all edges, opposite to one (main)
# edge of this group directly or through other opposite edges.
- # Notion of Opposite Edge make sence only on quadrangle face.
+ # Notion of Opposite Edge make sense only on quadrangle face.
# @param theShape Shape to build propagation groups on.
# @param theName Object name; when specified, this parameter is used
# for result publication in the study. Otherwise, if automatic
# @return List of GEOM.GEOM_Object, each of them is a propagation group.
#
# @ref swig_Propagate "Example"
+ @ManageTransactions("BlocksOp")
def Propagate(self, theShape, theName=None):
"""
Build all possible propagation groups.
Propagation group is a set of all edges, opposite to one (main)
edge of this group directly or through other opposite edges.
- Notion of Opposite Edge make sence only on quadrangle face.
+ Notion of Opposite Edge make sense only on quadrangle face.
Parameters:
theShape Shape to build propagation groups on.
#
# @ref tui_working_with_groups_page "Example 1"
# \n @ref swig_CreateGroup "Example 2"
+ @ManageTransactions("GroupOp")
def CreateGroup(self, theMainShape, theShapeType, theName=None):
"""
Creates a new group which will store sub-shapes of theMainShape
Example of usage:
group = geompy.CreateGroup(Box, geompy.ShapeType["FACE"])
-
+
"""
# Example: see GEOM_TestOthers.py
anObj = self.GroupOp.CreateGroup(theMainShape, theShapeType)
# \note Use method GetSubShapeID() to get an unique ID of the sub-shape
#
# @ref tui_working_with_groups_page "Example"
+ @ManageTransactions("GroupOp")
def AddObject(self,theGroup, theSubShapeID):
"""
Adds a sub-object with ID theSubShapeId to the group
theSubShapeID is a sub-shape ID in the main object.
Note:
- Use method GetSubShapeID() to get an unique ID of the sub-shape
+ Use method GetSubShapeID() to get an unique ID of the sub-shape
"""
# Example: see GEOM_TestOthers.py
self.GroupOp.AddObject(theGroup, theSubShapeID)
# \note Use method GetSubShapeID() to get an unique ID of the sub-shape
#
# @ref tui_working_with_groups_page "Example"
+ @ManageTransactions("GroupOp")
def RemoveObject(self,theGroup, theSubShapeID):
"""
Removes a sub-object with ID theSubShapeId from the group
# @param theSubShapes is a list of sub-shapes to be added.
#
# @ref tui_working_with_groups_page "Example"
+ @ManageTransactions("GroupOp")
def UnionList (self,theGroup, theSubShapes):
"""
Adds to the group all the given shapes. No errors, if some shapes are alredy included.
# @param theSubShapes is a list of indices of sub-shapes to be added.
#
# @ref swig_UnionIDs "Example"
+ @ManageTransactions("GroupOp")
def UnionIDs(self,theGroup, theSubShapes):
"""
Adds to the group all the given shapes. No errors, if some shapes are alredy included.
# @param theSubShapes is a list of sub-shapes to be removed.
#
# @ref tui_working_with_groups_page "Example"
+ @ManageTransactions("GroupOp")
def DifferenceList (self,theGroup, theSubShapes):
"""
Removes from the group all the given shapes. No errors, if some shapes are not included.
# @param theSubShapes is a list of indices of sub-shapes to be removed.
#
# @ref swig_DifferenceIDs "Example"
+ @ManageTransactions("GroupOp")
def DifferenceIDs(self,theGroup, theSubShapes):
"""
Removes from the group all the given shapes. No errors, if some shapes are not included.
Parameters:
theGroup is a GEOM group from which the sub-shapes are removed.
theSubShapes is a list of indices of sub-shapes to be removed.
- """
+ """
# Example: see GEOM_TestOthers.py
self.GroupOp.DifferenceIDs(theGroup, theSubShapes)
RaiseIfFailed("DifferenceIDs", self.GroupOp)
# @return a newly created GEOM group.
#
# @ref tui_union_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def UnionGroups (self, theGroup1, theGroup2, theName=None):
"""
Union of two groups.
# @return a newly created GEOM group.
#
# @ref tui_intersect_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def IntersectGroups (self, theGroup1, theGroup2, theName=None):
"""
Intersection of two groups.
# @return a newly created GEOM group.
#
# @ref tui_cut_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def CutGroups (self, theGroup1, theGroup2, theName=None):
"""
Cut of two groups.
# @return a newly created GEOM group.
#
# @ref tui_union_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def UnionListOfGroups (self, theGList, theName=None):
"""
Union of list of groups.
# @return a newly created GEOM group.
#
# @ref tui_intersect_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def IntersectListOfGroups (self, theGList, theName=None):
"""
Cut of lists of groups.
## Cut of lists of groups.
# New group is created. It will contain only entities
- # which are present in groups listed in theGList1 but
+ # which are present in groups listed in theGList1 but
# are not present in groups from theGList2.
# @param theGList1 is a list of GEOM groups to include elements of.
# @param theGList2 is a list of GEOM groups to exclude elements of.
# @return a newly created GEOM group.
#
# @ref tui_cut_groups_anchor "Example"
+ @ManageTransactions("GroupOp")
def CutListOfGroups (self, theGList1, theGList2, theName=None):
"""
Cut of lists of groups.
New group is created. It will contain only entities
- which are present in groups listed in theGList1 but
+ which are present in groups listed in theGList1 but
are not present in groups from theGList2.
Parameters:
# @param theGroup is a GEOM group for which a list of IDs is requested
#
# @ref swig_GetObjectIDs "Example"
+ @ManageTransactions("GroupOp")
def GetObjectIDs(self,theGroup):
"""
Returns a list of sub-objects ID stored in the group
# @param theGroup is a GEOM group which type is returned.
#
# @ref swig_GetType "Example"
+ @ManageTransactions("GroupOp")
def GetType(self,theGroup):
"""
Returns a type of sub-objects stored in the group
return aType
## Convert a type of geom object from id to string value
- # @param theId is a GEOM obect type id.
+ # @param theId is a GEOM object type id.
# @return type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
# @ref swig_GetType "Example"
def ShapeIdToType(self, theId):
Convert a type of geom object from id to string value
Parameters:
- theId is a GEOM obect type id.
-
+ theId is a GEOM object type id.
+
Returns:
type of geom object (POINT, VECTOR, PLANE, LINE, TORUS, ... )
"""
# @return a GEOM object which is a main shape for theGroup
#
# @ref swig_GetMainShape "Example"
+ @ManageTransactions("GroupOp")
def GetMainShape(self,theGroup):
"""
Returns a main shape associated with the group
self.addToStudyInFather(shape, group_edges, "Group of edges with " + `min_length`
+ left_str + "length" + right_str + `max_length`)
- sg.updateObjBrowser(1)
+ sg.updateObjBrowser(True)
return group_edges
# end of l3_groups
## @}
- ## @addtogroup l4_advanced
- ## @{
-
- ## Create a T-shape object with specified caracteristics for the main
- # and the incident pipes (radius, width, half-length).
- # The extremities of the main pipe are located on junctions points P1 and P2.
- # The extremity of the incident pipe is located on junction point P3.
- # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- # the main plane of the T-shape is XOY.
- #
- # @param theR1 Internal radius of main pipe
- # @param theW1 Width of main pipe
- # @param theL1 Half-length of main pipe
- # @param theR2 Internal radius of incident pipe (R2 < R1)
- # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
- # @param theL2 Half-length of incident pipe
- #
- # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- # @param theP1 1st junction point of main pipe
- # @param theP2 2nd junction point of main pipe
- # @param theP3 Junction point of incident pipe
- #
- # @param theRL Internal radius of left thickness reduction
- # @param theWL Width of left thickness reduction
- # @param theLtransL Length of left transition part
- # @param theLthinL Length of left thin part
- #
- # @param theRR Internal radius of right thickness reduction
- # @param theWR Width of right thickness reduction
- # @param theLtransR Length of right transition part
- # @param theLthinR Length of right thin part
- #
- # @param theRI Internal radius of incident thickness reduction
- # @param theWI Width of incident thickness reduction
- # @param theLtransI Length of incident transition part
- # @param theLthinI Length of incident thin part
- #
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
- #
- # @ref tui_creation_pipetshape "Example"
- def MakePipeTShape (self, theR1, theW1, theL1, theR2, theW2, theL2,
- theHexMesh=True, theP1=None, theP2=None, theP3=None,
- theRL=0, theWL=0, theLtransL=0, theLthinL=0,
- theRR=0, theWR=0, theLtransR=0, theLthinR=0,
- theRI=0, theWI=0, theLtransI=0, theLthinI=0,
- theName=None):
- """
- Create a T-shape object with specified caracteristics for the main
- and the incident pipes (radius, width, half-length).
- The extremities of the main pipe are located on junctions points P1 and P2.
- The extremity of the incident pipe is located on junction point P3.
- If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- the main plane of the T-shape is XOY.
-
- Parameters:
- theR1 Internal radius of main pipe
- theW1 Width of main pipe
- theL1 Half-length of main pipe
- theR2 Internal radius of incident pipe (R2 < R1)
- theW2 Width of incident pipe (R2+W2 < R1+W1)
- theL2 Half-length of incident pipe
- theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- theP1 1st junction point of main pipe
- theP2 2nd junction point of main pipe
- theP3 Junction point of incident pipe
-
- theRL Internal radius of left thickness reduction
- theWL Width of left thickness reduction
- theLtransL Length of left transition part
- theLthinL Length of left thin part
-
- theRR Internal radius of right thickness reduction
- theWR Width of right thickness reduction
- theLtransR Length of right transition part
- theLthinR Length of right thin part
-
- theRI Internal radius of incident thickness reduction
- theWI Width of incident thickness reduction
- theLtransI Length of incident transition part
- theLthinI Length of incident thin part
-
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- List of GEOM_Object, containing the created shape and propagation groups.
-
- Example of usage:
- # create PipeTShape object
- pipetshape = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0)
- # create PipeTShape object with position
- pipetshape_position = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, True, P1, P2, P3)
- # create PipeTShape object with left thickness reduction
- pipetshape_thr = geompy.MakePipeTShape(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, theRL=60, theWL=20, theLtransL=40, theLthinL=20)
- """
- theR1, theW1, theL1, theR2, theW2, theL2, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI)
- if (theP1 and theP2 and theP3):
- anObj = self.AdvOp.MakePipeTShapeTRWithPosition(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theHexMesh, theP1, theP2, theP3)
- else:
- anObj = self.AdvOp.MakePipeTShapeTR(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theHexMesh)
- RaiseIfFailed("MakePipeTShape", self.AdvOp)
- if Parameters: anObj[0].SetParameters(Parameters)
- def_names = [ "pipeTShape" ] + [ "pipeTShape_grp_%d" % i for i in range(1, len(anObj)) ]
- self._autoPublish(anObj, _toListOfNames(theName, len(anObj)), def_names)
- return anObj
-
- ## Create a T-shape object with chamfer and with specified caracteristics for the main
- # and the incident pipes (radius, width, half-length). The chamfer is
- # created on the junction of the pipes.
- # The extremities of the main pipe are located on junctions points P1 and P2.
- # The extremity of the incident pipe is located on junction point P3.
- # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- # the main plane of the T-shape is XOY.
- # @param theR1 Internal radius of main pipe
- # @param theW1 Width of main pipe
- # @param theL1 Half-length of main pipe
- # @param theR2 Internal radius of incident pipe (R2 < R1)
- # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
- # @param theL2 Half-length of incident pipe
- # @param theH Height of the chamfer.
- # @param theW Width of the chamfer.
- # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- # @param theP1 1st junction point of main pipe
- # @param theP2 2nd junction point of main pipe
- # @param theP3 Junction point of incident pipe
- #
- # @param theRL Internal radius of left thickness reduction
- # @param theWL Width of left thickness reduction
- # @param theLtransL Length of left transition part
- # @param theLthinL Length of left thin part
- #
- # @param theRR Internal radius of right thickness reduction
- # @param theWR Width of right thickness reduction
- # @param theLtransR Length of right transition part
- # @param theLthinR Length of right thin part
- #
- # @param theRI Internal radius of incident thickness reduction
- # @param theWI Width of incident thickness reduction
- # @param theLtransI Length of incident transition part
- # @param theLthinI Length of incident thin part
- #
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
- #
- # @ref tui_creation_pipetshape "Example"
- def MakePipeTShapeChamfer (self, theR1, theW1, theL1, theR2, theW2, theL2,
- theH, theW, theHexMesh=True, theP1=None, theP2=None, theP3=None,
- theRL=0, theWL=0, theLtransL=0, theLthinL=0,
- theRR=0, theWR=0, theLtransR=0, theLthinR=0,
- theRI=0, theWI=0, theLtransI=0, theLthinI=0,
- theName=None):
- """
- Create a T-shape object with chamfer and with specified caracteristics for the main
- and the incident pipes (radius, width, half-length). The chamfer is
- created on the junction of the pipes.
- The extremities of the main pipe are located on junctions points P1 and P2.
- The extremity of the incident pipe is located on junction point P3.
- If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- the main plane of the T-shape is XOY.
-
- Parameters:
- theR1 Internal radius of main pipe
- theW1 Width of main pipe
- theL1 Half-length of main pipe
- theR2 Internal radius of incident pipe (R2 < R1)
- theW2 Width of incident pipe (R2+W2 < R1+W1)
- theL2 Half-length of incident pipe
- theH Height of the chamfer.
- theW Width of the chamfer.
- theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- theP1 1st junction point of main pipe
- theP2 2nd junction point of main pipe
- theP3 Junction point of incident pipe
-
- theRL Internal radius of left thickness reduction
- theWL Width of left thickness reduction
- theLtransL Length of left transition part
- theLthinL Length of left thin part
-
- theRR Internal radius of right thickness reduction
- theWR Width of right thickness reduction
- theLtransR Length of right transition part
- theLthinR Length of right thin part
-
- theRI Internal radius of incident thickness reduction
- theWI Width of incident thickness reduction
- theLtransI Length of incident transition part
- theLthinI Length of incident thin part
-
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- List of GEOM_Object, containing the created shape and propagation groups.
-
- Example of usage:
- # create PipeTShape with chamfer object
- pipetshapechamfer = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0)
- # create PipeTShape with chamfer object with position
- pipetshapechamfer_position = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0, True, P1, P2, P3)
- # create PipeTShape with chamfer object with left thickness reduction
- pipetshapechamfer_thr = geompy.MakePipeTShapeChamfer(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 20.0, 20.0, theRL=60, theWL=20, theLtransL=40, theLthinL=20)
- """
- theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theH, theW, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI)
- if (theP1 and theP2 and theP3):
- anObj = self.AdvOp.MakePipeTShapeTRChamferWithPosition(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theH, theW, theHexMesh, theP1, theP2, theP3)
- else:
- anObj = self.AdvOp.MakePipeTShapeTRChamfer(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theH, theW, theHexMesh)
- RaiseIfFailed("MakePipeTShapeChamfer", self.AdvOp)
- if Parameters: anObj[0].SetParameters(Parameters)
- def_names = [ "pipeTShape" ] + [ "pipeTShape_grp_%d" % i for i in range(1, len(anObj)) ]
- self._autoPublish(anObj, _toListOfNames(theName, len(anObj)), def_names)
- return anObj
-
- ## Create a T-shape object with fillet and with specified caracteristics for the main
- # and the incident pipes (radius, width, half-length). The fillet is
- # created on the junction of the pipes.
- # The extremities of the main pipe are located on junctions points P1 and P2.
- # The extremity of the incident pipe is located on junction point P3.
- # If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- # the main plane of the T-shape is XOY.
- # @param theR1 Internal radius of main pipe
- # @param theW1 Width of main pipe
- # @param theL1 Half-length of main pipe
- # @param theR2 Internal radius of incident pipe (R2 < R1)
- # @param theW2 Width of incident pipe (R2+W2 < R1+W1)
- # @param theL2 Half-length of incident pipe
- # @param theRF Radius of curvature of fillet.
- # @param theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- # @param theP1 1st junction point of main pipe
- # @param theP2 2nd junction point of main pipe
- # @param theP3 Junction point of incident pipe
- #
- # @param theRL Internal radius of left thickness reduction
- # @param theWL Width of left thickness reduction
- # @param theLtransL Length of left transition part
- # @param theLthinL Length of left thin part
- #
- # @param theRR Internal radius of right thickness reduction
- # @param theWR Width of right thickness reduction
- # @param theLtransR Length of right transition part
- # @param theLthinR Length of right thin part
- #
- # @param theRI Internal radius of incident thickness reduction
- # @param theWI Width of incident thickness reduction
- # @param theLtransI Length of incident transition part
- # @param theLthinI Length of incident thin part
- #
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return List of GEOM.GEOM_Object, containing the created shape and propagation groups.
- #
- # @ref tui_creation_pipetshape "Example"
- def MakePipeTShapeFillet (self, theR1, theW1, theL1, theR2, theW2, theL2,
- theRF, theHexMesh=True, theP1=None, theP2=None, theP3=None,
- theRL=0, theWL=0, theLtransL=0, theLthinL=0,
- theRR=0, theWR=0, theLtransR=0, theLthinR=0,
- theRI=0, theWI=0, theLtransI=0, theLthinI=0,
- theName=None):
- """
- Create a T-shape object with fillet and with specified caracteristics for the main
- and the incident pipes (radius, width, half-length). The fillet is
- created on the junction of the pipes.
- The extremities of the main pipe are located on junctions points P1 and P2.
- The extremity of the incident pipe is located on junction point P3.
-
- Parameters:
- If P1, P2 and P3 are not given, the center of the shape is (0,0,0) and
- the main plane of the T-shape is XOY.
- theR1 Internal radius of main pipe
- theW1 Width of main pipe
- heL1 Half-length of main pipe
- theR2 Internal radius of incident pipe (R2 < R1)
- theW2 Width of incident pipe (R2+W2 < R1+W1)
- theL2 Half-length of incident pipe
- theRF Radius of curvature of fillet.
- theHexMesh Boolean indicating if shape is prepared for hex mesh (default=True)
- theP1 1st junction point of main pipe
- theP2 2nd junction point of main pipe
- theP3 Junction point of incident pipe
-
- theRL Internal radius of left thickness reduction
- theWL Width of left thickness reduction
- theLtransL Length of left transition part
- theLthinL Length of left thin part
-
- theRR Internal radius of right thickness reduction
- theWR Width of right thickness reduction
- theLtransR Length of right transition part
- theLthinR Length of right thin part
-
- theRI Internal radius of incident thickness reduction
- theWI Width of incident thickness reduction
- theLtransI Length of incident transition part
- theLthinI Length of incident thin part
-
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- List of GEOM_Object, containing the created shape and propagation groups.
-
- Example of usage:
- # create PipeTShape with fillet object
- pipetshapefillet = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0)
- # create PipeTShape with fillet object with position
- pipetshapefillet_position = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0, True, P1, P2, P3)
- # create PipeTShape with fillet object with left thickness reduction
- pipetshapefillet_thr = geompy.MakePipeTShapeFillet(80.0, 20.0, 200.0, 50.0, 20.0, 200.0, 5.0, theRL=60, theWL=20, theLtransL=40, theLthinL=20)
- """
- theR1, theW1, theL1, theR2, theW2, theL2, theRF, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI, Parameters = ParseParameters(theR1, theW1, theL1, theR2, theW2, theL2, theRF, theRL, theWL, theLtransL, theLthinL, theRR, theWR, theLtransR, theLthinR, theRI, theWI, theLtransI, theLthinI)
- if (theP1 and theP2 and theP3):
- anObj = self.AdvOp.MakePipeTShapeTRFilletWithPosition(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theRF, theHexMesh, theP1, theP2, theP3)
- else:
- anObj = self.AdvOp.MakePipeTShapeTRFillet(theR1, theW1, theL1, theR2, theW2, theL2,
- theRL, theWL, theLtransL, theLthinL,
- theRR, theWR, theLtransR, theLthinR,
- theRI, theWI, theLtransI, theLthinI,
- theRF, theHexMesh)
- RaiseIfFailed("MakePipeTShapeFillet", self.AdvOp)
- if Parameters: anObj[0].SetParameters(Parameters)
- def_names = [ "pipeTShape" ] + [ "pipeTShape_grp_%d" % i for i in range(1, len(anObj)) ]
- self._autoPublish(anObj, _toListOfNames(theName, len(anObj)), def_names)
- return anObj
-
- ## This function allows creating a disk already divided into blocks. It
- # can be used to create divided pipes for later meshing in hexaedra.
- # @param theR Radius of the disk
- # @param theOrientation Orientation of the plane on which the disk will be built
- # 1 = XOY, 2 = OYZ, 3 = OZX
- # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return New GEOM_Object, containing the created shape.
- #
- # @ref tui_creation_divideddisk "Example"
- def MakeDividedDisk(self, theR, theOrientation, thePattern, theName=None):
- """
- Creates a disk, divided into blocks. It can be used to create divided pipes
- for later meshing in hexaedra.
-
- Parameters:
- theR Radius of the disk
- theOrientation Orientation of the plane on which the disk will be built:
- 1 = XOY, 2 = OYZ, 3 = OZX
- thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM_Object, containing the created shape.
- """
- theR, Parameters = ParseParameters(theR)
- anObj = self.AdvOp.MakeDividedDisk(theR, 67.0, theOrientation, thePattern)
- RaiseIfFailed("MakeDividedDisk", self.AdvOp)
- if Parameters: anObj.SetParameters(Parameters)
- self._autoPublish(anObj, theName, "dividedDisk")
- return anObj
-
- ## This function allows creating a disk already divided into blocks. It
- # can be used to create divided pipes for later meshing in hexaedra.
- # @param theCenter Center of the disk
- # @param theVector Normal vector to the plane of the created disk
- # @param theRadius Radius of the disk
- # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return New GEOM_Object, containing the created shape.
- #
- # @ref tui_creation_divideddisk "Example"
- def MakeDividedDiskPntVecR(self, theCenter, theVector, theRadius, thePattern, theName=None):
- """
- Creates a disk already divided into blocks. It can be used to create divided pipes
- for later meshing in hexaedra.
-
- Parameters:
- theCenter Center of the disk
- theVector Normal vector to the plane of the created disk
- theRadius Radius of the disk
- thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM_Object, containing the created shape.
- """
- theRadius, Parameters = ParseParameters(theRadius)
- anObj = self.AdvOp.MakeDividedDiskPntVecR(theCenter, theVector, theRadius, 67.0, thePattern)
- RaiseIfFailed("MakeDividedDiskPntVecR", self.AdvOp)
- if Parameters: anObj.SetParameters(Parameters)
- self._autoPublish(anObj, theName, "dividedDisk")
- return anObj
-
- ## Builds a cylinder prepared for hexa meshes
- # @param theR Radius of the cylinder
- # @param theH Height of the cylinder
- # @param thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- #
- # @return New GEOM_Object, containing the created shape.
- #
- # @ref tui_creation_dividedcylinder "Example"
- def MakeDividedCylinder(self, theR, theH, thePattern, theName=None):
- """
- Builds a cylinder prepared for hexa meshes
-
- Parameters:
- theR Radius of the cylinder
- theH Height of the cylinder
- thePattern Division pattern. It can be GEOM.SQUARE or GEOM.HEXAGON
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM_Object, containing the created shape.
- """
- theR, theH, Parameters = ParseParameters(theR, theH)
- anObj = self.AdvOp.MakeDividedCylinder(theR, theH, thePattern)
- RaiseIfFailed("MakeDividedCylinder", self.AdvOp)
- if Parameters: anObj.SetParameters(Parameters)
- self._autoPublish(anObj, theName, "dividedCylinder")
- return anObj
-
- ## Create a surface from a cloud of points
- # @param thelPoints list of points. Compounds of points are
- # accepted as well.
- # @param theNbMax maximum number of Bezier pieces in the resulting
- # surface.
- # @param theDegMax maximum degree of the resulting BSpline surface.
- # @param theDMax 3D tolerance of initial approximation.
- # @param theName Object name; when specified, this parameter is used
- # for result publication in the study. Otherwise, if automatic
- # publication is switched on, default value is used for result name.
- # @return New GEOM_Object, containing the created shape.
- # @note 3D tolerance of initial approximation represents a tolerance of
- # initial plate surface approximation. If this parameter is equal
- # to 0 (default value) it is computed. In this case an error of
- # initial plate surface computation is used as the approximation
- # tolerance. This error represents a maximal distance between
- # computed plate surface and given points.
- #
- # @ref tui_creation_smoothingsurface "Example"
- def MakeSmoothingSurface(self, thelPoints, theNbMax=2, theDegMax=8,
- theDMax=0.0, theName=None):
- """
- Create a surface from a cloud of points
-
- Parameters:
- thelPoints list of points. Compounds of points are
- accepted as well.
- theNbMax maximum number of Bezier pieces in the resulting
- surface.
- theDegMax maximum degree of the resulting BSpline surface.
- theDMax 3D tolerance of initial approximation.
- theName Object name; when specified, this parameter is used
- for result publication in the study. Otherwise, if automatic
- publication is switched on, default value is used for result name.
-
- Returns:
- New GEOM_Object, containing the created shape.
-
- Note:
- 3D tolerance of initial approximation represents a tolerance of
- initial plate surface approximation. If this parameter is equal
- to 0 (default value) it is computed. In this case an error of
- initial plate surface computation is used as the approximation
- tolerance. This error represents a maximal distance between
- computed plate surface and given points.
- """
- anObj = self.AdvOp.MakeSmoothingSurface(thelPoints, theNbMax,
- theDegMax, theDMax)
- RaiseIfFailed("MakeSmoothingSurface", self.AdvOp)
- self._autoPublish(anObj, theName, "smoothing")
- return anObj
-
- ## Export a shape to XAO format
- # @param shape The shape to export
- # @param groups The list of groups to export
- # @param fields The list of fields to export
- # @param author The author of the export
- # @param fileName The name of the file to export
- # @return boolean
- #
- # @ref tui_exportxao "Example"
- def ExportXAO(self, shape, groups, fields, author, fileName):
- res = self.InsertOp.ExportXAO(shape, groups, fields, author, fileName)
- RaiseIfFailed("ExportXAO", self.InsertOp)
- return res
-
- ## Import a shape from XAO format
- # @param shape Shape to export
- # @param fileName The name of the file to import
- # @return tuple (res, shape, subShapes, groups, fields)
- # res Flag indicating if the import was successful
- # shape The imported shape
- # subShapes The list of imported subShapes
- # groups The list of imported groups
- # fields The list of imported fields
- #
- # @ref tui_importxao "Example"
- def ImportXAO(self, fileName):
- res = self.InsertOp.ImportXAO(fileName)
- RaiseIfFailed("ImportXAO", self.InsertOp)
- return res
-
#@@ insert new functions before this line @@ do not remove this line @@#
- # end of l4_advanced
- ## @}
-
## Create a copy of the given object
#
# @param theOriginal geometry object for copy
#
# @ingroup l1_geomBuilder_auxiliary
# @ref swig_MakeCopy "Example"
+ @ManageTransactions("InsertOp")
def MakeCopy(self, theOriginal, theName=None):
"""
Create a copy of the given object
# @param Path a path to the texture file
# @return unique texture identifier
# @ingroup l1_geomBuilder_auxiliary
+ @ManageTransactions("InsertOp")
def LoadTexture(self, Path):
"""
Load marker texture from the file
-
+
Parameters:
Path a path to the texture file
-
+
Returns:
unique texture identifier
"""
## Get internal name of the object based on its study entry
# @note This method does not provide an unique identifier of the geometry object.
- # @note This is internal function of GEOM component, though it can be used outside it for
+ # @note This is internal function of GEOM component, though it can be used outside it for
# appropriate reason (e.g. for identification of geometry object).
# @param obj geometry object
# @return unique object identifier
"""
Get internal name of the object based on its study entry.
Note: this method does not provide an unique identifier of the geometry object.
- It is an internal function of GEOM component, though it can be used outside GEOM for
+ It is an internal function of GEOM component, though it can be used outside GEOM for
appropriate reason (e.g. for identification of geometry object).
Parameters:
if entry is not None:
lst = entry.split(":")
if len(lst) > 0:
- ID = lst[-1] # -1 means last item in the list
+ ID = lst[-1] # -1 means last item in the list
return "GEOM_" + ID
return ID
-
-
+
+
## Add marker texture. @a Width and @a Height parameters
# specify width and height of the texture in pixels.
# @param RowData if @c True, @a Texture data are packed in the byte stream
# @return unique texture identifier
# @ingroup l1_geomBuilder_auxiliary
+ @ManageTransactions("InsertOp")
def AddTexture(self, Width, Height, Texture, RowData=False):
"""
Add marker texture. Width and Height parameters
RaiseIfFailed("AddTexture", self.InsertOp)
return ID
+ ## Transfer not topological data from one GEOM object to another.
+ #
+ # @param theObjectFrom the source object of non-topological data
+ # @param theObjectTo the destination object of non-topological data
+ # @param theFindMethod method to search sub-shapes of theObjectFrom
+ # in shape theObjectTo. Possible values are: GEOM.FSM_GetInPlace,
+ # GEOM.FSM_GetInPlaceByHistory and GEOM.FSM_GetInPlace_Old.
+ # Other values of GEOM.find_shape_method are not supported.
+ #
+ # @return True in case of success; False otherwise.
+ #
+ # @ingroup l1_geomBuilder_auxiliary
+ #
+ # @ref swig_TransferData "Example"
+ @ManageTransactions("InsertOp")
+ def TransferData(self, theObjectFrom, theObjectTo,
+ theFindMethod=GEOM.FSM_GetInPlace):
+ """
+ Transfer not topological data from one GEOM object to another.
+
+ Parameters:
+ theObjectFrom the source object of non-topological data
+ theObjectTo the destination object of non-topological data
+ theFindMethod method to search sub-shapes of theObjectFrom
+ in shape theObjectTo. Possible values are:
+ GEOM.FSM_GetInPlace, GEOM.FSM_GetInPlaceByHistory
+ and GEOM.FSM_GetInPlace_Old. Other values of
+ GEOM.find_shape_method are not supported.
+
+ Returns:
+ True in case of success; False otherwise.
+
+ # Example: see GEOM_TestOthers.py
+ """
+ # Example: see GEOM_TestAll.py
+ isOk = self.InsertOp.TransferData(theObjectFrom,
+ theObjectTo, theFindMethod)
+ RaiseIfFailed("TransferData", self.InsertOp)
+ return isOk
+
## Creates a new folder object. It is a container for any GEOM objects.
# @param Name name of the container
- # @param Father parent object. If None,
+ # @param Father parent object. If None,
# folder under 'Geometry' root object will be created.
# @return a new created folder
# @ingroup l1_publish_data
def NewFolder(self, Name, Father=None):
"""
Create a new folder object. It is an auxiliary container for any GEOM objects.
-
+
Parameters:
Name name of the container
- Father parent object. If None,
+ Father parent object. If None,
folder under 'Geometry' root object will be created.
-
+
Returns:
a new created folder
"""
def PutToFolder(self, Object, Folder):
"""
Move object to the specified folder
-
+
Parameters:
Object object to move
Folder target folder
def PutListToFolder(self, ListOfSO, Folder):
"""
Move list of objects to the specified folder
-
+
Parameters:
ListOfSO list of objects to move
Folder target folder
# 0 - VERTEX, 1 - EDGE, 2 - FACE, 3 - SOLID, -1 - whole shape
# @param componentNames names of components
# @return a created field
+ @ManageTransactions("FieldOp")
def CreateField(self, shape, name, type, dimension, componentNames):
"""
Creates a field
dimension dimension of the shape the field lies on
0 - VERTEX, 1 - EDGE, 2 - FACE, 3 - SOLID, -1 - whole shape
componentNames names of components
-
+
Returns:
a created field
"""
return
## Returns number of fields on a shape
+ @ManageTransactions("FieldOp")
def CountFields(self, shape):
"Returns number of fields on a shape"
nb = self.FieldOp.CountFields( shape )
return nb
## Returns all fields on a shape
+ @ManageTransactions("FieldOp")
def GetFields(self, shape):
"Returns all fields on a shape"
ff = self.FieldOp.GetFields( shape )
return ff
## Returns a field on a shape by its name
+ @ManageTransactions("FieldOp")
def GetField(self, shape, name):
"Returns a field on a shape by its name"
f = self.FieldOp.GetField( shape, name )
return self.field.GetComponents(self)
## Adds a time step to the field
- # @param step the time step number futher used as the step identifier
+ # @param step the time step number further used as the step identifier
# @param stamp the time step time
# @param values the values of the time step
def addStep(self, step, stamp, values):
assert isinstance(geom,geomBuilder), "Geom engine class is %s but should be geomBuilder.geomBuilder. Import geomBuilder before creating the instance."%geom.__class__
geom.init_geom(study)
return geom
+
+
+# Register methods from the plug-ins in the geomBuilder class
+plugins_var = os.environ.get( "GEOM_PluginsList" )
+
+plugins = None
+if plugins_var is not None:
+ plugins = plugins_var.split( ":" )
+ plugins=filter(lambda x: len(x)>0, plugins)
+if plugins is not None:
+ for pluginName in plugins:
+ pluginBuilderName = pluginName + "Builder"
+ try:
+ exec( "from salome.%s.%s import *" % (pluginName, pluginBuilderName))
+ except Exception, e:
+ from salome_utils import verbose
+ print "Exception while loading %s: %s" % ( pluginBuilderName, e )
+ continue
+ exec( "from salome.%s import %s" % (pluginName, pluginBuilderName))
+ plugin = eval( pluginBuilderName )
+
+ # add methods from plugin module to the geomBuilder class
+ for k in dir( plugin ):
+ if k[0] == '_': continue
+ method = getattr( plugin, k )
+ if type( method ).__name__ == 'function':
+ if not hasattr( geomBuilder, k ):
+ setattr( geomBuilder, k, method )
+ pass
+ pass
+ del pluginName
+ pass
+ pass
