gg = ImportComponentGUI("GEOM")
-"""
+def SubShapeName(aSubObj, aMainObj):
+ """
* Get name for sub-shape aSubObj of shape aMainObj
* Example: see GEOM_TestAll.py
-"""
-def SubShapeName(aSubObj, aMainObj):
+ """
aSubId = orb.object_to_string(aSubObj)
aMainId = orb.object_to_string(aMainObj)
index = gg.getIndexTopology(aSubId, aMainId)
name = gg.getShapeTypeString(aSubId) + "_%d"%(index)
return name
-"""
+def addToStudy(aShape, aName):
+ """
* Publish in study aShape with name aName
* Example: see GEOM_TestAll.py
-"""
-def addToStudy(aShape, aName):
+ """
try:
aSObject = geom.AddInStudy(myStudy, aShape, aName, None)
except:
return ""
return aShape.GetStudyEntry()
-"""
+def addToStudyInFather(aFather, aShape, aName):
+ """
* Publish in study aShape with name aName as sub-object of previously published aFather
* Example: see GEOM_TestAll.py
-"""
-def addToStudyInFather(aFather, aShape, aName):
+ """
try:
aSObject = geom.AddInStudy(myStudy, aShape, aName, aFather)
except:
# Basic primitives
# -----------------------------------------------------------------------------
-"""
+def MakeVertex(theX, theY, theZ):
+ """
* Create point by three coordinates.
* \param theX The X coordinate of the point.
* \param theY The Y coordinate of the point.
* \return New GEOM_Object, containing the created point.
* Example: see GEOM_TestAll.py
-"""
-def MakeVertex(theX, theY, theZ):
+ """
anObj = BasicOp.MakePointXYZ(theX, theY, theZ)
if BasicOp.IsDone() == 0:
print "MakePointXYZ : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeVertexWithRef(theReference, theX, theY, theZ):
+ """
* Create a point, distant from the referenced point
* on the given distances along the coordinate axes.
* \param theReference The referenced point.
* \return New GEOM_Object, containing the created point.
* Example: see GEOM_TestAll.py
-"""
-def MakeVertexWithRef(theReference, theX, theY, theZ):
+ """
anObj = BasicOp.MakePointWithReference(theReference, theX, theY, theZ)
if BasicOp.IsDone() == 0:
print "MakePointWithReference : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeVertexOnCurve(theRefCurve, theParameter):
+ """
* 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.
* \return New GEOM_Object, containing the created point.
* Example: see GEOM_TestAll.py
-"""
-def MakeVertexOnCurve(theRefCurve, theParameter):
+ """
anObj = BasicOp.MakePointOnCurve(theRefCurve, theParameter)
if BasicOp.IsDone() == 0:
print "MakePointOnCurve : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeVectorDXDYDZ(theDX, theDY, theDZ):
+ """
* Create a vector with the given components.
* \param theDX X component of the vector.
* \param theDY Y component of the vector.
* \return New GEOM_Object, containing the created vector.
* Example: see GEOM_TestAll.py
-"""
-def MakeVectorDXDYDZ(theDX, theDY, theDZ):
+ """
anObj = BasicOp.MakeVectorDXDYDZ(theDX, theDY, theDZ)
if BasicOp.IsDone() == 0:
print "MakeVectorDXDYDZ : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeVector(thePnt1, thePnt2):
+ """
* Create a vector between two points.
* \param thePnt1 Start point for the vector.
* \param thePnt2 End point for the vector.
* \return New GEOM_Object, containing the created vector.
* Example: see GEOM_TestAll.py
-"""
-def MakeVector(thePnt1, thePnt2):
+ """
anObj = BasicOp.MakeVectorTwoPnt(thePnt1, thePnt2)
if BasicOp.IsDone() == 0:
print "MakeVectorTwoPnt : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeLine(thePnt, theDir):
+ """
* Create a line, passing through the given point
* and parrallel to the given direction
* \param thePnt Point. The resulting line will pass through it.
* \return New GEOM_Object, containing the created line.
* Example: see GEOM_TestAll.py
-"""
-def MakeLine(thePnt, theDir):
+ """
anObj = BasicOp.MakeLine(thePnt, theDir)
if BasicOp.IsDone() == 0:
print "MakeLine : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeLineTwoPnt(thePnt1, thePnt2):
+ """
* Create a line, passing through the given points
* \param thePnt1 First of two points, defining the line.
* \param thePnt2 Second of two points, defining the line.
* \return New GEOM_Object, containing the created line.
* Example: see GEOM_TestAll.py
-"""
-def MakeLineTwoPnt(thePnt1, thePnt2):
+ """
anObj = BasicOp.MakeLineTwoPnt(thePnt1, thePnt2)
if BasicOp.IsDone() == 0:
print "MakeLineTwoPnt : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakePlane(thePnt, theVec, theTrimSize):
+ """
* Create a plane, passing through the given point
* and normal to the given vector.
* \param thePnt Point, the plane has to pass through.
* \return New GEOM_Object, containing the created plane.
* Example: see GEOM_TestAll.py
-"""
-def MakePlane(thePnt, theVec, theTrimSize):
+ """
anObj = BasicOp.MakePlanePntVec(thePnt, theVec, theTrimSize)
if BasicOp.IsDone() == 0:
print "MakePlanePntVec : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakePlaneThreePnt(thePnt1, thePnt2, thePnt3, theTrimSize):
+ """
* Create a plane, passing through the three given points
* \param thePnt1 First of three points, defining the plane.
* \param thePnt2 Second of three points, defining the plane.
* \return New GEOM_Object, containing the created plane.
* Example: see GEOM_TestAll.py
-"""
-def MakePlaneThreePnt(thePnt1, thePnt2, thePnt3, theTrimSize):
+ """
anObj = BasicOp.MakePlaneThreePnt(thePnt1, thePnt2, thePnt3, theTrimSize)
if BasicOp.IsDone() == 0:
print "MakePlaneThreePnt : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakePlaneFace(theFace, theTrimSize):
+ """
* Create a plane, similar to the existing one, but with another size of representing face.
* \param theFace Referenced plane.
* \param theTrimSize New half size of a side of quadrangle face, representing the plane.
* \return New GEOM_Object, containing the created plane.
* Example: see GEOM_TestAll.py
-"""
-def MakePlaneFace(theFace, theTrimSize):
+ """
anObj = BasicOp.MakePlaneFace(theFace, theTrimSize)
if BasicOp.IsDone() == 0:
print "MakePlaneFace : ", BasicOp.GetErrorCode()
return anObj
-"""
+def MakeMarker(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ):
+ """
* Create a local coordinate system.
* \param OX,OY,OZ Three coordinates of coordinate system origin.
* \param XDX,XDY,XDZ Three components of OX direction
* \return New GEOM_Object, containing the created coordinate system.
* Example: see GEOM_TestAll.py
-"""
-def MakeMarker(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ):
+ """
anObj = BasicOp.MakeMarker(OX,OY,OZ, XDX,XDY,XDZ, YDX,YDY,YDZ)
if BasicOp.IsDone() == 0:
print "MakeMarker : ", BasicOp.GetErrorCode()
# Curves
# -----------------------------------------------------------------------------
-"""
+def MakeArc(thePnt1, thePnt2, thePnt3):
+ """
* Create an arc of circle, passing through three given points.
* \param thePnt1 Start point of the arc.
* \param thePnt2 Middle point of the arc.
* \return New GEOM_Object, containing the created arc.
* Example: see GEOM_TestAll.py
-"""
-def MakeArc(thePnt1, thePnt2, thePnt3):
+ """
anObj = CurvesOp.MakeArc(thePnt1, thePnt2, thePnt3)
if CurvesOp.IsDone() == 0:
print "MakeArc : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeCircle(thePnt, theVec, theR):
+ """
* Create a circle with given center, normal vector and radius.
* \param thePnt Circle center.
* \param theVec Vector, normal to the plane of the circle.
* \return New GEOM_Object, containing the created circle.
* Example: see GEOM_TestAll.py
-"""
-def MakeCircle(thePnt, theVec, theR):
+ """
anObj = CurvesOp.MakeCirclePntVecR(thePnt, theVec, theR)
if CurvesOp.IsDone() == 0:
print "MakeCirclePntVecR : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeCircleThreePnt(thePnt1, thePnt2, thePnt3):
+ """
* Create a circle, passing through three given points
* \param thePnt1,thePnt2,thePnt3 Points, defining the circle.
* \return New GEOM_Object, containing the created circle.
* Example: see GEOM_TestAll.py
-"""
-def MakeCircleThreePnt(thePnt1, thePnt2, thePnt3):
+ """
anObj = CurvesOp.MakeCircleThreePnt(thePnt1, thePnt2, thePnt3)
if CurvesOp.IsDone() == 0:
print "MakeCircleThreePnt : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeEllipse(thePnt, theVec, theRMajor, theRMinor):
+ """
* Create an ellipse with given center, normal vector and radiuses.
* \param thePnt Ellipse center.
* \param theVec Vector, normal to the plane of the ellipse.
* \return New GEOM_Object, containing the created ellipse.
* Example: see GEOM_TestAll.py
-"""
-def MakeEllipse(thePnt, theVec, theRMajor, theRMinor):
+ """
anObj = CurvesOp.MakeEllipse(thePnt, theVec, theRMajor, theRMinor)
if CurvesOp.IsDone() == 0:
print "MakeEllipse : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakePolyline(thePoints):
+ """
* Create a polyline on the set of points.
* \param thePoints Sequence of points for the polyline.
* \return New GEOM_Object, containing the created polyline.
* Example: see GEOM_TestAll.py
-"""
-def MakePolyline(thePoints):
+ """
anObj = CurvesOp.MakePolyline(thePoints)
if CurvesOp.IsDone() == 0:
print "MakePolyline : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeBezier(thePoints):
+ """
* Create bezier curve on the set of points.
* \param thePoints Sequence of points for the bezier curve.
* \return New GEOM_Object, containing the created bezier curve.
* Example: see GEOM_TestAll.py
-"""
-def MakeBezier(thePoints):
+ """
anObj = CurvesOp.MakeSplineBezier(thePoints)
if CurvesOp.IsDone() == 0:
print "MakeSplineBezier : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeInterpol(thePoints):
+ """
* Create B-Spline curve on the set of points.
* \param thePoints Sequence of points for the B-Spline curve.
* \return New GEOM_Object, containing the created B-Spline curve.
* Example: see GEOM_TestAll.py
-"""
-def MakeInterpol(thePoints):
+ """
anObj = CurvesOp.MakeSplineInterpolation(thePoints)
if CurvesOp.IsDone() == 0:
print "MakeSplineInterpolation : ", CurvesOp.GetErrorCode()
return anObj
-"""
+def MakeSketcher(theCommand, theWorkingPlane = [0,0,0, 0,0,1, 1,0,0]):
+ """
* Create a sketcher (wire or face), following the textual description,
* passed through \a theCommand argument. \n
* Edges of the resulting wire or face will be arcs of circles and/or linear segments. \n
* \return New GEOM_Object, containing the created wire.
* Example: see GEOM_TestAll.py
-"""
-def MakeSketcher(theCommand, theWorkingPlane = [0,0,0, 0,0,1, 1,0,0]):
+ """
anObj = CurvesOp.MakeSketcher(theCommand, theWorkingPlane)
if CurvesOp.IsDone() == 0:
print "MakeSketcher : ", CurvesOp.GetErrorCode()
# Create 3D Primitives
# -----------------------------------------------------------------------------
-"""
+def MakeBox(x1,y1,z1,x2,y2,z2):
+ """
* Create a box by coordinates of two opposite vertices.
* Example: see GEOM_TestAll.py
-"""
-def MakeBox(x1,y1,z1,x2,y2,z2):
+ """
pnt1 = MakeVertex(x1,y1,z1)
pnt2 = MakeVertex(x2,y2,z2)
return MakeBoxTwoPnt(pnt1,pnt2)
-"""
+def MakeBoxDXDYDZ(theDX, theDY, theDZ):
+ """
* Create a box with specified dimensions along the coordinate axes
* and with edges, parallel to the coordinate axes.
* Center of the box will be at point (DX/2, DY/2, DZ/2).
* \return New GEOM_Object, containing the created box.
* Example: see GEOM_TestAll.py
-"""
-def MakeBoxDXDYDZ(theDX, theDY, theDZ):
+ """
anObj = PrimOp.MakeBoxDXDYDZ(theDX, theDY, theDZ)
if PrimOp.IsDone() == 0:
print "MakeBoxDXDYDZ : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeBoxTwoPnt(thePnt1, thePnt2):
+ """
* Create a box with two specified opposite vertices,
* and with edges, parallel to the coordinate axes
* \param thePnt1 First of two opposite vertices.
* \return New GEOM_Object, containing the created box.
* Example: see GEOM_TestAll.py
-"""
-def MakeBoxTwoPnt(thePnt1, thePnt2):
+ """
anObj = PrimOp.MakeBoxTwoPnt(thePnt1, thePnt2)
if PrimOp.IsDone() == 0:
print "MakeBoxTwoPnt : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeCylinder(thePnt, theAxis, theR, theH):
+ """
* Create a cylinder with given base point, axis, radius and height.
* \param thePnt Central point of cylinder base.
* \param theAxis Cylinder axis.
* \return New GEOM_Object, containing the created cylinder.
* Example: see GEOM_TestAll.py
-"""
-def MakeCylinder(thePnt, theAxis, theR, theH):
+ """
anObj = PrimOp.MakeCylinderPntVecRH(thePnt, theAxis, theR, theH)
if PrimOp.IsDone() == 0:
print "MakeCylinderPntVecRH : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeCylinderRH(theR, theH):
+ """
* Create a cylinder with given radius and height at
* the origin of coordinate system. Axis of the cylinder
* will be collinear to the OZ axis of the coordinate system.
* \return New GEOM_Object, containing the created cylinder.
* Example: see GEOM_TestAll.py
-"""
-def MakeCylinderRH(theR, theH):
+ """
anObj = PrimOp.MakeCylinderRH(theR, theH)
if PrimOp.IsDone() == 0:
print "MakeCylinderRH : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeSpherePntR(thePnt, theR):
+ """
* Create a sphere with given center and radius.
* \param thePnt Sphere center.
* \param theR Sphere radius.
* \return New GEOM_Object, containing the created sphere.
* Example: see GEOM_TestAll.py
-"""
-def MakeSpherePntR(thePnt, theR):
+ """
anObj = PrimOp.MakeSpherePntR(thePnt, theR)
if PrimOp.IsDone() == 0:
print "MakeSpherePntR : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeSphere(x, y, z, theR):
+ """
* Create a sphere with given center and radius.
* \param x,y,z Coordinates of sphere center.
* \param theR Sphere radius.
* \return New GEOM_Object, containing the created sphere.
* Example: see GEOM_TestAll.py
-"""
-def MakeSphere(x, y, z, theR):
+ """
point = MakeVertex(x, y, z)
anObj = MakeSpherePntR(point, theR)
return anObj
-"""
+def MakeSphereR(theR):
+ """
* Create a sphere with given radius at the origin of coordinate system.
* \param theR Sphere radius.
* \return New GEOM_Object, containing the created sphere.
* Example: see GEOM_TestAll.py
-"""
-def MakeSphereR(theR):
+ """
anObj = PrimOp.MakeSphereR(theR)
if PrimOp.IsDone() == 0:
print "MakeSphereR : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeCone(thePnt, theAxis, theR1, theR2, theH):
+ """
* Create a cone with given base point, axis, height and radiuses.
* \param thePnt Central point of the first cone base.
* \param theAxis Cone axis.
* \return New GEOM_Object, containing the created cone.
* Example: see GEOM_TestAll.py
-"""
-def MakeCone(thePnt, theAxis, theR1, theR2, theH):
+ """
anObj = PrimOp.MakeConePntVecR1R2H(thePnt, theAxis, theR1, theR2, theH)
if PrimOp.IsDone() == 0:
print "MakeConePntVecR1R2H : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeConeR1R2H(theR1, theR2, theH):
+ """
* 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.
* \return New GEOM_Object, containing the created cone.
* Example: see GEOM_TestAll.py
-"""
-def MakeConeR1R2H(theR1, theR2, theH):
+ """
anObj = PrimOp.MakeConeR1R2H(theR1, theR2, theH)
if PrimOp.IsDone() == 0:
print "MakeConeR1R2H : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeTorus(thePnt, theVec, theRMajor, theRMinor):
+ """
* Create a torus with given center, normal vector and radiuses.
* \param thePnt Torus central point.
* \param theVec Torus axis of symmetry.
* \return New GEOM_Object, containing the created torus.
* Example: see GEOM_TestAll.py
-"""
-def MakeTorus(thePnt, theVec, theRMajor, theRMinor):
+ """
anObj = PrimOp.MakeTorusPntVecRR(thePnt, theVec, theRMajor, theRMinor)
if PrimOp.IsDone() == 0:
print "MakeTorusPntVecRR : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeTorusRR(theRMajor, theRMinor):
+ """
* Create a torus with given radiuses at the origin of coordinate system.
* \param theRMajor Torus major radius.
* \param theRMinor Torus minor radius.
* \return New GEOM_Object, containing the created torus.
* Example: see GEOM_TestAll.py
-"""
-def MakeTorusRR(theRMajor, theRMinor):
+ """
anObj = PrimOp.MakeTorusRR(theRMajor, theRMinor)
if PrimOp.IsDone() == 0:
print "MakeTorusRR : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakePrism(theBase, thePoint1, thePoint2):
+ """
* Create a shape by extrusion of the base shape along a vector, defined by two points.
* \param theBase Base shape to be extruded.
* \param thePoint1 First end of extrusion vector.
* \return New GEOM_Object, containing the created prism.
* Example: see GEOM_TestAll.py
-"""
-def MakePrism(theBase, thePoint1, thePoint2):
+ """
anObj = PrimOp.MakePrismTwoPnt(theBase, thePoint1, thePoint2)
if PrimOp.IsDone() == 0:
print "MakePrismTwoPnt : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakePrismVecH(theBase, theVec, theH):
+ """
* 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.
* \return New GEOM_Object, containing the created prism.
* Example: see GEOM_TestAll.py
-"""
-def MakePrismVecH(theBase, theVec, theH):
+ """
anObj = PrimOp.MakePrismVecH(theBase, theVec, theH)
if PrimOp.IsDone() == 0:
print "MakePrismVecH : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakePipe(theBase, thePath):
+ """
* Create a shape by extrusion of the base shape along
* the path shape. The path shape can be a wire or an edge.
* \param theBase Base shape to be extruded.
* \return New GEOM_Object, containing the created pipe.
* Example: see GEOM_TestAll.py
-"""
-def MakePipe(theBase, thePath):
+ """
anObj = PrimOp.MakePipe(theBase, thePath)
if PrimOp.IsDone() == 0:
print "MakePipe : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeRevolution(theBase, theAxis, theAngle):
+ """
* Create a shape by revolution of the base shape around the axis
* on the given angle, i.e. all the space, transfixed by the base
* shape during its rotation around the axis on the given angle.
* \return New GEOM_Object, containing the created revolution.
* Example: see GEOM_TestAll.py
-"""
-def MakeRevolution(theBase, theAxis, theAngle):
+ """
anObj = PrimOp.MakeRevolutionAxisAngle(theBase, theAxis, theAngle)
if PrimOp.IsDone() == 0:
print "MakeRevolutionAxisAngle : ", PrimOp.GetErrorCode()
# Create base shapes
# -----------------------------------------------------------------------------
-"""
+def MakeEdge(thePnt1, thePnt2):
+ """
* Create a linear edge with specified ends.
* \param thePnt1 Point for the first end of edge.
* \param thePnt2 Point for the second end of edge.
* \return New GEOM_Object, containing the created edge.
* Example: see GEOM_TestAll.py
-"""
-def MakeEdge(thePnt1, thePnt2):
+ """
anObj = ShapesOp.MakeEdge(thePnt1, thePnt2)
if ShapesOp.IsDone() == 0:
print "MakeEdge : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeWire(theEdgesAndWires):
+ """
* Create a wire from the set of edges and wires.
* \param theEdgesAndWires List of edges and/or wires.
* \return New GEOM_Object, containing the created wire.
* Example: see GEOM_TestAll.py
-"""
-def MakeWire(theEdgesAndWires):
+ """
anObj = ShapesOp.MakeWire(theEdgesAndWires)
if ShapesOp.IsDone() == 0:
print "MakeWire : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeFace(theWire, isPlanarWanted):
+ """
* Create a face on the given wire.
* \param theWire Wire to build the face on.
* \param isPlanarWanted If TRUE, only planar face will be built.
* \return New GEOM_Object, containing the created face.
* Example: see GEOM_TestAll.py
-"""
-def MakeFace(theWire, isPlanarWanted):
+ """
anObj = ShapesOp.MakeFace(theWire, isPlanarWanted)
if ShapesOp.IsDone() == 0:
print "MakeFace : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeFaceWires(theWires, isPlanarWanted):
+ """
* Create a face on the given wires set.
* \param theWires List of wires to build the face on.
* \param isPlanarWanted If TRUE, only planar face will be built.
* \return New GEOM_Object, containing the created face.
* Example: see GEOM_TestAll.py
-"""
-def MakeFaceWires(theWires, isPlanarWanted):
+ """
anObj = ShapesOp.MakeFaceWires(theWires, isPlanarWanted)
if ShapesOp.IsDone() == 0:
print "MakeFaceWires : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeFaces(theWires, isPlanarWanted):
+ """
* Shortcut to MakeFaceWires()
* Example: see GEOM_TestOthers.py
-"""
-def MakeFaces(theWires, isPlanarWanted):
+ """
anObj = MakeFaceWires(theWires, isPlanarWanted)
return anObj
-"""
+def MakeShell(theFacesAndShells):
+ """
* Create a shell from the set of faces and shells.
* \param theFacesAndShells List of faces and/or shells.
* \return New GEOM_Object, containing the created shell.
* Example: see GEOM_TestAll.py
-"""
-def MakeShell(theFacesAndShells):
+ """
anObj = ShapesOp.MakeShell(theFacesAndShells)
if ShapesOp.IsDone() == 0:
print "MakeShell : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeSolid(theShells):
+ """
* Create a solid, bounded by the given shells.
* \param theShells Sequence of bounding shells.
* \return New GEOM_Object, containing the created solid.
* Example: see GEOM_TestAll.py
-"""
-def MakeSolid(theShells):
+ """
anObj = ShapesOp.MakeSolidShells(theShells)
if ShapesOp.IsDone() == 0:
print "MakeSolid : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def MakeCompound(theShapes):
+ """
* Create a compound of the given shapes.
* \param theShapes List of shapes to put in compound.
* \return New GEOM_Object, containing the created compound.
* Example: see GEOM_TestAll.py
-"""
-def MakeCompound(theShapes):
+ """
anObj = ShapesOp.MakeCompound(theShapes)
if ShapesOp.IsDone() == 0:
print "MakeCompound : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def NumberOfFaces(theShape):
+ """
* Gives quantity of faces in the given shape.
* \param theShape Shape to count faces of.
* \return Quantity of faces.
* Example: see GEOM_TestOthers.py
-"""
-def NumberOfFaces(theShape):
+ """
nb_faces = ShapesOp.NumberOfFaces(theShape)
if ShapesOp.IsDone() == 0:
print "NumberOfFaces : ", ShapesOp.GetErrorCode()
return nb_faces
-"""
+def NumberOfEdges(theShape):
+ """
* Gives quantity of edges in the given shape.
* \param theShape Shape to count edges of.
* \return Quantity of edges.
* Example: see GEOM_TestOthers.py
-"""
-def NumberOfEdges(theShape):
+ """
nb_edges = ShapesOp.NumberOfEdges(theShape)
if ShapesOp.IsDone() == 0:
print "NumberOfEdges : ", ShapesOp.GetErrorCode()
return nb_edges
-"""
+def ChangeOrientation(theShape):
+ """
* Reverses an orientation the given shape.
* \param theShape Shape to be reversed.
* \return The reversed copy of theShape.
* Example: see GEOM_TestAll.py
-"""
-def ChangeOrientation(theShape):
+ """
anObj = ShapesOp.ChangeOrientation(theShape)
if ShapesOp.IsDone() == 0:
print "ChangeOrientation : ", ShapesOp.GetErrorCode()
return anObj
-"""
+def OrientationChange(theShape):
+ """
* Shortcut to ChangeOrientation()
* Example: see GEOM_TestOthers.py
-"""
-def OrientationChange(theShape):
+ """
anObj = ChangeOrientation(theShape)
return anObj
-"""
+def GetFreeFacesIDs(theShape):
+ """
* Retrieve all free faces from the given shape.
* Free face is a face, which is not shared between two shells of the shape.
* \param theShape Shape to find free faces in.
* \return List of IDs of all free faces, contained in theShape.
* Example: see GEOM_TestOthers.py
-"""
-def GetFreeFacesIDs(theShape):
+ """
anIDs = ShapesOp.GetFreeFacesIDs(theShape)
if ShapesOp.IsDone() == 0:
print "GetFreeFacesIDs : ", ShapesOp.GetErrorCode()
return anIDs
-"""
+def GetSharedShapes(theShape1, theShape2, theShapeType):
+ """
* Get all sub-shapes of theShape1 of the given type, shared with theShape2.
* \param theShape1 Shape to find sub-shapes in.
* \param theShape2 Shape to find shared sub-shapes with.
* \return List of sub-shapes of theShape1, shared with theShape2.
* Example: see GEOM_TestOthers.py
-"""
-def GetSharedShapes(theShape1, theShape2, theShapeType):
+ """
aList = ShapesOp.GetSharedShapes(theShape1, theShape2, theShapeType)
if ShapesOp.IsDone() == 0:
print "GetSharedShapes : ", ShapesOp.GetErrorCode()
return aList
-"""
+def GetShapesOnPlane(theShape, theShapeType, theAx1, theState):
+ """
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified plane by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \return List of all found sub-shapes.
* Example: see GEOM_TestOthers.py
-"""
-def GetShapesOnPlane(theShape, theShapeType, theAx1, theState):
+ """
aList = ShapesOp.GetShapesOnPlane(theShape, theShapeType, theAx1, theState)
if ShapesOp.IsDone() == 0:
print "GetShapesOnPlane : ", ShapesOp.GetErrorCode()
return aList
-"""
+def GetShapesOnCylinder(theShape, theShapeType, theAxis, theRadius, theState):
+ """
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified cylinder by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \return List of all found sub-shapes.
* Example: see GEOM_TestOthers.py
-"""
-def GetShapesOnCylinder(theShape, theShapeType, theAxis, theRadius, theState):
+ """
aList = ShapesOp.GetShapesOnCylinder(theShape, theShapeType, theAxis, theRadius, theState)
if ShapesOp.IsDone() == 0:
print "GetShapesOnCylinder : ", ShapesOp.GetErrorCode()
return aList
-"""
+def GetShapesOnSphere(theShape, theShapeType, theCenter, theRadius, theState):
+ """
* Find in \a theShape all sub-shapes of type \a theShapeType, situated relatively
* the specified sphere by the certain way, defined through \a theState parameter.
* \param theShape Shape to find sub-shapes of.
* \return List of all found sub-shapes.
* Example: see GEOM_TestOthers.py
-"""
-def GetShapesOnSphere(theShape, theShapeType, theCenter, theRadius, theState):
+ """
aList = ShapesOp.GetShapesOnSphere(theShape, theShapeType, theCenter, theRadius, theState)
if ShapesOp.IsDone() == 0:
print "GetShapesOnSphere : ", ShapesOp.GetErrorCode()
return aList
-#"""
-# * Get sub-shape(s) of theShapeWhere, which are
-# * coincident with \a theShapeWhat or could be a part of it.
-# * \param theShapeWhere Shape to find sub-shapes of.
-# * \param theShapeWhat Shape, specifying what to find.
-# * \return Group of all found sub-shapes or a single found sub-shape.
-#
-# * Example: see GEOM_TestOthers.py
-#"""
-#def GetInPlace(theShapeWhere, theShapeWhat):
-# anObj = ShapesOp.GetInPlace(theShapeWhere, theShapeWhat)
-# if ShapesOp.IsDone() == 0:
-# print "GetInPlace : ", ShapesOp.GetErrorCode()
-# return anObj
+def GetInPlace(theShapeWhere, theShapeWhat):
+ """
+ * Get sub-shape(s) of theShapeWhere, which are
+ * coincident with \a theShapeWhat or could be a part of it.
+ * \param theShapeWhere Shape to find sub-shapes of.
+ * \param theShapeWhat Shape, specifying what to find.
+ * \return Group of all found sub-shapes or a single found sub-shape.
+
+ * Example: see GEOM_TestOthers.py
+ """
+ anObj = ShapesOp.GetInPlace(theShapeWhere, theShapeWhat)
+ if ShapesOp.IsDone() == 0:
+ print "GetInPlace : ", ShapesOp.GetErrorCode()
+ return anObj
# -----------------------------------------------------------------------------
# Access to sub-shapes by their unique IDs inside the main shape.
# -----------------------------------------------------------------------------
-"""
+def GetSubShape(aShape, ListOfID):
+ """
* Obtain a composite sub-shape of <aShape>, composed from sub-shapes
* of <aShape>, selected by their unique IDs inside <aShape>
* Example: see GEOM_TestAll.py
-"""
-def GetSubShape(aShape, ListOfID):
+ """
anObj = geom.AddSubShape(aShape,ListOfID)
return anObj
-"""
+def GetSubShapeID(aShape, aSubShape):
+ """
* Obtain unique ID of sub-shape <aSubShape> inside <aShape>
* Example: see GEOM_TestAll.py
-"""
-def GetSubShapeID(aShape, aSubShape):
+ """
anID = LocalOp.GetSubShapeIndex(aShape, aSubShape)
if LocalOp.IsDone() == 0:
print "GetSubShapeIndex : ", LocalOp.GetErrorCode()
# Decompose objects
# -----------------------------------------------------------------------------
-"""
+def SubShapeAll(aShape, aType):
+ """
* Explode a shape on subshapes of a given type.
* \param theShape Shape to be exploded.
* \param theShapeType Type of sub-shapes to be retrieved.
* \return List of sub-shapes of type theShapeType, contained in theShape.
* Example: see GEOM_TestAll.py
-"""
-def SubShapeAll(aShape, aType):
+ """
ListObj = ShapesOp.MakeExplode(aShape,aType,0)
if ShapesOp.IsDone() == 0:
print "MakeExplode : ", ShapesOp.GetErrorCode()
return ListObj
-"""
+def SubShapeAllIDs(aShape, aType):
+ """
* Explode a shape on subshapes of a given type.
* \param theShape Shape to be exploded.
* \param theShapeType Type of sub-shapes to be retrieved.
* \return List of IDs of sub-shapes.
-"""
-def SubShapeAllIDs(aShape, aType):
+ """
ListObj = ShapesOp.SubShapeAllIDs(aShape,aType,0)
if ShapesOp.IsDone() == 0:
print "SubShapeAllIDs : ", ShapesOp.GetErrorCode()
return ListObj
-"""
+def SubShapeAllSorted(aShape, aType):
+ """
* Explode a shape on subshapes of a given type.
* Sub-shapes will be sorted by coordinates of their gravity centers.
* \param theShape Shape to be exploded.
* \return List of sub-shapes of type theShapeType, contained in theShape.
* Example: see GEOM_TestAll.py
-"""
-def SubShapeAllSorted(aShape, aType):
+ """
ListObj = ShapesOp.MakeExplode(aShape,aType,1)
if ShapesOp.IsDone() == 0:
print "MakeExplode : ", ShapesOp.GetErrorCode()
return ListObj
-"""
+def SubShapeAllSortedIDs(aShape, aType):
+ """
* Explode a shape on subshapes of a given type.
* Sub-shapes will be sorted by coordinates of their gravity centers.
* \param theShape Shape to be exploded.
* \param theShapeType Type of sub-shapes to be retrieved.
* \return List of IDs of sub-shapes.
-"""
-def SubShapeAllSortedIDs(aShape, aType):
+ """
ListIDs = ShapesOp.SubShapeAllIDs(aShape,aType,1)
if ShapesOp.IsDone() == 0:
print "SubShapeAllSortedIDs : ", ShapesOp.GetErrorCode()
return ListObj
-"""
+def SubShape(aShape, aType, ListOfInd):
+ """
* Obtain a compound of sub-shapes of <aShape>,
* selected by they indices in list of all sub-shapes of type <aType>.
* Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
* Example: see GEOM_TestAll.py
-"""
-def SubShape(aShape, aType, ListOfInd):
+ """
ListOfIDs = []
AllShapeList = SubShapeAll(aShape, aType)
for ind in ListOfInd:
anObj = GetSubShape(aShape, ListOfIDs)
return anObj
-"""
+def SubShapeSorted(aShape, aType, ListOfInd):
+ """
* Obtain a compound of sub-shapes of <aShape>,
* selected by they indices in sorted list of all sub-shapes of type <aType>.
* Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type]
* Example: see GEOM_TestAll.py
-"""
-def SubShapeSorted(aShape, aType, ListOfInd):
+ """
ListOfIDs = []
AllShapeList = SubShapeAllSorted(aShape, aType)
for ind in ListOfInd:
# Healing operations
# -----------------------------------------------------------------------------
-"""
+def ProcessShape(theShape, theOperators, theParameters, theValues):
+ """
* Apply a sequence of Shape Healing operators to the given object.
* \param theShape Shape to be processed.
* \param theOperators List of names of operators ("FixShape", "SplitClosedFaces", etc.).
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def ProcessShape(theShape, theOperators, theParameters, theValues):
+ """
anObj = HealOp.ProcessShape(theShape, theOperators, theParameters, theValues)
if HealOp.IsDone() == 0:
print "ProcessShape : ", HealOp.GetErrorCode()
return anObj
-"""
+def SuppressFaces(theObject, theFaces):
+ """
* Remove faces from the given object (shape).
* \param theObject Shape to be processed.
* \param theFaces Indices of faces to be removed, if EMPTY then the method
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def SuppressFaces(theObject, theFaces):
+ """
anObj = HealOp.SuppressFaces(theObject, theFaces)
if HealOp.IsDone() == 0:
print "SuppressFaces : ", HealOp.GetErrorCode()
return anObj
-"""
+def MakeSewing(ListShape, theTolerance):
+ """
* Sewing of some shapes into single shape.
* Example: see GEOM_TestHealing.py
-"""
-def MakeSewing(ListShape, theTolerance):
+ """
comp = MakeCompound(ListShape)
anObj = Sew(comp, theTolerance)
return anObj
-"""
+def Sew(theObject, theTolerance):
+ """
* Sewing of the given object.
* \param theObject Shape to be processed.
* \param theTolerance Required tolerance value.
* \return New GEOM_Object, containing processed shape.
* Example: see MakeSewing() above
-"""
-def Sew(theObject, theTolerance):
+ """
anObj = HealOp.Sew(theObject, theTolerance)
if HealOp.IsDone() == 0:
print "Sew : ", HealOp.GetErrorCode()
return anObj
-"""
+def SuppressInternalWires(theObject, theWires):
+ """
* Remove internal wires and edges from the given object (face).
* \param theObject Shape to be processed.
* \param theWires Indices of wires to be removed, if EMPTY then the method
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def SuppressInternalWires(theObject, theWires):
+ """
anObj = HealOp.RemoveIntWires(theObject, theWires)
if HealOp.IsDone() == 0:
print "SuppressInternalWires : ", HealOp.GetErrorCode()
return anObj
-"""
+def SuppressHoles(theObject, theWires):
+ """
* Remove internal closed contours (holes) from the given object.
* \param theObject Shape to be processed.
* \param theWires Indices of wires to be removed, if EMPTY then the method
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def SuppressHoles(theObject, theWires):
+ """
anObj = HealOp.FillHoles(theObject, theWires)
if HealOp.IsDone() == 0:
print "SuppressHoles : ", HealOp.GetErrorCode()
return anObj
-"""
+def CloseContour(theObject, theWires, isCommonVertex):
+ """
* Close an open wire.
* \param theObject Shape to be processed.
* \param theWires Indexes of edge(s) and wire(s) to be closed within <VAR>theObject</VAR>'s shape,
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def CloseContour(theObject, theWires, isCommonVertex):
+ """
anObj = HealOp.CloseContour(theObject, theWires, isCommonVertex)
if HealOp.IsDone() == 0:
print "CloseContour : ", HealOp.GetErrorCode()
return anObj
-"""
+def DivideEdge(theObject, theEdgeIndex, theValue, isByParameter):
+ """
* Addition of a point to a given edge object.
* \param theObject Shape to be processed.
* \param theEdgeIndex Index of edge to be divided within theObject's shape,
* \return New GEOM_Object, containing processed shape.
* Example: see GEOM_TestHealing.py
-"""
-def DivideEdge(theObject, theEdgeIndex, theValue, isByParameter):
+ """
anObj = HealOp.DivideEdge(theObject, theEdgeIndex, theValue, isByParameter)
if HealOp.IsDone() == 0:
print "DivideEdge : ", HealOp.GetErrorCode()
return anObj
-"""
+def GetFreeBoundary(theObject):
+ """
* Get a list of wires (wrapped in GEOM_Object-s),
* that constitute a free boundary of the given shape.
* \param theObject Shape to get free boundary of.
* theOpenWires: Open wires on the free boundary of the given shape.
* Example: see GEOM_TestHealing.py
-"""
-def GetFreeBoundary(theObject):
+ """
anObj = HealOp.GetFreeBoundary(theObject)
if HealOp.IsDone() == 0:
print "GetFreeBoundaries : ", HealOp.GetErrorCode()
# Create advanced objects
# -----------------------------------------------------------------------------
-"""
+def MakeCopy(theOriginal):
+ """
* Create a copy of the given object
* Example: see GEOM_TestAll.py
-"""
-def MakeCopy(theOriginal):
+ """
anObj = InsertOp.MakeCopy(theOriginal)
if InsertOp.IsDone() == 0:
print "MakeCopy : ", InsertOp.GetErrorCode()
return anObj
-"""
+def MakeFilling(theShape, theMinDeg, theMaxDeg, theTol2D, theTol3D, theNbIter):
+ """
* Create a filling from the given compound of contours.
* \param theShape the compound of contours
* \param theMinDeg a minimal degree
* \return New GEOM_Object, containing the created filling surface.
* Example: see GEOM_TestAll.py
-"""
-def MakeFilling(theShape, theMinDeg, theMaxDeg, theTol2D, theTol3D, theNbIter):
+ """
anObj = PrimOp.MakeFilling(theShape, theMinDeg, theMaxDeg, theTol2D, theTol3D, theNbIter)
if PrimOp.IsDone() == 0:
print "MakeFilling : ", PrimOp.GetErrorCode()
return anObj
-"""
+def MakeGlueFaces(theShape, theTolerance):
+ """
* Replace coincident faces in theShape by one face.
* \param theShape Initial shape.
* \param theTolerance Maximum distance between faces, which can be considered as coincident.
* \return New GEOM_Object, containing a copy of theShape without coincident faces.
* Example: see GEOM_Spanner.py
-"""
-def MakeGlueFaces(theShape, theTolerance):
+ """
anObj = ShapesOp.MakeGlueFaces(theShape, theTolerance)
if ShapesOp.IsDone() == 0:
print "MakeGlueFaces : ", ShapesOp.GetErrorCode()
# Boolean (Common, Cut, Fuse, Section)
# -----------------------------------------------------------------------------
-"""
+def MakeBoolean(theShape1, theShape2, theOperation):
+ """
* Perform one of boolean operations on two given shapes.
* \param theShape1 First argument for boolean operation.
* \param theShape2 Second argument for boolean operation.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeBoolean(theShape1, theShape2, theOperation):
+ """
anObj = BoolOp.MakeBoolean(theShape1, theShape2, theOperation)
if BoolOp.IsDone() == 0:
print "MakeBoolean : ", BoolOp.GetErrorCode()
return anObj
-"""
- * Shortcuts to MakeBoolean() for certain operations
+def MakeCommon(s1, s2):
+ """
+ * Shortcut to MakeBoolean(s1, s2, 1)
* Example: see GEOM_TestOthers.py
-"""
-def MakeCommon(s1, s2):
+ """
return MakeBoolean(s1, s2, 1)
def MakeCut(s1, s2):
+ """
+ * Shortcut to MakeBoolean(s1, s2, 2)
+
+ * Example: see GEOM_TestOthers.py
+ """
return MakeBoolean(s1, s2, 2)
def MakeFuse(s1, s2):
+ """
+ * Shortcut to MakeBoolean(s1, s2, 3)
+
+ * Example: see GEOM_TestOthers.py
+ """
return MakeBoolean(s1, s2, 3)
def MakeSection(s1, s2):
+ """
+ * Shortcut to MakeBoolean(s1, s2, 4)
+
+ * Example: see GEOM_TestOthers.py
+ """
return MakeBoolean(s1, s2, 4)
-"""
+def MakePartition(ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
+ Limit=ShapeType["SHAPE"], RemoveWebs=0, ListMaterials=[]):
+ """
* Perform partition operation.
* \param ListShapes Shapes to be intersected.
* \param ListTools Shapes to intersect theShapes.
* \return New GEOM_Object, containing the result shapes.
* Example: see GEOM_TestAll.py
-"""
-def MakePartition(ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
- Limit=ShapeType["SHAPE"], RemoveWebs=0, ListMaterials=[]):
+ """
anObj = BoolOp.MakePartition(ListShapes, ListTools,
ListKeepInside, ListRemoveInside,
Limit, RemoveWebs, ListMaterials);
print "MakePartition : ", BoolOp.GetErrorCode()
return anObj
-"""
+def Partition(ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
+ Limit=ShapeType["SHAPE"], RemoveWebs=0, ListMaterials=[]):
+ """
* Shortcut to MakePartition()
* Example: see GEOM_TestOthers.py
-"""
-def Partition(ListShapes, ListTools=[], ListKeepInside=[], ListRemoveInside=[],
- Limit=ShapeType["SHAPE"], RemoveWebs=0, ListMaterials=[]):
+ """
anObj = MakePartition(ListShapes, ListTools,
ListKeepInside, ListRemoveInside,
Limit, RemoveWebs, ListMaterials);
return anObj
-"""
+def MakeHalfPartition(theShape, thePlane):
+ """
* Perform partition of the Shape with the Plane
* \param theShape Shape to be intersected.
* \param thePlane Tool shape, to intersect theShape.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeHalfPartition(theShape, thePlane):
+ """
anObj = BoolOp.MakeHalfPartition(theShape, thePlane)
if BoolOp.IsDone() == 0:
print "MakeHalfPartition : ", BoolOp.GetErrorCode()
# Transform objects
# -----------------------------------------------------------------------------
-"""
+def MakeTranslationTwoPoints(theObject, thePoint1, thePoint2):
+ """
* Translate the given object along the vector, specified
* by its end points, creating its copy before the translation.
* \param theObject The object to be translated.
* \return New GEOM_Object, containing the translated object.
* Example: see GEOM_TestAll.py
-"""
-def MakeTranslationTwoPoints(theObject, thePoint1, thePoint2):
+ """
anObj = TrsfOp.TranslateTwoPointsCopy(theObject, thePoint1, thePoint2)
if TrsfOp.IsDone() == 0:
print "TranslateTwoPointsCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeTranslation(theObject, theDX, theDY, theDZ):
+ """
* Translate the given object along the vector, specified
* by its components, creating its copy before the translation.
* \param theObject The object to be translated.
* \return New GEOM_Object, containing the translated object.
* Example: see GEOM_TestAll.py
-"""
-def MakeTranslation(theObject, theDX, theDY, theDZ):
+ """
anObj = TrsfOp.TranslateDXDYDZCopy(theObject, theDX, theDY, theDZ)
if TrsfOp.IsDone() == 0:
print "TranslateDXDYDZCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeTranslationVector(theObject, theVector):
+ """
* Translate the given object along the given vector,
* creating its copy before the translation.
* \param theObject The object to be translated.
* \return New GEOM_Object, containing the translated object.
* Example: see GEOM_TestAll.py
-"""
-def MakeTranslationVector(theObject, theVector):
+ """
anObj = TrsfOp.TranslateVectorCopy(theObject, theVector)
if TrsfOp.IsDone() == 0:
print "TranslateVectorCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeRotation(theObject, theAxis, theAngle):
+ """
* Rotate the given object around the given axis
* on the given angle, creating its copy before the rotatation.
* \param theObject The object to be rotated.
* \return New GEOM_Object, containing the rotated object.
* Example: see GEOM_TestAll.py
-"""
-def MakeRotation(theObject, theAxis, theAngle):
+ """
anObj = TrsfOp.RotateCopy(theObject, theAxis, theAngle)
if TrsfOp.IsDone() == 0:
print "RotateCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeScaleTransform(theObject, thePoint, theFactor):
+ """
* Scale the given object by the factor, creating its copy before the scaling.
* \param theObject The object to be scaled.
* \param thePoint Center point for scaling.
* \return New GEOM_Object, containing the scaled shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeScaleTransform(theObject, thePoint, theFactor):
+ """
anObj = TrsfOp.ScaleShapeCopy(theObject, thePoint, theFactor)
if TrsfOp.IsDone() == 0:
print "ScaleShapeCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeMirrorByPlane(theObject, thePlane):
+ """
* Create an object, symmetrical
* to the given one relatively the given plane.
* \param theObject The object to be mirrored.
* \return New GEOM_Object, containing the mirrored shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeMirrorByPlane(theObject, thePlane):
+ """
anObj = TrsfOp.MirrorPlaneCopy(theObject, thePlane)
if TrsfOp.IsDone() == 0:
print "MirrorPlaneCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeMirrorByAxis(theObject, theAxis):
+ """
* Create an object, symmetrical
* to the given one relatively the given axis.
* \param theObject The object to be mirrored.
* \return New GEOM_Object, containing the mirrored shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeMirrorByAxis(theObject, theAxis):
+ """
anObj = TrsfOp.MirrorAxisCopy(theObject, theAxis)
if TrsfOp.IsDone() == 0:
print "MirrorAxisCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeMirrorByPoint(theObject, thePoint):
+ """
* Create an object, symmetrical
* to the given one relatively the given point.
* \param theObject The object to be mirrored.
* \return New GEOM_Object, containing the mirrored shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeMirrorByPoint(theObject, thePoint):
+ """
anObj = TrsfOp.MirrorPointCopy(theObject, thePoint)
if TrsfOp.IsDone() == 0:
print "MirrorPointCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakePosition(theObject, theStartLCS, theEndLCS):
+ """
* Modify the Location of the given object by LCS
* creating its copy before the setting
* Example: see GEOM_TestAll.py
-"""
-def MakePosition(theObject, theStartLCS, theEndLCS):
+ """
anObj = TrsfOp.PositionShapeCopy(theObject, theStartLCS, theEndLCS)
if TrsfOp.IsDone() == 0:
print "PositionShapeCopy : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeOffset(theObject, theOffset):
+ """
* Create new object as offset of the given one.
* \param theObject The base object for the offset.
* \param theOffset Offset value.
* \return New GEOM_Object, containing the offset object.
* Example: see GEOM_TestAll.py
-"""
-def MakeOffset(theObject, theOffset):
+ """
anObj = TrsfOp.OffsetShapeCopy(theObject, theOffset)
if TrsfOp.IsDone() == 0:
print "OffsetShapeCopy : ", TrsfOp.GetErrorCode()
# Patterns
# -----------------------------------------------------------------------------
-"""
+def MakeMultiTranslation1D(theObject, theVector, theStep, theNbTimes):
+ """
* Translate the given object along the given vector a given number times
* \param theObject The object to be translated.
* \param theVector Direction of the translation.
* the shapes, obtained after each translation.
* Example: see GEOM_TestAll.py
-"""
-def MakeMultiTranslation1D(theObject, theVector, theStep, theNbTimes):
+ """
anObj = TrsfOp.MultiTranslate1D(theObject, theVector, theStep, theNbTimes)
if TrsfOp.IsDone() == 0:
print "MultiTranslate1D : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeMultiTranslation2D(theObject, theVector1, theStep1, theNbTimes1,
+ theVector2, theStep2, theNbTimes2):
+ """
* Conseqently apply two specified translations to theObject specified number of times.
* \param theObject The object to be translated.
* \param theVector1 Direction of the first translation.
* the shapes, obtained after each translation.
* Example: see GEOM_TestAll.py
-"""
-def MakeMultiTranslation2D(theObject, theVector1, theStep1, theNbTimes1,
- theVector2, theStep2, theNbTimes2):
+ """
anObj = TrsfOp.MultiTranslate2D(theObject, theVector1, theStep1, theNbTimes1,
theVector2, theStep2, theNbTimes2)
if TrsfOp.IsDone() == 0:
print "MultiTranslate2D : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MultiRotate1D(theObject, theAxis, theNbTimes):
+ """
* Rotate the given object around the given axis a given number times.
* Rotation angle will be 2*PI/theNbTimes.
* \param theObject The object to be rotated.
* shapes, obtained after each rotation.
* Example: see GEOM_TestAll.py
-"""
-def MultiRotate1D(theObject, theAxis, theNbTimes):
+ """
anObj = TrsfOp.MultiRotate1D(theObject, theAxis, theNbTimes)
if TrsfOp.IsDone() == 0:
print "MultiRotate1D : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MultiRotate2D(theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2):
+ """
* Rotate the given object around the
* given axis on the given angle a given number
* times and multi-translate each rotation result.
* shapes, obtained after each transformation.
* Example: see GEOM_TestAll.py
-"""
-def MultiRotate2D(theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2):
+ """
anObj = TrsfOp.MultiRotate2D(theObject, theAxis, theAngle, theNbTimes1, theStep, theNbTimes2)
if TrsfOp.IsDone() == 0:
print "MultiRotate2D : ", TrsfOp.GetErrorCode()
return anObj
-"""
+def MakeMultiRotation1D(aShape,aDir,aPoint,aNbTimes):
+ """
* The same, as MultiRotate1D(), but axis is given by direction and point
* Example: see GEOM_TestOthers.py
-"""
-def MakeMultiRotation1D(aShape,aDir,aPoint,aNbTimes):
+ """
aVec = MakeLine(aPoint,aDir)
anObj = MultiRotate1D(aShape,aVec,aNbTimes)
return anObj
-"""
+def MakeMultiRotation2D(aShape,aDir,aPoint,anAngle,nbtimes1,aStep,nbtimes2):
+ """
* The same, as MultiRotate2D(), but axis is given by direction and point
* Example: see GEOM_TestOthers.py
-"""
-def MakeMultiRotation2D(aShape,aDir,aPoint,anAngle,nbtimes1,aStep,nbtimes2):
+ """
aVec = MakeLine(aPoint,aDir)
anObj = MultiRotate2D(aShape,aVec,anAngle,nbtimes1,aStep,nbtimes2)
return anObj
# Local operations
# -----------------------------------------------------------------------------
-"""
+def MakeFilletAll(theShape, theR):
+ """
* Perform a fillet on all edges of the given shape.
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestOthers.py
-"""
-def MakeFilletAll(theShape, theR):
+ """
anObj = LocalOp.MakeFilletAll(theShape, theR)
if LocalOp.IsDone() == 0:
print "MakeFilletAll : ", LocalOp.GetErrorCode()
return anObj
-"""
+def MakeFillet(theShape, theR, theShapeType, theListShapes):
+ """
* Perform a fillet on the specified edges/faces of the given shape
* \param theShape Shape, to perform fillet on.
* \param theR Fillet radius.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeFillet(theShape, theR, theShapeType, theListShapes):
+ """
anObj = None
if theShapeType == ShapeType["EDGE"]:
anObj = LocalOp.MakeFilletEdges(theShape, theR, theListShapes)
print "MakeFillet : ", LocalOp.GetErrorCode()
return anObj
-"""
+def MakeChamferAll(theShape, theD):
+ """
* Perform a symmetric chamfer on all edges of the given shape.
* \param theShape Shape, to perform chamfer on.
* \param theD Chamfer size along each face.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestOthers.py
-"""
-def MakeChamferAll(theShape, theD):
+ """
anObj = LocalOp.MakeChamferAll(theShape, theD)
if LocalOp.IsDone() == 0:
print "MakeChamferAll : ", LocalOp.GetErrorCode()
return anObj
-"""
+def MakeChamferEdge(theShape, theD1, theD2, theFace1, theFace2):
+ """
* Perform a chamfer on edges, common to the specified faces,
* with distance D1 on the Face1
* \param theShape Shape, to perform chamfer on.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeChamferEdge(theShape, theD1, theD2, theFace1, theFace2):
+ """
anObj = LocalOp.MakeChamferEdge(theShape, theD1, theD2, theFace1, theFace2)
if LocalOp.IsDone() == 0:
print "MakeChamferEdge : ", LocalOp.GetErrorCode()
return anObj
-"""
+def MakeChamferFaces(theShape, theD1, theD2, theFaces):
+ """
* Perform a chamfer on all edges of the specified faces,
* with distance D1 on the first specified face (if several for one edge)
* \param theShape Shape, to perform chamfer on.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_TestAll.py
-"""
-def MakeChamferFaces(theShape, theD1, theD2, theFaces):
+ """
anObj = LocalOp.MakeChamferFaces(theShape, theD1, theD2, theFaces)
if LocalOp.IsDone() == 0:
print "MakeChamferFaces : ", LocalOp.GetErrorCode()
return anObj
-"""
+def MakeChamfer(aShape,d1,d2,aShapeType,ListShape):
+ """
* Shortcut to MakeChamferEdge() and MakeChamferFaces()
* Example: see GEOM_TestOthers.py
-"""
-def MakeChamfer(aShape,d1,d2,aShapeType,ListShape):
+ """
anObj = None
if aShapeType == ShapeType["EDGE"]:
anObj = MakeChamferEdge(aShape,d1,d2,ListShape[0],ListShape[1])
anObj = MakeChamferFaces(aShape,d1,d2,ListShape)
return anObj
-"""
+def Archimede(theShape, theWeight, theWaterDensity, theMeshDeflection):
+ """
* 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.
* by a plane, corresponding to water level.
* Example: see GEOM_TestAll.py
-"""
-def Archimede(theShape, theWeight, theWaterDensity, theMeshDeflection):
+ """
anObj = LocalOp.MakeArchimede(theShape, theWeight, theWaterDensity, theMeshDeflection)
if LocalOp.IsDone() == 0:
print "MakeArchimede : ", LocalOp.GetErrorCode()
# Information objects
# -----------------------------------------------------------------------------
-"""
+def PointCoordinates(Point):
+ """
* Get point coordinates
* \return [x, y, z]
* Example: see GEOM_TestMeasures.py
-"""
-def PointCoordinates(Point):
+ """
aTuple = MeasuOp.PointCoordinates(Point)
if MeasuOp.IsDone() == 0:
print "PointCoordinates : ", MeasuOp.GetErrorCode()
return aTuple
-"""
+def BasicProperties(theShape):
+ """
* Get summarized length of all wires,
* area of surface and volume of the given shape.
* \param theShape Shape to define properties of.
* theVolume: Volume of the given shape.
* Example: see GEOM_TestMeasures.py
-"""
-def BasicProperties(theShape):
+ """
aTuple = MeasuOp.GetBasicProperties(theShape)
if MeasuOp.IsDone() == 0:
print "BasicProperties : ", MeasuOp.GetErrorCode()
return aTuple
-"""
+def BoundingBox(theShape):
+ """
* Get parameters of bounding box of the given shape
* \param theShape Shape to obtain bounding box of.
* \return [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax]
* Zmin,Zmax: Limits of shape along OZ axis.
* Example: see GEOM_TestMeasures.py
-"""
-def BoundingBox(theShape):
+ """
aTuple = MeasuOp.GetBoundingBox(theShape)
if MeasuOp.IsDone() == 0:
print "BoundingBox : ", MeasuOp.GetErrorCode()
return aTuple
-"""
+def Inertia(theShape):
+ """
* Get inertia matrix and moments of inertia of theShape.
* \param theShape Shape to calculate inertia of.
* \return [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz]
* Ix,Iy,Iz: Moments of inertia of the given shape.
* Example: see GEOM_TestMeasures.py
-"""
-def Inertia(theShape):
+ """
aTuple = MeasuOp.GetInertia(theShape)
if MeasuOp.IsDone() == 0:
print "Inertia : ", MeasuOp.GetErrorCode()
return aTuple
-"""
+def MinDistance(theShape1, theShape2):
+ """
* Get minimal distance between the given shapes.
* \param theShape1,theShape2 Shapes to find minimal distance between.
* \return Value of the minimal distance between the given shapes.
* Example: see GEOM_TestMeasures.py
-"""
-def MinDistance(theShape1, theShape2):
+ """
aTuple = MeasuOp.GetMinDistance(theShape1, theShape2)
if MeasuOp.IsDone() == 0:
print "MinDistance : ", MeasuOp.GetErrorCode()
return aTuple[0]
-"""
+def Tolerance(theShape):
+ """
* Get min and max tolerances of sub-shapes of theShape
* \param theShape Shape, to get tolerances of.
* \return [FaceMin,FaceMax, EdgeMin,EdgeMax, VertMin,VertMax]
* VertMin,VertMax: Min and max tolerances of the vertices.
* Example: see GEOM_TestMeasures.py
-"""
-def Tolerance(theShape):
+ """
aTuple = MeasuOp.GetTolerance(theShape)
if MeasuOp.IsDone() == 0:
print "Tolerance : ", MeasuOp.GetErrorCode()
return aTuple
-"""
+def WhatIs(theShape):
+ """
* Obtain description of the given shape (number of sub-shapes of each type)
* \param theShape Shape to be described.
* \return Description of the given shape.
* Example: see GEOM_TestMeasures.py
-"""
-def WhatIs(theShape):
+ """
aDescr = MeasuOp.WhatIs(theShape)
if MeasuOp.IsDone() == 0:
print "WhatIs : ", MeasuOp.GetErrorCode()
return aDescr
-"""
+def MakeCDG(theShape):
+ """
* Get a point, situated at the centre of mass of theShape.
* \param theShape Shape to define centre of mass of.
* \return New GEOM_Object, containing the created point.
* Example: see GEOM_TestMeasures.py
-"""
-def MakeCDG(theShape):
+ """
anObj = MeasuOp.GetCentreOfMass(theShape)
if MeasuOp.IsDone() == 0:
print "GetCentreOfMass : ", MeasuOp.GetErrorCode()
return anObj
-"""
+def CheckShape(theShape):
+ """
* Check a topology of the given shape.
* \param theShape Shape to check validity of.
* \return TRUE, if the shape "seems to be valid" from the topological point of view.
* If theShape is invalid, prints a description of problem.
* Example: see GEOM_TestMeasures.py
-"""
-def CheckShape(theShape):
+ """
(IsValid, Status) = MeasuOp.CheckShape(theShape)
if MeasuOp.IsDone() == 0:
print "CheckShape : ", MeasuOp.GetErrorCode()
# Import/Export objects
# -----------------------------------------------------------------------------
-"""
+def Import(theFileName, theFormatName):
+ """
* 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.
* \return New GEOM_Object, containing the imported shape.
* Example: see GEOM_TestOthers.py
-"""
-def Import(theFileName, theFormatName):
+ """
anObj = InsertOp.Import(theFileName, theFormatName)
if InsertOp.IsDone() == 0:
print "Import : ", InsertOp.GetErrorCode()
return anObj
-"""
- * Shortcuts to Import() for certain formats
+def ImportBREP(theFileName):
+ """
+ * Shortcut to Import() for BREP format
* Example: see GEOM_TestOthers.py
-"""
-def ImportBREP(theFileName):
+ """
return Import(theFileName, "BREP")
def ImportIGES(theFileName):
+ """
+ * Shortcut to Import() for IGES format
+
+ * Example: see GEOM_TestOthers.py
+ """
return Import(theFileName, "IGES")
def ImportSTEP(theFileName):
+ """
+ * Shortcut to Import() for STEP format
+
+ * Example: see GEOM_TestOthers.py
+ """
return Import(theFileName, "STEP")
-"""
+def Export(theObject, theFileName, theFormatName):
+ """
* Export the given shape into a file with given name.
* \param theObject Shape to be stored in the file.
* \param theFileName Name of the file to store the given shape in.
* Available formats can be obtained with InsertOp.ImportTranslators() method.
* Example: see GEOM_TestOthers.py
-"""
-def Export(theObject, theFileName, theFormatName):
+ """
InsertOp.Export(theObject, theFileName, theFormatName)
if InsertOp.IsDone() == 0:
print "Export : ", InsertOp.GetErrorCode()
-"""
- * Shortcuts to Export() for certain formats
+def ExportBREP(theObject, theFileName):
+ """
+ * Shortcut to Export() for BREP format
* Example: see GEOM_TestOthers.py
-"""
-def ExportBREP(theObject, theFileName):
+ """
return Export(theObject, theFileName, "BREP")
def ExportIGES(theObject, theFileName):
+ """
+ * Shortcut to Export() for IGES format
+
+ * Example: see GEOM_TestOthers.py
+ """
return Export(theObject, theFileName, "IGES")
def ExportSTEP(theObject, theFileName):
+ """
+ * Shortcut to Export() for STEP format
+
+ * Example: see GEOM_TestOthers.py
+ """
return Export(theObject, theFileName, "STEP")
# -----------------------------------------------------------------------------
# Block operations
# -----------------------------------------------------------------------------
-"""
+def MakeQuad(E1, E2, E3, E4):
+ """
* Create a quadrangle face from four edges. Order of Edges is not
* important. It is not necessary that edges share the same vertex.
* \param E1,E2,E3,E4 Edges for the face bound.
* \return New GEOM_Object, containing the created face.
* Example: see GEOM_Spanner.py
-"""
-def MakeQuad(E1, E2, E3, E4):
+ """
anObj = BlocksOp.MakeQuad(E1, E2, E3, E4)
if BlocksOp.IsDone() == 0:
print "MakeQuad : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeQuad2Edges(E1, E2):
+ """
* Create a quadrangle face on two edges.
* The missing edges will be built by creating the shortest ones.
* \param E1,E2 Two opposite edges for the face.
* \return New GEOM_Object, containing the created face.
* Example: see GEOM_Spanner.py
-"""
-def MakeQuad2Edges(E1, E2):
+ """
anObj = BlocksOp.MakeQuad2Edges(E1, E2)
if BlocksOp.IsDone() == 0:
print "MakeQuad2Edges : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeQuad4Vertices(V1, V2, V3, V4):
+ """
* Create a quadrangle face with specified corners.
* The missing edges will be built by creating the shortest ones.
* \param V1,V2,V3,V4 Corner vertices for the face.
* \return New GEOM_Object, containing the created face.
* Example: see GEOM_Spanner.py
-"""
-def MakeQuad4Vertices(V1, V2, V3, V4):
+ """
anObj = BlocksOp.MakeQuad4Vertices(V1, V2, V3, V4)
if BlocksOp.IsDone() == 0:
print "MakeQuad4Vertices : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeHexa(F1, F2, F3, F4, F5, F6):
+ """
* 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.
* \param F1,F2,F3,F4,F5,F6 Faces for the hexahedral solid.
* \return New GEOM_Object, containing the created solid.
* Example: see GEOM_Spanner.py
-"""
-def MakeHexa(F1, F2, F3, F4, F5, F6):
+ """
anObj = BlocksOp.MakeHexa(F1, F2, F3, F4, F5, F6)
if BlocksOp.IsDone() == 0:
print "MakeHexa : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeHexa2Faces(F1, F2):
+ """
* Create a hexahedral solid between two given faces.
* The missing faces will be built by creating the smallest ones.
* \param F1,F2 Two opposite faces for the hexahedral solid.
* \return New GEOM_Object, containing the created solid.
* Example: see GEOM_Spanner.py
-"""
-def MakeHexa2Faces(F1, F2):
+ """
anObj = BlocksOp.MakeHexa2Faces(F1, F2)
if BlocksOp.IsDone() == 0:
print "MakeHexa2Faces : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeHexa2Faces(F1, F2):
+ """
* Get a vertex, found in the given shape by its coordinates.
* \param theShape Block or a compound of blocks.
* \param theX,theY,theZ Coordinates of the sought vertex.
* \return New GEOM_Object, containing the found vertex.
* Example: see GEOM_TestOthers.py
-"""
-def GetPoint(theShape, theX, theY, theZ, theEpsilon):
+ """
anObj = BlocksOp.GetPoint(theShape, theX, theY, theZ, theEpsilon)
if BlocksOp.IsDone() == 0:
print "GetPoint : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetEdge(theShape, thePoint1, thePoint2):
+ """
* Get an edge, found in the given shape by two given vertices.
* \param theShape Block or a compound of blocks.
* \param thePoint1,thePoint2 Points, close to the ends of the desired edge.
* \return New GEOM_Object, containing the found edge.
* Example: see GEOM_Spanner.py
-"""
-def GetEdge(theShape, thePoint1, thePoint2):
+ """
anObj = BlocksOp.GetEdge(theShape, thePoint1, thePoint2)
if BlocksOp.IsDone() == 0:
print "GetEdge : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetEdgeNearPoint(theShape, thePoint):
+ """
* Find an edge of the given shape, which has minimal distance to the given point.
* \param theShape Block or a compound of blocks.
* \param thePoint Point, close to the desired edge.
* \return New GEOM_Object, containing the found edge.
* Example: see GEOM_TestOthers.py
-"""
-def GetEdgeNearPoint(theShape, thePoint):
+ """
anObj = BlocksOp.GetEdgeNearPoint(theShape, thePoint)
if BlocksOp.IsDone() == 0:
print "GetEdgeNearPoint : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetFaceByPoints(theShape, thePoint1, thePoint2, thePoint3, thePoint4):
+ """
* Returns a face, found in the given shape by four given corner vertices.
* \param theShape Block or a compound of blocks.
* \param thePoint1-thePoint4 Points, close to the corners of the desired face.
* \return New GEOM_Object, containing the found face.
* Example: see GEOM_Spanner.py
-"""
-def GetFaceByPoints(theShape, thePoint1, thePoint2, thePoint3, thePoint4):
+ """
anObj = BlocksOp.GetFaceByPoints(theShape, thePoint1, thePoint2, thePoint3, thePoint4)
if BlocksOp.IsDone() == 0:
print "GetFaceByPoints : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetFaceByEdges(theShape, theEdge1, theEdge2):
+ """
* Get a face of block, found in the given shape by two given edges.
* \param theShape Block or a compound of blocks.
* \param theEdge1,theEdge2 Edges, close to the edges of the desired face.
* \return New GEOM_Object, containing the found face.
* Example: see GEOM_Spanner.py
-"""
-def GetFaceByEdges(theShape, theEdge1, theEdge2):
+ """
anObj = BlocksOp.GetFaceByEdges(theShape, theEdge1, theEdge2)
if BlocksOp.IsDone() == 0:
print "GetFaceByEdges : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetOppositeFace(theBlock, theFace):
+ """
* Find a face, opposite to the given one in the given block.
* \param theBlock Must be a hexahedral solid.
* \param theFace Face of \a theBlock, opposite to the desired face.
* \return New GEOM_Object, containing the found face.
* Example: see GEOM_Spanner.py
-"""
-def GetOppositeFace(theBlock, theFace):
+ """
anObj = BlocksOp.GetOppositeFace(theBlock, theFace)
if BlocksOp.IsDone() == 0:
print "GetOppositeFace : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetFaceNearPoint(theShape, thePoint):
+ """
* Find a face of the given shape, which has minimal distance to the given point.
* \param theShape Block or a compound of blocks.
* \param thePoint Point, close to the desired face.
* \return New GEOM_Object, containing the found face.
* Example: see GEOM_Spanner.py
-"""
-def GetFaceNearPoint(theShape, thePoint):
+ """
anObj = BlocksOp.GetFaceNearPoint(theShape, thePoint)
if BlocksOp.IsDone() == 0:
print "GetFaceNearPoint : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetFaceByNormale(theBlock, theVector):
+ """
* Find a face of block, whose outside normale has minimal angle with the given vector.
* \param theShape Block or a compound of blocks.
* \param theVector Vector, close to the normale of the desired face.
* \return New GEOM_Object, containing the found face.
* Example: see GEOM_Spanner.py
-"""
-def GetFaceByNormale(theBlock, theVector):
+ """
anObj = BlocksOp.GetFaceByNormale(theBlock, theVector)
if BlocksOp.IsDone() == 0:
print "GetFaceByNormale : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def CheckCompoundOfBlocks(theCompound):
+ """
* Check, if the compound of blocks is given.
* To be considered as a compound of blocks, the
* given shape must satisfy the following conditions:
* If theCompound is not valid, prints all discovered errors.
* Example: see GEOM_Spanner.py
-"""
-def CheckCompoundOfBlocks(theCompound):
+ """
(IsValid, BCErrors) = BlocksOp.CheckCompoundOfBlocks(theCompound)
if BlocksOp.IsDone() == 0:
print "CheckCompoundOfBlocks : ", BlocksOp.GetErrorCode()
print Descr
return IsValid
-"""
+def RemoveExtraEdges(theShape):
+ """
* Remove all seam and degenerated edges from \a theShape.
* Unite faces and edges, sharing one surface.
* \param theShape The compound or single solid to remove irregular edges from.
* \return Improved shape.
* Example: see GEOM_TestOthers.py
-"""
-def RemoveExtraEdges(theShape):
+ """
anObj = BlocksOp.RemoveExtraEdges(theShape)
if BlocksOp.IsDone() == 0:
print "RemoveExtraEdges : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def CheckAndImprove(theShape):
+ """
* Check, if the given shape is a blocks compound.
* Fix all detected errors.
* \note Single block can be also fixed by this method.
* \return Improved compound.
* Example: see GEOM_TestOthers.py
-"""
-def CheckAndImprove(theShape):
+ """
anObj = BlocksOp.CheckAndImprove(theShape)
if BlocksOp.IsDone() == 0:
print "CheckAndImprove : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeBlockExplode(theCompound, theMinNbFaces, theMaxNbFaces):
+ """
* Get all the blocks, contained in the given compound.
* \param theCompound The compound to explode.
* \param theMinNbFaces If solid has lower number of faces, it is not a block.
* \return List of GEOM_Objects, containing the retrieved blocks.
* Example: see GEOM_TestOthers.py
-"""
-def MakeBlockExplode(theCompound, theMinNbFaces, theMaxNbFaces):
+ """
aList = BlocksOp.ExplodeCompoundOfBlocks(theCompound, theMinNbFaces, theMaxNbFaces)
if BlocksOp.IsDone() == 0:
print "MakeBlockExplode : ", BlocksOp.GetErrorCode()
return aList
-"""
+def GetBlockNearPoint(theCompound, thePoint):
+ """
* Find block, containing the given point inside its volume or on boundary.
* \param theCompound Compound, to find block in.
* \param thePoint Point, close to the desired block. If the point lays on
* \return New GEOM_Object, containing the found block.
* Example: see GEOM_Spanner.py
-"""
-def GetBlockNearPoint(theCompound, thePoint):
+ """
anObj = BlocksOp.GetBlockNearPoint(theCompound, thePoint)
if BlocksOp.IsDone() == 0:
print "GetBlockNearPoint : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetBlockByParts(theCompound, theParts):
+ """
* Find block, containing all the elements, passed as the parts, or maximum quantity of them.
* \param theCompound Compound, to find block in.
* \param theParts List of faces and/or edges and/or vertices to be parts of the found block.
* \return New GEOM_Object, containing the found block.
* Example: see GEOM_TestOthers.py
-"""
-def GetBlockByParts(theCompound, theParts):
+ """
anObj = BlocksOp.GetBlockByParts(theCompound, theParts)
if BlocksOp.IsDone() == 0:
print "GetBlockByParts : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def GetBlocksByParts(theCompound, theParts):
+ """
* Return all blocks, containing all the elements, passed as the parts.
* \param theCompound Compound, to find blocks in.
* \param theParts List of faces and/or edges and/or vertices to be parts of the found blocks.
* \return List of GEOM_Objects, containing the found blocks.
* Example: see GEOM_Spanner.py
-"""
-def GetBlocksByParts(theCompound, theParts):
+ """
aList = BlocksOp.GetBlocksByParts(theCompound, theParts)
if BlocksOp.IsDone() == 0:
print "GetBlocksByParts : ", BlocksOp.GetErrorCode()
return aList
-"""
+def MakeMultiTransformation1D(Block, DirFace1, DirFace2, NbTimes):
+ """
* Multi-transformate block and glue the result.
* Transformation is defined so, as to superpose direction faces.
* \param Block Hexahedral solid to be multi-transformed.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_Spanner.py
-"""
-def MakeMultiTransformation1D(Block, DirFace1, DirFace2, NbTimes):
+ """
anObj = BlocksOp.MakeMultiTransformation1D(Block, DirFace1, DirFace2, NbTimes)
if BlocksOp.IsDone() == 0:
print "MakeMultiTransformation1D : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def MakeMultiTransformation2D(Block, DirFace1U, DirFace2U, NbTimesU,
+ DirFace1V, DirFace2V, NbTimesV):
+ """
* Multi-transformate block and glue the result.
* \param Block Hexahedral solid to be multi-transformed.
* \param DirFace1U,DirFace2U IDs of Direction faces for the first transformation.
* \return New GEOM_Object, containing the result shape.
* Example: see GEOM_Spanner.py
-"""
-def MakeMultiTransformation2D(Block, DirFace1U, DirFace2U, NbTimesU,
- DirFace1V, DirFace2V, NbTimesV):
+ """
anObj = BlocksOp.MakeMultiTransformation2D(Block, DirFace1U, DirFace2U, NbTimesU,
DirFace1V, DirFace2V, NbTimesV)
if BlocksOp.IsDone() == 0:
print "MakeMultiTransformation2D : ", BlocksOp.GetErrorCode()
return anObj
-"""
+def Propagate(theShape):
+ """
* 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.
* \return List of GEOM_Objects, each of them is a propagation group.
* Example: see GEOM_TestOthers.py
-"""
-def Propagate(theShape):
+ """
listChains = BlocksOp.Propagate(theShape)
if BlocksOp.IsDone() == 0:
print "Propagate : ", BlocksOp.GetErrorCode()
# Group operations
# -----------------------------------------------------------------------------
-"""
+def CreateGroup(theMainShape, theShapeType):
+ """
* Creates a new group which will store sub shapes of theMainShape
* \param theMainShape is a GEOM object on which the group is selected
* \param theShapeType defines a shape type of the group
* \return a newly created GEOM group
* Example: see GEOM_TestOthers.py
-"""
-def CreateGroup(theMainShape, theShapeType):
+ """
anObj = GroupOp.CreateGroup(theMainShape, theShapeType)
if GroupOp.IsDone() == 0:
print "CreateGroup : ", GroupOp.GetErrorCode()
return anObj
-"""
+def AddObject(theGroup, theSubShapeID):
+ """
* Adds a sub object with ID theSubShapeId to the group
* \param theGroup is a GEOM group to which the new sub shape is added
* \param theSubShapeID is a sub shape ID in the main object.
* \note Use method GetSubShapeID() to get an unique ID of the sub shape
* Example: see GEOM_TestOthers.py
-"""
-def AddObject(theGroup, theSubShapeID):
+ """
GroupOp.AddObject(theGroup, theSubShapeID)
if GroupOp.IsDone() == 0:
print "AddObject : ", GroupOp.GetErrorCode()
-"""
+def RemoveObject(theGroup, theSubShapeID):
+ """
* Removes a sub object with ID \a theSubShapeId from the group
* \param theGroup is a GEOM group from which the new sub shape is removed
* \param theSubShapeID is a sub shape ID in the main object.
* \note Use method GetSubShapeID() to get an unique ID of the sub shape
* Example: see GEOM_TestOthers.py
-"""
-def RemoveObject(theGroup, theSubShapeID):
+ """
GroupOp.RemoveObject(theGroup, theSubShapeID)
if GroupOp.IsDone() == 0:
print "RemoveObject : ", GroupOp.GetErrorCode()
-"""
+def GetObjectIDs(theGroup):
+ """
* Returns a list of sub objects ID stored in the group
* \param theGroup is a GEOM group for which a list of IDs is requested
* Example: see GEOM_TestOthers.py
-"""
-def GetObjectIDs(theGroup):
+ """
ListIDs = GroupOp.GetObjects(theGroup)
if GroupOp.IsDone() == 0:
print "GetObjectIDs : ", GroupOp.GetErrorCode()
return ListIDs
-"""
+def GetType(theGroup):
+ """
* Returns a type of sub objects stored in the group
* \param theGroup is a GEOM group which type is returned.
* Example: see GEOM_TestOthers.py
-"""
-def GetType(theGroup):
+ """
aType = GroupOp.GetType(theGroup)
if GroupOp.IsDone() == 0:
print "GetType : ", GroupOp.GetErrorCode()
return aType
-"""
+def GetMainShape(theGroup):
+ """
* Returns a main shape associated with the group
* \param theGroup is a GEOM group for which a main shape object is requested
* \return a GEOM object which is a main shape for theGroup
* Example: see GEOM_TestOthers.py
-"""
-def GetMainShape(theGroup):
+ """
anObj = GroupOp.GetMainShape(theGroup)
if GroupOp.IsDone() == 0:
print "GetMainShape : ", GroupOp.GetErrorCode()
return anObj
-"""
- * Add Path to the system path
-"""
def addPath(Path):
+ """
+ * Add Path to load python scripts from
+ """
if (sys.path.count(Path) < 1):
sys.path.append(Path)
