# Package geompy

## Functions
def | init_geom
def | SubShapeName
| Get name for sub-shape aSubObj of shape aMainObj.
def | addToStudy
| Publish in study aShape with name aName.
def | addToStudyInFather
| Publish in study aShape with name aName as sub-object of previously published aFather.
def | MakeVertex
| Create point by three coordinates.
def | MakeVertexWithRef
| Create a point, distant from the referenced point on the given distances along the coordinate axes.
def | MakeVertexOnCurve
| Create a point, corresponding to the given parameter on the given curve.
def | MakeVectorDXDYDZ
| Create a vector with the given components.
def | MakeVector
| Create a vector between two points.
def | MakeLine
| Create a line, passing through the given point and parrallel to the given direction.
def | MakeLineTwoPnt
| Create a line, passing through the given points.
def | MakePlane
| Create a plane, passing through the given point and normal to the given vector.
def | MakePlaneThreePnt
| Create a plane, passing through the three given points.
def | MakePlaneFace
| Create a plane, similar to the existing one, but with another size of representing face.
def | MakeMarker
| Create a local coordinate system.
def | MakeMarkerPntTwoVec
| Create a local coordinate system.
def | MakeArc
| Create an arc of circle, passing through three given points.
def | MakeCircle
| Create a circle with given center, normal vector and radius.
def | MakeCircleThreePnt
| Create a circle, passing through three given points.
def | MakeEllipse
| Create an ellipse with given center, normal vector and radiuses.
def | MakePolyline
| Create a polyline on the set of points.
def | MakeBezier
| Create bezier curve on the set of points.
def | MakeInterpol
| Create B-Spline curve on the set of points.
def | MakeSketcher
| Create a sketcher (wire or face), following the textual description, passed through theCommand argument.
def | MakeSketcherOnPlane
| Create a sketcher (wire or face), following the textual description, passed through theCommand argument.
def | MakeBox
| Create a box by coordinates of two opposite vertices.
def | MakeBoxDXDYDZ
| Create a box with specified dimensions along the coordinate axes and with edges, parallel to the coordinate axes.
def | MakeBoxTwoPnt
| Create a box with two specified opposite vertices, and with edges, parallel to the coordinate axes.
def | MakeCylinder
| Create a cylinder with given base point, axis, radius and height.
def | MakeCylinderRH
| Create a cylinder with given radius and height at the origin of coordinate system.
def | MakeSpherePntR
| Create a sphere with given center and radius.
def | MakeSphere
| Create a sphere with given center and radius.
def | MakeSphereR
| Create a sphere with given radius at the origin of coordinate system.
def | MakeCone
| Create a cone with given base point, axis, height and radiuses.
def | MakeConeR1R2H
| Create a cone with given height and radiuses at the origin of coordinate system.
def | MakeTorus
| Create a torus with given center, normal vector and radiuses.
def | MakeTorusRR
| Create a torus with given radiuses at the origin of coordinate system.
def | MakePrism
| Create a shape by extrusion of the base shape along a vector, defined by two points.
def | MakePrismVecH
| Create a shape by extrusion of the base shape along the vector, i.e.
def | MakePipe
| Create a shape by extrusion of the base shape along the path shape.
def | MakeRevolution
| Create a shape by revolution of the base shape around the axis on the given angle, i.e.
def | MakeEdge
| Create a linear edge with specified ends.
def | MakeWire
| Create a wire from the set of edges and wires.
def | MakeFace
| Create a face on the given wire.
def | MakeFaceWires
| Create a face on the given wires set.
def | MakeFaces
| Shortcut to MakeFaceWires().
def | MakeShell
| Create a shell from the set of faces and shells.
def | MakeSolid
| Create a solid, bounded by the given shells.
def | MakeCompound
| Create a compound of the given shapes.
def | NumberOfFaces
| Gives quantity of faces in the given shape.
def | NumberOfEdges
| Gives quantity of edges in the given shape.
def | ChangeOrientation
| Reverses an orientation the given shape.
def | OrientationChange
| Shortcut to ChangeOrientation().
def | GetFreeFacesIDs
| Retrieve all free faces from the given shape.
def | GetSharedShapes
| Get all sub-shapes of theShape1 of the given type, shared with theShape2.
def | GetShapesOnPlane
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified plane by the certain way, defined through theState parameter.
def | GetShapesOnPlaneIDs
| Works like the above method, but returns list of sub-shapes indices.
def | GetShapesOnCylinder
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified cylinder by the certain way, defined through theState parameter.
def | GetShapesOnCylinderIDs
| Works like the above method, but returns list of sub-shapes indices.
def | GetShapesOnSphere
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified sphere by the certain way, defined through theState parameter.
def | GetShapesOnSphereIDs
| Works like the above method, but returns list of sub-shapes indices.
def | GetShapesOnQuadrangle
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified quadrangle by the certain way, defined through theState parameter.
def | GetShapesOnQuadrangleIDs
| Works like the above method, but returns list of sub-shapes indices.
def | GetInPlace
| Get sub-shape(s) of theShapeWhere, which are coincident with theShapeWhat or could be a part of it.
def | GetSubShape
| Obtain a composite sub-shape of <aShape>, composed from sub-shapes of <aShape>, selected by their unique IDs inside <aShape>.
def | GetSubShapeID
| Obtain unique ID of sub-shape <aSubShape> inside <aShape>.
def | SubShapeAll
| Explode a shape on subshapes of a given type.
def | SubShapeAllIDs
| Explode a shape on subshapes of a given type.
def | SubShapeAllSorted
| Explode a shape on subshapes of a given type.
def | SubShapeAllSortedIDs
| Explode a shape on subshapes of a given type.
def | SubShape
| Obtain a compound of sub-shapes of <aShape>, selected by they indices in list of all sub-shapes of type <aType>.
def | SubShapeSorted
| Obtain a compound of sub-shapes of <aShape>, selected by they indices in sorted list of all sub-shapes of type <aType>.
def | ProcessShape
| Apply a sequence of Shape Healing operators to the given object.
def | SuppressFaces
| Remove faces from the given object (shape).
def | MakeSewing
| Sewing of some shapes into single shape.
def | Sew
| Sewing of the given object.
def | SuppressInternalWires
| Remove internal wires and edges from the given object (face).
def | SuppressHoles
| Remove internal closed contours (holes) from the given object.
def | CloseContour
| Close an open wire.
def | DivideEdge
| Addition of a point to a given edge object.
def | GetFreeBoundary
| Get a list of wires (wrapped in GEOM_Object-s), that constitute a free boundary of the given shape.
def | MakeCopy
| Create a copy of the given object.
def | MakeFilling
| Create a filling from the given compound of contours.
def | MakeGlueFaces
| Replace coincident faces in theShape by one face.
def | MakeBoolean
| Perform one of boolean operations on two given shapes.
def | MakeCommon
| Shortcut to MakeBoolean(s1, s2, 1).
def | MakeCut
| Shortcut to MakeBoolean(s1, s2, 2).
def | MakeFuse
| Shortcut to MakeBoolean(s1, s2, 3).
def | MakeSection
| Shortcut to MakeBoolean(s1, s2, 4).
def | MakePartition
| Perform partition operation.
def | Partition
| Shortcut to MakePartition().
def | MakeHalfPartition
| Perform partition of the Shape with the Plane.
def | MakeTranslationTwoPoints
| Translate the given object along the vector, specified by its end points, creating its copy before the translation.
def | MakeTranslation
| Translate the given object along the vector, specified by its components, creating its copy before the translation.
def | MakeTranslationVector
| Translate the given object along the given vector, creating its copy before the translation.
def | MakeRotation
| Rotate the given object around the given axis on the given angle, creating its copy before the rotatation.
def | MakeScaleTransform
| Scale the given object by the factor, creating its copy before the scaling.
def | MakeMirrorByPlane
| Create an object, symmetrical to the given one relatively the given plane.
def | MakeMirrorByAxis
| Create an object, symmetrical to the given one relatively the given axis.
def | MakeMirrorByPoint
| Create an object, symmetrical to the given one relatively the given point.
def | MakePosition
| Modify the Location of the given object by LCS creating its copy before the setting.
def | MakeOffset
| Create new object as offset of the given one.
def | MakeMultiTranslation1D
| Translate the given object along the given vector a given number times.
def | MakeMultiTranslation2D
| Conseqently apply two specified translations to theObject specified number of times.
def | MultiRotate1D
| Rotate the given object around the given axis a given number times.
def | MultiRotate2D
| Rotate the given object around the given axis on the given angle a given number times and multi-translate each rotation result.
def | MakeMultiRotation1D
| The same, as MultiRotate1D(), but axis is given by direction and point.
def | MakeMultiRotation2D
| The same, as MultiRotate2D(), but axis is given by direction and point.
def | MakeFilletAll
| Perform a fillet on all edges of the given shape.
def | MakeFillet
| Perform a fillet on the specified edges/faces of the given shape.
def | MakeChamferAll
| Perform a symmetric chamfer on all edges of the given shape.
def | MakeChamferEdge
| Perform a chamfer on edges, common to the specified faces, with distance D1 on the Face1.
def | MakeChamferFaces
| Perform a chamfer on all edges of the specified faces, with distance D1 on the first specified face (if several for one edge).
def | MakeChamfer
| Shortcut to MakeChamferEdge() and MakeChamferFaces().
def | Archimede
| Perform an Archimde operation on the given shape with given parameters.
def | PointCoordinates
| Get point coordinates.
def | BasicProperties
| Get summarized length of all wires, area of surface and volume of the given shape.
def | BoundingBox
| Get parameters of bounding box of the given shape.
def | Inertia
| Get inertia matrix and moments of inertia of theShape.
def | MinDistance
| Get minimal distance between the given shapes.
def | Tolerance
| Get min and max tolerances of sub-shapes of theShape.
def | WhatIs
| Obtain description of the given shape (number of sub-shapes of each type).
def | MakeCDG
| Get a point, situated at the centre of mass of theShape.
def | CheckShape
| Check a topology of the given shape.
def | Import
| Import a shape from the BREP or IGES or STEP file (depends on given format) with given name.
def | ImportBREP
| Shortcut to Import() for BREP format.
def | ImportIGES
| Shortcut to Import() for IGES format.
def | ImportSTEP
| Shortcut to Import() for STEP format.
def | Export
| Export the given shape into a file with given name.
def | ExportBREP
| Shortcut to Export() for BREP format.
def | ExportIGES
| Shortcut to Export() for IGES format.
def | ExportSTEP
| Shortcut to Export() for STEP format.
def | MakeQuad
| Create a quadrangle face from four edges.
def | MakeQuad2Edges
| Create a quadrangle face on two edges.
def | MakeQuad4Vertices
| Create a quadrangle face with specified corners.
def | MakeHexa
| Create a hexahedral solid, bounded by the six given faces.
def | MakeHexa2Faces
| Create a hexahedral solid between two given faces.
def | GetPoint
| Get a vertex, found in the given shape by its coordinates.
def | GetEdge
| Get an edge, found in the given shape by two given vertices.
def | GetEdgeNearPoint
| Find an edge of the given shape, which has minimal distance to the given point.
def | GetFaceByPoints
| Returns a face, found in the given shape by four given corner vertices.
def | GetFaceByEdges
| Get a face of block, found in the given shape by two given edges.
def | GetOppositeFace
| Find a face, opposite to the given one in the given block.
def | GetFaceNearPoint
| Find a face of the given shape, which has minimal distance to the given point.
def | GetFaceByNormale
| Find a face of block, whose outside normale has minimal angle with the given vector.
def | CheckCompoundOfBlocks
| Check, if the compound of blocks is given.
def | RemoveExtraEdges
| Remove all seam and degenerated edges from theShape.
def | CheckAndImprove
| Check, if the given shape is a blocks compound.
def | MakeBlockExplode
| Get all the blocks, contained in the given compound.
def | GetBlockNearPoint
| Find block, containing the given point inside its volume or on boundary.
def | GetBlockByParts
| Find block, containing all the elements, passed as the parts, or maximum quantity of them.
def | GetBlocksByParts
| Return all blocks, containing all the elements, passed as the parts.
def | MakeMultiTransformation1D
| Multi-transformate block and glue the result.
def | MakeMultiTransformation2D
| Multi-transformate block and glue the result.
def | Propagate
| Build all possible propagation groups.
def | CreateGroup
| Creates a new group which will store sub shapes of theMainShape.
def | AddObject
| Adds a sub object with ID theSubShapeId to the group.
def | RemoveObject
| Removes a sub object with ID theSubShapeId from the group.
def | UnionList
| Adds to the group all the given shapes.
def | UnionIDs
| Works like the above method, but argument theSubShapes here is a list of sub-shapes indices.
def | DifferenceList
| Removes from the group all the given shapes.
def | DifferenceIDs
| Works like the above method, but argument theSubShapes here is a list of sub-shapes indices.
def | GetObjectIDs
| Returns a list of sub objects ID stored in the group.
def | GetType
| Returns a type of sub objects stored in the group.
def | GetMainShape
| Returns a main shape associated with the group.
def | GetEdgesByLength
def | SelectEdges
def | addPath
| Add Path to load python scripts from.
## Variables
tuple | g = lcc.FindOrLoadComponent("FactoryServer", "GEOM")
tuple | geom = g._narrow( GEOM.GEOM_Gen )
| myBuilder = None
int | myStudyId = 0
| father = None
| BasicOp = None
| CurvesOp = None
| PrimOp = None
| ShapesOp = None
| HealOp = None
| InsertOp = None
| BoolOp = None
| TrsfOp = None
| LocalOp = None
| MeasuOp = None
| BlocksOp = None
| GroupOp = None
dictionary | ShapeType = {"COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}
tuple | g = lcc.FindOrLoadComponent("FactoryServer", "GEOM")
tuple | geom = g._narrow( GEOM.GEOM_Gen )
| myBuilder = None
int | myStudyId = 0
| father = None
| BasicOp = None
| CurvesOp = None
| PrimOp = None
| ShapesOp = None
| HealOp = None
| InsertOp = None
| BoolOp = None
| TrsfOp = None
| LocalOp = None
| MeasuOp = None
| BlocksOp = None
| GroupOp = None
dictionary | ShapeType = {"COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}

## Function Documentation

def geompy::init_geom | ( |  | theStudy | ) |

def geompy::SubShapeName | ( |  | aSubObj,
|  |  | aMainObj
| ) |

| Example: see GEOM_TestAll.py

def geompy::addToStudy | ( |  | aShape,
|  |  | aName
| ) |

| Example: see GEOM_TestAll.py

def geompy::addToStudyInFather | ( |  | aFather,
|  |  | aShape,
|  |  | aName
| ) |

| Example: see GEOM_TestAll.py

def geompy::MakeVertex | ( |  | theX,
|  |  | theY,
|  |  | theZ
| ) |

  | Parameters:
  | theX | The X coordinate of the point.
  | theY | The Y coordinate of the point.
  | theZ | The Z coordinate of the point.
Returns: New GEOM_Object, containing the created point. Example: see GEOM_TestAll.py

def geompy::MakeVertexWithRef | ( |  | theReference,
|  |  | theX,
|  |  | theY,
|  |  | theZ
| ) |

  | Parameters:
  | theReference | The referenced point.
  | theX | Displacement from the referenced point along OX axis.
  | theY | Displacement from the referenced point along OY axis.
  | theZ | Displacement from the referenced point along OZ axis.
Returns: New GEOM_Object, containing the created point. Example: see GEOM_TestAll.py

def geompy::MakeVertexOnCurve | ( |  | theRefCurve,
|  |  | theParameter
| ) |

  | Parameters:
  | theRefCurve | The referenced curve.
  | theParameter | Value of parameter on the referenced curve.
Returns: New GEOM_Object, containing the created point. Example: see GEOM_TestAll.py

def geompy::MakeVectorDXDYDZ | ( |  | theDX,
|  |  | theDY,
|  |  | theDZ
| ) |

  | Parameters:
  | theDX | X component of the vector.
  | theDY | Y component of the vector.
  | theDZ | Z component of the vector.
Returns: New GEOM_Object, containing the created vector. Example: see GEOM_TestAll.py

def geompy::MakeVector | ( |  | thePnt1,
|  |  | thePnt2
| ) |

  | Parameters:
  | thePnt1 | Start point for the vector.
  | thePnt2 | End point for the vector.
Returns: New GEOM_Object, containing the created vector.

def geompy::MakeLine | ( |  | thePnt,
|  |  | theDir
| ) |

  | Parameters:
  | thePnt | Point. The resulting line will pass through it.
  | theDir | Direction. The resulting line will be parallel to it.
Returns: New GEOM_Object, containing the created line. Example: see GEOM_TestAll.py

def geompy::MakeLineTwoPnt | ( |  | thePnt1,
|  |  | thePnt2
| ) |

  | Parameters:
  | thePnt1 | First of two points, defining the line.
  | thePnt2 | Second of two points, defining the line.
Returns: New GEOM_Object, containing the created line. Example: see GEOM_TestAll.py

def geompy::MakePlane | ( |  | thePnt,
|  |  | theVec,
|  |  | theTrimSize
| ) |

  | Parameters:
  | thePnt | Point, the plane has to pass through.
  | theVec | Vector, defining the plane normal direction.
  | theTrimSize | Half size of a side of quadrangle face, representing the plane.
Returns: New GEOM_Object, containing the created plane. Example: see GEOM_TestAll.py

def geompy::MakePlaneThreePnt | ( |  | thePnt1,
|  |  | thePnt2,
|  |  | thePnt3,
|  |  | theTrimSize
| ) |

  | Parameters:
  | thePnt1 | First of three points, defining the plane.
  | thePnt2 | Second of three points, defining the plane.
  | thePnt3 | Fird of three points, defining the plane.
  | theTrimSize | Half size of a side of quadrangle face, representing the plane.
Returns: New GEOM_Object, containing the created plane. Example: see GEOM_TestAll.py

def geompy::MakePlaneFace | ( |  | theFace,
|  |  | theTrimSize
| ) |

  | Parameters:
  | theFace | Referenced plane.
  | theTrimSize | New half size of a side of quadrangle face, representing the plane.
Returns: New GEOM_Object, containing the created plane. Example: see GEOM_TestAll.py

def geompy::MakeMarker | ( |  | OX,
|  |  | OY,
|  |  | OZ,
|  |  | XDX,
|  |  | XDY,
|  |  | XDZ,
|  |  | YDX,
|  |  | YDY,
|  |  | YDZ
| ) |

  | 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
Returns: New GEOM_Object, containing the created coordinate system. Example: see GEOM_TestAll.py

def geompy::MakeMarkerPntTwoVec | ( |  | theOrigin,
|  |  | theXVec,
|  |  | theYVec
| ) |

  | Parameters:
  | theOrigin | Point of coordinate system origin.
  | theXVec | Vector of X direction
  | theYVec | Vector of Y direction
Returns: New GEOM_Object, containing the created coordinate system.

def geompy::MakeArc | ( |  | thePnt1,
|  |  | thePnt2,
|  |  | thePnt3
| ) |

  | Parameters:
  | thePnt1 | Start point of the arc.
  | thePnt2 | Middle point of the arc.
  | thePnt3 | End point of the arc.
Returns: New GEOM_Object, containing the created arc. Example: see GEOM_TestAll.py

def geompy::MakeCircle | ( |  | thePnt,
|  |  | theVec,
|  |  | theR
| ) |

  | Parameters:
  | thePnt | Circle center.
  | theVec | Vector, normal to the plane of the circle.
  | theR | Circle radius.
Returns: New GEOM_Object, containing the created circle. Example: see GEOM_TestAll.py

def geompy::MakeCircleThreePnt | ( |  | thePnt1,
|  |  | thePnt2,
|  |  | thePnt3
| ) |

  | Parameters:
  | thePnt1,thePnt2,thePnt3 | Points, defining the circle.
Returns: New GEOM_Object, containing the created circle. Example: see GEOM_TestAll.py

def geompy::MakeEllipse | ( |  | thePnt,
|  |  | theVec,
|  |  | theRMajor,
|  |  | theRMinor
| ) |

  | Parameters:
  | thePnt | Ellipse center.
  | theVec | Vector, normal to the plane of the ellipse.
  | theRMajor | Major ellipse radius.
  | theRMinor | Minor ellipse radius.
Returns: New GEOM_Object, containing the created ellipse. Example: see GEOM_TestAll.py

def geompy::MakePolyline | ( |  | thePoints | ) |

  | Parameters:
  | thePoints | Sequence of points for the polyline.
Returns: New GEOM_Object, containing the created polyline. Example: see GEOM_TestAll.py

def geompy::MakeBezier | ( |  | thePoints | ) |

  | Parameters:
  | thePoints | Sequence of points for the bezier curve.
Returns: New GEOM_Object, containing the created bezier curve. Example: see GEOM_TestAll.py

def geompy::MakeInterpol | ( |  | thePoints | ) |

  | Parameters:
  | thePoints | Sequence of points for the B-Spline curve.
Returns: New GEOM_Object, containing the created B-Spline curve. Example: see GEOM_TestAll.py

def geompy::MakeSketcher | ( |  | theCommand,
|  |  | theWorkingPlane = `[0`
| ) |

  | Edges of the resulting wire or face will be arcs of circles and/or linear segments. Format of the description string have to be the following: "Sketcher[:F x1 y1]:CMD[:CMD[:CMD...]]" Where: x1, y1 are coordinates of the first sketcher point (zero by default), 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 "IX x" : Create segment by direction & Intersect. X "IY y" : Create segment by direction & Intersect. Y "C radius length" : Create arc by direction, radius and length(in degree) "WW" : Close Wire (to finish) "WF" : Close Wire and build face (to finish) Parameters:
  | theCommand | String, defining the sketcher in local coordinates of the working plane.
  | theWorkingPlane | Nine double values, defining origin, OZ and OX directions of the working plane.
Returns: New GEOM_Object, containing the created wire. Example: see GEOM_TestAll.py

def geompy::MakeSketcherOnPlane | ( |  | theCommand,
|  |  | theWorkingPlane
| ) |

  | For format of the description string see the previous method. Parameters:
  | theCommand | String, defining the sketcher in local coordinates of the working plane.
  | theWorkingPlane | Planar Face of the working plane.
Returns: New GEOM_Object, containing the created wire.

def geompy::MakeBox | ( |  | x1,
|  |  | y1,
|  |  | z1,
|  |  | x2,
|  |  | y2,
|  |  | z2
| ) |

| Example: see GEOM_TestAll.py

def geompy::MakeBoxDXDYDZ | ( |  | theDX,
|  |  | theDY,
|  |  | theDZ
| ) |

  | Center of the box will be at point (DX/2, DY/2, DZ/2). Parameters:
  | theDX | Length of Box edges, parallel to OX axis.
  | theDY | Length of Box edges, parallel to OY axis.
  | theDZ | Length of Box edges, parallel to OZ axis.
Returns: New GEOM_Object, containing the created box. Example: see GEOM_TestAll.py

def geompy::MakeBoxTwoPnt | ( |  | thePnt1,
|  |  | thePnt2
| ) |

  | Parameters:
  | thePnt1 | First of two opposite vertices.
  | thePnt2 | Second of two opposite vertices.
Returns: New GEOM_Object, containing the created box. Example: see GEOM_TestAll.py

def geompy::MakeCylinder | ( |  | thePnt,
|  |  | theAxis,
|  |  | theR,
|  |  | theH
| ) |

  | Parameters:
  | thePnt | Central point of cylinder base.
  | theAxis | Cylinder axis.
  | theR | Cylinder radius.
  | theH | Cylinder height.
Returns: New GEOM_Object, containing the created cylinder. Example: see GEOM_TestAll.py

def geompy::MakeCylinderRH | ( |  | theR,
|  |  | theH
| ) |

  | Axis of the cylinder will be collinear to the OZ axis of the coordinate system. Parameters:
  | theR | Cylinder radius.
  | theH | Cylinder height.
Returns: New GEOM_Object, containing the created cylinder. Example: see GEOM_TestAll.py

def geompy::MakeSpherePntR | ( |  | thePnt,
|  |  | theR
| ) |

  | Parameters:
  | thePnt | Sphere center.
  | theR | Sphere radius.
Returns: New GEOM_Object, containing the created sphere. Example: see GEOM_TestAll.py

def geompy::MakeSphere | ( |  | x,
|  |  | y,
|  |  | z,
|  |  | theR
| ) |

  | Parameters:
  | x,y,z | Coordinates of sphere center.
  | theR | Sphere radius.
Returns: New GEOM_Object, containing the created sphere. Example: see GEOM_TestAll.py

def geompy::MakeSphereR | ( |  | theR | ) |

  | Parameters:
  | theR | Sphere radius.
Returns: New GEOM_Object, containing the created sphere. Example: see GEOM_TestAll.py

def geompy::MakeCone | ( |  | thePnt,
|  |  | theAxis,
|  |  | theR1,
|  |  | theR2,
|  |  | theH
| ) |

  | Parameters:
  | thePnt | Central point of the first cone base.
  | theAxis | Cone axis.
  | theR1 | Radius of the first cone base.
  | theR2 | Radius of the second cone base.
  Note: If both radiuses are non-zero, the cone will be truncated. If the radiuses are equal, a cylinder will be created instead. Parameters:
  | theH | Cone height.
Returns: New GEOM_Object, containing the created cone. Example: see GEOM_TestAll.py

def geompy::MakeConeR1R2H | ( |  | theR1,
|  |  | theR2,
|  |  | theH
| ) |

  | Axis of the cone will be collinear to the OZ axis of the coordinate system. Parameters:
  | theR1 | Radius of the first cone base.
  | theR2 | Radius of the second cone base.
  Note: If both radiuses are non-zero, the cone will be truncated. If the radiuses are equal, a cylinder will be created instead. Parameters:
  | theH | Cone height.
Returns: New GEOM_Object, containing the created cone. Example: see GEOM_TestAll.py

def geompy::MakeTorus | ( |  | thePnt,
|  |  | theVec,
|  |  | theRMajor,
|  |  | theRMinor
| ) |

  | Parameters:
  | thePnt | Torus central point.
  | theVec | Torus axis of symmetry.
  | theRMajor | Torus major radius.
  | theRMinor | Torus minor radius.
Returns: New GEOM_Object, containing the created torus. Example: see GEOM_TestAll.py

def geompy::MakeTorusRR | ( |  | theRMajor,
|  |  | theRMinor
| ) |

  | Parameters:
  | theRMajor | Torus major radius.
  | theRMinor | Torus minor radius.
Returns: New GEOM_Object, containing the created torus. Example: see GEOM_TestAll.py

def geompy::MakePrism | ( |  | theBase,
|  |  | thePoint1,
|  |  | thePoint2
| ) |

  | Parameters:
  | theBase | Base shape to be extruded.
  | thePoint1 | First end of extrusion vector.
  | thePoint2 | Second end of extrusion vector.
Returns: New GEOM_Object, containing the created prism. Example: see GEOM_TestAll.py

def geompy::MakePrismVecH | ( |  | theBase,
|  |  | theVec,
|  |  | theH
| ) |

  | all the space, transfixed by the base shape during its translation along the vector on the given distance. Parameters:
  | theBase | Base shape to be extruded.
  | theVec | Direction of extrusion.
  | theH | Prism dimension along theVec.
Returns: New GEOM_Object, containing the created prism. Example: see GEOM_TestAll.py

def geompy::MakePipe | ( |  | theBase,
|  |  | thePath
| ) |

  | The path shape can be a wire or an edge. Parameters:
  | theBase | Base shape to be extruded.
  | thePath | Path shape to extrude the base shape along it.
Returns: New GEOM_Object, containing the created pipe. Example: see GEOM_TestAll.py

def geompy::MakeRevolution | ( |  | theBase,
|  |  | theAxis,
|  |  | theAngle
| ) |

  | all the space, transfixed by the base shape during its rotation around the axis on the given angle. Parameters:
  | theBase | Base shape to be rotated.
  | theAxis | Rotation axis.
  | theAngle | Rotation angle in radians.
Returns: New GEOM_Object, containing the created revolution. Example: see GEOM_TestAll.py

def geompy::MakeEdge | ( |  | thePnt1,
|  |  | thePnt2
| ) |

  | Parameters:
  | thePnt1 | Point for the first end of edge.
  | thePnt2 | Point for the second end of edge.
Returns: New GEOM_Object, containing the created edge. Example: see GEOM_TestAll.py

def geompy::MakeWire | ( |  | theEdgesAndWires | ) |

  | Parameters:
  | theEdgesAndWires | List of edges and/or wires.
Returns: New GEOM_Object, containing the created wire. Example: see GEOM_TestAll.py

def geompy::MakeFace | ( |  | theWire,
|  |  | isPlanarWanted
| ) |

  | Parameters:
  | theWire | Wire to build the face on.
  | isPlanarWanted | If TRUE, only planar face will be built. If impossible, NULL object will be returned.
Returns: New GEOM_Object, containing the created face. Example: see GEOM_TestAll.py

def geompy::MakeFaceWires | ( |  | theWires,
|  |  | isPlanarWanted
| ) |

  | Parameters:
  | theWires | List of wires to build the face on.
  | isPlanarWanted | If TRUE, only planar face will be built. If impossible, NULL object will be returned.
Returns: New GEOM_Object, containing the created face. Example: see GEOM_TestAll.py

def geompy::MakeFaces | ( |  | theWires,
|  |  | isPlanarWanted
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeShell | ( |  | theFacesAndShells | ) |

  | Parameters:
  | theFacesAndShells | List of faces and/or shells.
Returns: New GEOM_Object, containing the created shell. Example: see GEOM_TestAll.py

def geompy::MakeSolid | ( |  | theShells | ) |

  | Parameters:
  | theShells | Sequence of bounding shells.
Returns: New GEOM_Object, containing the created solid. Example: see GEOM_TestAll.py

def geompy::MakeCompound | ( |  | theShapes | ) |

  | Parameters:
  | theShapes | List of shapes to put in compound.
Returns: New GEOM_Object, containing the created compound. Example: see GEOM_TestAll.py

def geompy::NumberOfFaces | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to count faces of.
Returns: Quantity of faces. Example: see GEOM_TestOthers.py

def geompy::NumberOfEdges | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to count edges of.
Returns: Quantity of edges. Example: see GEOM_TestOthers.py

def geompy::ChangeOrientation | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to be reversed.
Returns: The reversed copy of theShape. Example: see GEOM_TestAll.py

def geompy::OrientationChange | ( |  | theShape | ) |

| Example: see GEOM_TestOthers.py

def geompy::GetFreeFacesIDs | ( |  | theShape | ) |

  | Free face is a face, which is not shared between two shells of the shape. Parameters:
  | theShape | Shape to find free faces in.
Returns: List of IDs of all free faces, contained in theShape. Example: see GEOM_TestOthers.py

def geompy::GetSharedShapes | ( |  | theShape1,
|  |  | theShape2,
|  |  | theShapeType
| ) |

  | Parameters:
  | theShape1 | Shape to find sub-shapes in.
  | theShape2 | Shape to find shared sub-shapes with.
  | theShapeType | Type of sub-shapes to be retrieved.
Returns: List of sub-shapes of theShape1, shared with theShape2. Example: see GEOM_TestOthers.py

def geompy::GetShapesOnPlane | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAx1,
|  |  | theState
| ) |

  | Parameters:
  | theShape | Shape to find sub-shapes of.
  | theShapeType | Type of sub-shapes to be retrieved.
  | theAx1 | Vector (or line, or linear edge), specifying normal direction and location of the plane to find shapes on.
  | theState | The state of the subshapes to find. It can be one of ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
Returns: List of all found sub-shapes. Example: see GEOM_TestOthers.py

def geompy::GetShapesOnPlaneIDs | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAx1,
|  |  | theState
| ) |

| Example: see GEOM_TestOthers.py

def geompy::GetShapesOnCylinder | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAxis,
|  |  | theRadius,
|  |  | theState
| ) |

  | Parameters:
  | theShape | Shape to find sub-shapes of.
  | theShapeType | Type of sub-shapes to be retrieved.
  | theAxis | Vector (or line, or linear edge), specifying axis of the cylinder to find shapes on.
  | theRadius | Radius of the cylinder to find shapes on.
  | theState | The state of the subshapes to find. It can be one of ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
Returns: List of all found sub-shapes. Example: see GEOM_TestOthers.py

def geompy::GetShapesOnCylinderIDs | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAxis,
|  |  | theRadius,
|  |  | theState
| ) |

| Example: see GEOM_TestOthers.py

def geompy::GetShapesOnSphere | ( |  | theShape,
|  |  | theShapeType,
|  |  | theCenter,
|  |  | theRadius,
|  |  | theState
| ) |

  | Parameters:
  | theShape | Shape to find sub-shapes of.
  | theShapeType | Type of sub-shapes to be retrieved.
  | theCenter | Point, specifying center of the sphere to find shapes on.
  | theRadius | Radius of the sphere to find shapes on.
  | theState | The state of the subshapes to find. It can be one of ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
Returns: List of all found sub-shapes. Example: see GEOM_TestOthers.py

def geompy::GetShapesOnSphereIDs | ( |  | theShape,
|  |  | theShapeType,
|  |  | theCenter,
|  |  | theRadius,
|  |  | theState
| ) |

| Example: see GEOM_TestOthers.py

def geompy::GetShapesOnQuadrangle | ( |  | theShape,
|  |  | theShapeType,
|  |  | theTopLeftPoint,
|  |  | theTopRigthPoint,
|  |  | theBottomLeftPoint,
|  |  | theBottomRigthPoint,
|  |  | theState
| ) |

  | Parameters:
  | theShape | Shape to find sub-shapes of.
  | theShapeType | Type of sub-shapes to be retrieved.
  | theCenter | Point, specifying center of the sphere to find shapes on.
  | theRadius | Radius of the sphere to find shapes on.
  | theState | The state of the subshapes to find. It can be one of ST_ON, ST_OUT, ST_ONOUT, ST_IN, ST_ONIN.
Returns: List of all found sub-shapes. Example: see GEOM_TestOthers.py

def geompy::GetShapesOnQuadrangleIDs | ( |  | theShape,
|  |  | theShapeType,
|  |  | theTopLeftPoint,
|  |  | theTopRigthPoint,
|  |  | theBottomLeftPoint,
|  |  | theBottomRigthPoint,
|  |  | theState
| ) |

| Example: see GEOM_TestOthers.py

def geompy::GetInPlace | ( |  | theShapeWhere,
|  |  | theShapeWhat
| ) |

  | Parameters:
  | theShapeWhere | Shape to find sub-shapes of.
  | theShapeWhat | Shape, specifying what to find.
Returns: Group of all found sub-shapes or a single found sub-shape. Example: see GEOM_TestOthers.py

def geompy::GetSubShape | ( |  | aShape,
|  |  | ListOfID
| ) |

| Example: see GEOM_TestAll.py

def geompy::GetSubShapeID | ( |  | aShape,
|  |  | aSubShape
| ) |

| Example: see GEOM_TestAll.py

def geompy::SubShapeAll | ( |  | aShape,
|  |  | aType
| ) |

  | Parameters:
  | theShape | Shape to be exploded.
  | theShapeType | Type of sub-shapes to be retrieved.
Returns: List of sub-shapes of type theShapeType, contained in theShape. Example: see GEOM_TestAll.py

def geompy::SubShapeAllIDs | ( |  | aShape,
|  |  | aType
| ) |

  | Parameters:
  | theShape | Shape to be exploded.
  | theShapeType | Type of sub-shapes to be retrieved.
Returns: List of IDs of sub-shapes.

def geompy::SubShapeAllSorted | ( |  | aShape,
|  |  | aType
| ) |

  | Sub-shapes will be sorted by coordinates of their gravity centers. Parameters:
  | theShape | Shape to be exploded.
  | theShapeType | Type of sub-shapes to be retrieved.
Returns: List of sub-shapes of type theShapeType, contained in theShape. Example: see GEOM_TestAll.py

def geompy::SubShapeAllSortedIDs | ( |  | aShape,
|  |  | aType
| ) |

  | Sub-shapes will be sorted by coordinates of their gravity centers. Parameters:
  | theShape | Shape to be exploded.
  | theShapeType | Type of sub-shapes to be retrieved.
Returns: List of IDs of sub-shapes.

def geompy::SubShape | ( |  | aShape,
|  |  | aType,
|  |  | ListOfInd
| ) |

| Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type] Example: see GEOM_TestAll.py

def geompy::SubShapeSorted | ( |  | aShape,
|  |  | aType,
|  |  | ListOfInd
| ) |

| Each index is in range [1, Nb_Sub-Shapes_Of_Given_Type] Example: see GEOM_TestAll.py

def geompy::ProcessShape | ( |  | theShape,
|  |  | theOperators,
|  |  | theParameters,
|  |  | theValues
| ) |

  | Parameters:
  | theShape | Shape to be processed.
  | theOperators | List of names of operators ("FixShape", "SplitClosedFaces", etc.).
  | theParameters | List of names of parameters ("FixShape.Tolerance3d", "SplitClosedFaces.NbSplitPoints", etc.).
  | theValues | List of values of parameters, in the same order as parameters are listed in theParameters list.
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::SuppressFaces | ( |  | theObject,
|  |  | theFaces
| ) |

  | Parameters:
  | theObject | Shape to be processed.
  | theFaces | Indices of faces to be removed, if EMPTY then the method removes ALL faces of the given object.
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::MakeSewing | ( |  | ListShape,
|  |  | theTolerance
| ) |

| Example: see GEOM_TestHealing.py

def geompy::Sew | ( |  | theObject,
|  |  | theTolerance
| ) |

  | Parameters:
  | theObject | Shape to be processed.
  | theTolerance | Required tolerance value.
Returns: New GEOM_Object, containing processed shape. Example: see MakeSewing() above

def geompy::SuppressInternalWires | ( |  | theObject,
|  |  | theWires
| ) |

  | Parameters:
  | theObject | Shape to be processed.
  | theWires | Indices of wires to be removed, if EMPTY then the method removes ALL internal wires of the given object.
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::SuppressHoles | ( |  | theObject,
|  |  | theWires
| ) |

  | Parameters:
  | theObject | Shape to be processed.
  | theWires | Indices of wires to be removed, if EMPTY then the method removes ALL internal holes of the given object
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::CloseContour | ( |  | theObject,
|  |  | theWires,
|  |  | isCommonVertex
| ) |

  | Parameters:
  | theObject | Shape to be processed.
  | theWires | Indexes of edge(s) and wire(s) to be closed within theObject's shape, if -1, then theObject itself is a wire.
  | isCommonVertex | If TRUE : closure by creation of a common vertex, If FALS : closure by creation of an edge between ends.
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::DivideEdge | ( |  | theObject,
|  |  | theEdgeIndex,
|  |  | theValue,
|  |  | isByParameter
| ) |

  | 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.
  | theValue | Value of parameter on edge or length parameter, depending on isByParameter.
  | isByParameter | If TRUE : theValue is treated as a curve parameter [0..1], if FALSE : theValue is treated as a length parameter [0..1]
Returns: New GEOM_Object, containing processed shape. Example: see GEOM_TestHealing.py

def geompy::GetFreeBoundary | ( |  | theObject | ) |

  | Parameters:
  | theObject | Shape to get free boundary of.
Returns: [status, theClosedWires, theOpenWires] status: FALSE, if an error(s) occured 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

def geompy::MakeCopy | ( |  | theOriginal | ) |

| Example: see GEOM_TestAll.py

def geompy::MakeFilling | ( |  | theShape,
|  |  | theMinDeg,
|  |  | theMaxDeg,
|  |  | theTol2D,
|  |  | theTol3D,
|  |  | theNbIter
| ) |

  | Parameters:
  | theShape | the compound of contours
  | theMinDeg | a minimal degree
  | theMaxDeg | a maximal degree
  | theTol2D | a 2d tolerance
  | theTol3D | a 3d tolerance
  | theNbIter | a number of iteration
Returns: New GEOM_Object, containing the created filling surface. Example: see GEOM_TestAll.py

def geompy::MakeGlueFaces | ( |  | theShape,
|  |  | theTolerance
| ) |

  | Parameters:
  | theShape | Initial shape.
  | theTolerance | Maximum distance between faces, which can be considered as coincident.
Returns: New GEOM_Object, containing a copy of theShape without coincident faces. Example: see GEOM_Spanner.py

def geompy::MakeBoolean | ( |  | theShape1,
|  |  | theShape2,
|  |  | theOperation
| ) |

  | Parameters:
  | theShape1 | First argument for boolean operation.
  | theShape2 | Second argument for boolean operation.
  | theOperation | Indicates the operation to be done: 1 - Common, 2 - Cut, 3 - Fuse, 4 - Section.
Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestAll.py

def geompy::MakeCommon | ( |  | s1,
|  |  | s2
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeCut | ( |  | s1,
|  |  | s2
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeFuse | ( |  | s1,
|  |  | s2
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeSection | ( |  | s1,
|  |  | s2
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakePartition | ( |  | ListShapes,
|  |  | ListTools = `[]`,
|  |  | ListKeepInside = `[]`,
|  |  | ListRemoveInside = `[]`,
|  |  | Limit = `ShapeType["SHAPE"]`,
|  |  | RemoveWebs = `0`,
|  |  | ListMaterials = `[]`
| ) |

  | Parameters:
  | ListShapes | Shapes to be intersected.
  | ListTools | Shapes to intersect theShapes.
  | 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.
  | Limit | Type of resulting shapes (corresponding to TopAbs_ShapeEnum).
  | RemoveWebs | If TRUE, perform Glue 3D algorithm.
  | ListMaterials | Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
Returns: New GEOM_Object, containing the result shapes. Example: see GEOM_TestAll.py

def geompy::Partition | ( |  | ListShapes,
|  |  | ListTools = `[]`,
|  |  | ListKeepInside = `[]`,
|  |  | ListRemoveInside = `[]`,
|  |  | Limit = `ShapeType["SHAPE"]`,
|  |  | RemoveWebs = `0`,
|  |  | ListMaterials = `[]`
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeHalfPartition | ( |  | theShape,
|  |  | thePlane
| ) |

  | Parameters:
  | theShape | Shape to be intersected.
  | thePlane | Tool shape, to intersect theShape.
Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestAll.py

def geompy::MakeTranslationTwoPoints | ( |  | theObject,
|  |  | thePoint1,
|  |  | thePoint2
| ) |

  | Parameters:
  | theObject | The object to be translated.
  | thePoint1 | Start point of translation vector.
  | thePoint2 | End point of translation vector.
Returns: New GEOM_Object, containing the translated object. Example: see GEOM_TestAll.py

def geompy::MakeTranslation | ( |  | theObject,
|  |  | theDX,
|  |  | theDY,
|  |  | theDZ
| ) |

  | Parameters:
  | theObject | The object to be translated.
  | theDX,theDY,theDZ | Components of translation vector.
Returns: New GEOM_Object, containing the translated object. Example: see GEOM_TestAll.py

def geompy::MakeTranslationVector | ( |  | theObject,
|  |  | theVector
| ) |

  | Parameters:
  | theObject | The object to be translated.
  | theVector | The translation vector.
Returns: New GEOM_Object, containing the translated object. Example: see GEOM_TestAll.py

def geompy::MakeRotation | ( |  | theObject,
|  |  | theAxis,
|  |  | theAngle
| ) |

  | Parameters:
  | theObject | The object to be rotated.
  | theAxis | Rotation axis.
  | theAngle | Rotation angle in radians.
Returns: New GEOM_Object, containing the rotated object. Example: see GEOM_TestAll.py

def geompy::MakeScaleTransform | ( |  | theObject,
|  |  | thePoint,
|  |  | theFactor
| ) |

  | Parameters:
  | theObject | The object to be scaled.
  | thePoint | Center point for scaling.
  | theFactor | Scaling factor value.
Returns: New GEOM_Object, containing the scaled shape. Example: see GEOM_TestAll.py

def geompy::MakeMirrorByPlane | ( |  | theObject,
|  |  | thePlane
| ) |

  | Parameters:
  | theObject | The object to be mirrored.
  | thePlane | Plane of symmetry.
Returns: New GEOM_Object, containing the mirrored shape. Example: see GEOM_TestAll.py

def geompy::MakeMirrorByAxis | ( |  | theObject,
|  |  | theAxis
| ) |

  | Parameters:
  | theObject | The object to be mirrored.
  | theAxis | Axis of symmetry.
Returns: New GEOM_Object, containing the mirrored shape. Example: see GEOM_TestAll.py

def geompy::MakeMirrorByPoint | ( |  | theObject,
|  |  | thePoint
| ) |

  | Parameters:
  | theObject | The object to be mirrored.
  | thePoint | Point of symmetry.
Returns: New GEOM_Object, containing the mirrored shape. Example: see GEOM_TestAll.py

def geompy::MakePosition | ( |  | theObject,
|  |  | theStartLCS,
|  |  | theEndLCS
| ) |

| Example: see GEOM_TestAll.py

def geompy::MakeOffset | ( |  | theObject,
|  |  | theOffset
| ) |

  | Parameters:
  | theObject | The base object for the offset.
  | theOffset | Offset value.
Returns: New GEOM_Object, containing the offset object. Example: see GEOM_TestAll.py

def geompy::MakeMultiTranslation1D | ( |  | theObject,
|  |  | theVector,
|  |  | theStep,
|  |  | theNbTimes
| ) |

  | Parameters:
  | theObject | The object to be translated.
  | theVector | Direction of the translation.
  | theStep | Distance to translate on.
  | theNbTimes | Quantity of translations to be done.
Returns: New GEOM_Object, containing compound of all the shapes, obtained after each translation. Example: see GEOM_TestAll.py

def geompy::MakeMultiTranslation2D | ( |  | theObject,
|  |  | theVector1,
|  |  | theStep1,
|  |  | theNbTimes1,
|  |  | theVector2,
|  |  | theStep2,
|  |  | theNbTimes2
| ) |

  | Parameters:
  | theObject | The object to be translated.
  | theVector1 | Direction of the first translation.
  | theStep1 | Step of the first translation.
  | theNbTimes1 | Quantity of translations to be done along theVector1.
  | theVector2 | Direction of the second translation.
  | theStep2 | Step of the second translation.
  | theNbTimes2 | Quantity of translations to be done along theVector2.
Returns: New GEOM_Object, containing compound of all the shapes, obtained after each translation. Example: see GEOM_TestAll.py

def geompy::MultiRotate1D | ( |  | theObject,
|  |  | theAxis,
|  |  | theNbTimes
| ) |

  | Rotation angle will be 2*PI/theNbTimes. Parameters:
  | theObject | The object to be rotated.
  | theAxis | The rotation axis.
  | theNbTimes | Quantity of rotations to be done.
Returns: New GEOM_Object, containing compound of all the shapes, obtained after each rotation. Example: see GEOM_TestAll.py

def geompy::MultiRotate2D | ( |  | theObject,
|  |  | theAxis,
|  |  | theAngle,
|  |  | theNbTimes1,
|  |  | theStep,
|  |  | theNbTimes2
| ) |

  | Translation direction passes through center of gravity of rotated shape and its projection on the rotation axis. Parameters:
  | theObject | The object to be rotated.
  | theAxis | Rotation axis.
  | theAngle | Rotation angle in graduces.
  | theNbTimes1 | Quantity of rotations to be done.
  | theStep | Translation distance.
  | theNbTimes2 | Quantity of translations to be done.
Returns: New GEOM_Object, containing compound of all the shapes, obtained after each transformation. Example: see GEOM_TestAll.py

def geompy::MakeMultiRotation1D | ( |  | aShape,
|  |  | aDir,
|  |  | aPoint,
|  |  | aNbTimes
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeMultiRotation2D | ( |  | aShape,
|  |  | aDir,
|  |  | aPoint,
|  |  | anAngle,
|  |  | nbtimes1,
|  |  | aStep,
|  |  | nbtimes2
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeFilletAll | ( |  | theShape,
|  |  | theR
| ) |

  | Parameters:
  | theShape | Shape, to perform fillet on.
  | theR | Fillet radius.
Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestOthers.py

def geompy::MakeFillet | ( |  | theShape,
|  |  | theR,
|  |  | theShapeType,
|  |  | theListShapes
| ) |

  | Parameters:
  | theShape | Shape, to perform fillet on.
  | theR | Fillet radius.
  | theShapeType | Type of shapes in <theListShapes>.
  | theListShapes | Global indices of edges/faces to perform fillet on.
Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID(). Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestAll.py

def geompy::MakeChamferAll | ( |  | theShape,
|  |  | theD
| ) |

  | Parameters:
  | theShape | Shape, to perform chamfer on.
  | theD | Chamfer size along each face.
Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestOthers.py

def geompy::MakeChamferEdge | ( |  | theShape,
|  |  | theD1,
|  |  | theD2,
|  |  | theFace1,
|  |  | theFace2
| ) |

  | Parameters:
  | theShape | Shape, to perform chamfer on.
  | theD1 | Chamfer size along theFace1.
  | theD2 | Chamfer size along theFace2.
  | theFace1,theFace2 | Global indices of two faces of theShape.
Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID(). Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestAll.py

def geompy::MakeChamferFaces | ( |  | theShape,
|  |  | theD1,
|  |  | theD2,
|  |  | theFaces
| ) |

  | Parameters:
  | theShape | Shape, to perform chamfer on.
  | theD1 | Chamfer size along face from theFaces. If both faces, connected to the edge, are in theFaces, theD1 will be get along face, which is nearer to theFaces beginning.
  | theD2 | Chamfer size along another of two faces, connected to the edge.
  | theFaces | Sequence of global indices of faces of theShape.
Note: Global index of sub-shape can be obtained, using method geompy.GetSubShapeID(). Returns: New GEOM_Object, containing the result shape. Example: see GEOM_TestAll.py

def geompy::MakeChamfer | ( |  | aShape,
|  |  | d1,
|  |  | d2,
|  |  | aShapeType,
|  |  | ListShape
| ) |

| Example: see GEOM_TestOthers.py

def geompy::Archimede | ( |  | theShape,
|  |  | theWeight,
|  |  | theWaterDensity,
|  |  | theMeshDeflection
| ) |

  | The object presenting the resulting face is returned. Parameters:
  | theShape | Shape to be put in water.
  | theWeight | Weight og the shape.
  | theWaterDensity | Density of the water.
  | theMeshDeflection | Deflection of the mesh, using to compute the section.
Returns: New GEOM_Object, containing a section of theShape by a plane, corresponding to water level. Example: see GEOM_TestAll.py

def geompy::PointCoordinates | ( |  | Point | ) |

| Returns: [x, y, z] Example: see GEOM_TestMeasures.py

def geompy::BasicProperties | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to define properties of.
Returns: [theLength, theSurfArea, theVolume] theLength: Summarized length of all wires of the given shape. theSurfArea: Area of surface of the given shape. theVolume: Volume of the given shape. Example: see GEOM_TestMeasures.py

def geompy::BoundingBox | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to obtain bounding box of.
Returns: [Xmin,Xmax, Ymin,Ymax, Zmin,Zmax] Xmin,Xmax: Limits of shape along OX axis. Ymin,Ymax: Limits of shape along OY axis. Zmin,Zmax: Limits of shape along OZ axis. Example: see GEOM_TestMeasures.py

def geompy::Inertia | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to calculate inertia of.
Returns: [I11,I12,I13, I21,I22,I23, I31,I32,I33, Ix,Iy,Iz] I(1-3)(1-3): Components of the inertia matrix of the given shape. Ix,Iy,Iz: Moments of inertia of the given shape. Example: see GEOM_TestMeasures.py

def geompy::MinDistance | ( |  | theShape1,
|  |  | theShape2
| ) |

  | Parameters:
  | theShape1,theShape2 | Shapes to find minimal distance between.
Returns: Value of the minimal distance between the given shapes. Example: see GEOM_TestMeasures.py

def geompy::Tolerance | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape, to get tolerances of.
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. VertMin,VertMax: Min and max tolerances of the vertices. Example: see GEOM_TestMeasures.py

def geompy::WhatIs | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to be described.
Returns: Description of the given shape. Example: see GEOM_TestMeasures.py

def geompy::MakeCDG | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to define centre of mass of.
Returns: New GEOM_Object, containing the created point. Example: see GEOM_TestMeasures.py

def geompy::CheckShape | ( |  | theShape | ) |

  | Parameters:
  | theShape | Shape to check validity of.
Returns: 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 geompy::Import | ( |  | theFileName,
|  |  | theFormatName
| ) |

  | Parameters:
  | theFileName | The file, containing the shape.
  | theFormatName | Specify format for the file reading. Available formats can be obtained with InsertOp.ImportTranslators() method.
Returns: New GEOM_Object, containing the imported shape. Example: see GEOM_TestOthers.py

def geompy::ImportBREP | ( |  | theFileName | ) |

| Example: see GEOM_TestOthers.py

def geompy::ImportIGES | ( |  | theFileName | ) |

| Example: see GEOM_TestOthers.py

def geompy::ImportSTEP | ( |  | theFileName | ) |

| Example: see GEOM_TestOthers.py

def geompy::Export | ( |  | theObject,
|  |  | theFileName,
|  |  | theFormatName
| ) |

  | Parameters:
  | theObject | Shape to be stored in the file.
  | theFileName | Name of the file to store the given shape in.
  | theFormatName | Specify format for the shape storage. Available formats can be obtained with InsertOp.ImportTranslators() method.
Example: see GEOM_TestOthers.py

def geompy::ExportBREP | ( |  | theObject,
|  |  | theFileName
| ) |

| Example: see GEOM_TestOthers.py

def geompy::ExportIGES | ( |  | theObject,
|  |  | theFileName
| ) |

| Example: see GEOM_TestOthers.py

def geompy::ExportSTEP | ( |  | theObject,
|  |  | theFileName
| ) |

| Example: see GEOM_TestOthers.py

def geompy::MakeQuad | ( |  | E1,
|  |  | E2,
|  |  | E3,
|  |  | E4
| ) |

  | Order of Edges is not important. It is not necessary that edges share the same vertex. Parameters:
  | E1,E2,E3,E4 | Edges for the face bound.
Returns: New GEOM_Object, containing the created face. Example: see GEOM_Spanner.py

def geompy::MakeQuad2Edges | ( |  | E1,
|  |  | E2
| ) |

  | The missing edges will be built by creating the shortest ones. Parameters:
  | E1,E2 | Two opposite edges for the face.
Returns: New GEOM_Object, containing the created face. Example: see GEOM_Spanner.py

def geompy::MakeQuad4Vertices | ( |  | V1,
|  |  | V2,
|  |  | V3,
|  |  | V4
| ) |

  | The missing edges will be built by creating the shortest ones. Parameters:
  | V1,V2,V3,V4 | Corner vertices for the face.
Returns: New GEOM_Object, containing the created face. Example: see GEOM_Spanner.py

def geompy::MakeHexa | ( |  | F1,
|  |  | F2,
|  |  | F3,
|  |  | F4,
|  |  | F5,
|  |  | F6
| ) |

  | Order of faces is not important. It is not necessary that Faces share the same edge. Parameters:
  | F1,F2,F3,F4,F5,F6 | Faces for the hexahedral solid.
Returns: New GEOM_Object, containing the created solid. Example: see GEOM_Spanner.py

def geompy::MakeHexa2Faces | ( |  | F1,
|  |  | F2
| ) |

  | The missing faces will be built by creating the smallest ones. Parameters:
  | F1,F2 | Two opposite faces for the hexahedral solid.
Returns: New GEOM_Object, containing the created solid. Example: see GEOM_Spanner.py

def geompy::GetPoint | ( |  | theShape,
|  |  | theX,
|  |  | theY,
|  |  | theZ,
|  |  | theEpsilon
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | theX,theY,theZ | Coordinates of the sought vertex.
  | theEpsilon | Maximum allowed distance between the resulting vertex and point with the given coordinates.
Returns: New GEOM_Object, containing the found vertex. Example: see GEOM_TestOthers.py

def geompy::GetEdge | ( |  | theShape,
|  |  | thePoint1,
|  |  | thePoint2
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | thePoint1,thePoint2 | Points, close to the ends of the desired edge.
Returns: New GEOM_Object, containing the found edge. Example: see GEOM_Spanner.py

def geompy::GetEdgeNearPoint | ( |  | theShape,
|  |  | thePoint
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | thePoint | Point, close to the desired edge.
Returns: New GEOM_Object, containing the found edge. Example: see GEOM_TestOthers.py

def geompy::GetFaceByPoints | ( |  | theShape,
|  |  | thePoint1,
|  |  | thePoint2,
|  |  | thePoint3,
|  |  | thePoint4
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | thePoint1-thePoint4 | Points, close to the corners of the desired face.
Returns: New GEOM_Object, containing the found face. Example: see GEOM_Spanner.py

def geompy::GetFaceByEdges | ( |  | theShape,
|  |  | theEdge1,
|  |  | theEdge2
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | theEdge1,theEdge2 | Edges, close to the edges of the desired face.
Returns: New GEOM_Object, containing the found face. Example: see GEOM_Spanner.py

def geompy::GetOppositeFace | ( |  | theBlock,
|  |  | theFace
| ) |

  | Parameters:
  | theBlock | Must be a hexahedral solid.
  | theFace | Face of theBlock, opposite to the desired face.
Returns: New GEOM_Object, containing the found face. Example: see GEOM_Spanner.py

def geompy::GetFaceNearPoint | ( |  | theShape,
|  |  | thePoint
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | thePoint | Point, close to the desired face.
Returns: New GEOM_Object, containing the found face. Example: see GEOM_Spanner.py

def geompy::GetFaceByNormale | ( |  | theBlock,
|  |  | theVector
| ) |

  | Parameters:
  | theShape | Block or a compound of blocks.
  | theVector | Vector, close to the normale of the desired face.
Returns: New GEOM_Object, containing the found face. Example: see GEOM_Spanner.py

def geompy::CheckCompoundOfBlocks | ( |  | theCompound | ) |

-   | 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). 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.
Returns: TRUE, if the given shape is a compound of blocks. If theCompound is not valid, prints all discovered errors. Example: see GEOM_Spanner.py

def geompy::RemoveExtraEdges | ( |  | theShape | ) |

  | Unite faces and edges, sharing one surface. Parameters:
  | theShape | The compound or single solid to remove irregular edges from.
Returns: Improved shape. Example: see GEOM_TestOthers.py

def geompy::CheckAndImprove | ( |  | theShape | ) |

  | Fix all detected errors. Note: Single block can be also fixed by this method. Parameters:
  | theCompound | The compound to check and improve.
Returns: Improved compound. Example: see GEOM_TestOthers.py

def geompy::MakeBlockExplode | ( |  | theCompound,
|  |  | theMinNbFaces,
|  |  | theMaxNbFaces
| ) |

  | Parameters:
  | theCompound | The compound to explode.
  | theMinNbFaces | If solid has lower number of faces, it is not a block.
  | theMaxNbFaces | If solid has higher number of faces, it is not a block.
Note: If theMaxNbFaces = 0, the maximum number of faces is not restricted. Returns: List of GEOM_Objects, containing the retrieved blocks. Example: see GEOM_TestOthers.py

def geompy::GetBlockNearPoint | ( |  | theCompound,
|  |  | thePoint
| ) |

  | Parameters:
  | theCompound | Compound, to find block in.
  | thePoint | Point, close to the desired block. If the point lays on boundary between some blocks, we return block with nearest center.
Returns: New GEOM_Object, containing the found block. Example: see GEOM_Spanner.py

def geompy::GetBlockByParts | ( |  | theCompound,
|  |  | theParts
| ) |

  | Parameters:
  | theCompound | Compound, to find block in.
  | theParts | List of faces and/or edges and/or vertices to be parts of the found block.
Returns: New GEOM_Object, containing the found block. Example: see GEOM_TestOthers.py

def geompy::GetBlocksByParts | ( |  | theCompound,
|  |  | theParts
| ) |

  | Parameters:
  | theCompound | Compound, to find blocks in.
  | theParts | List of faces and/or edges and/or vertices to be parts of the found blocks.
Returns: List of GEOM_Objects, containing the found blocks. Example: see GEOM_Spanner.py

def geompy::MakeMultiTransformation1D | ( |  | Block,
|  |  | DirFace1,
|  |  | DirFace2,
|  |  | NbTimes
| ) |

  | Transformation is defined so, as to superpose direction faces. Parameters:
  | Block | Hexahedral solid to be multi-transformed.
  | DirFace1 | ID of First direction face.
  | DirFace2 | ID of Second direction face.
  | NbTimes | Quantity of transformations to be done.
Note: Unique ID of sub-shape can be obtained, using method GetSubShapeID(). Returns: New GEOM_Object, containing the result shape. Example: see GEOM_Spanner.py

def geompy::MakeMultiTransformation2D | ( |  | Block,
|  |  | DirFace1U,
|  |  | DirFace2U,
|  |  | NbTimesU,
|  |  | DirFace1V,
|  |  | DirFace2V,
|  |  | NbTimesV
| ) |

  | Parameters:
  | Block | Hexahedral solid to be multi-transformed.
  | DirFace1U,DirFace2U | IDs of Direction faces for the first transformation.
  | DirFace1V,DirFace2V | IDs of Direction faces for the second transformation.
  | NbTimesU,NbTimesV | Quantity of transformations to be done.
Returns: New GEOM_Object, containing the result shape. Example: see GEOM_Spanner.py

def geompy::Propagate | ( |  | theShape | ) |

  | 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. Parameters:
  | theShape | Shape to build propagation groups on.
Returns: List of GEOM_Objects, each of them is a propagation group. Example: see GEOM_TestOthers.py

def geompy::CreateGroup | ( |  | theMainShape,
|  |  | theShapeType
| ) |

  | Parameters:
  | theMainShape | is a GEOM object on which the group is selected
  | theShapeType | defines a shape type of the group
Returns: a newly created GEOM group Example: see GEOM_TestOthers.py

def geompy::AddObject | ( |  | theGroup,
|  |  | theSubShapeID
| ) |

  | Parameters:
  | theGroup | is a GEOM group to which the new sub shape is added
  | 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 geompy::RemoveObject | ( |  | theGroup,
|  |  | theSubShapeID
| ) |

  | Parameters:
  | theGroup | is a GEOM group from which the new sub shape is removed
  | 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 geompy::UnionList | ( |  | theGroup,
|  |  | theSubShapes
| ) |

  | No errors, if some shapes are alredy included. Parameters:
  | theGroup | is a GEOM group to which the new sub shapes are added.
  | theSubShapes | is a list of sub shapes to be added.
Example: see GEOM_TestOthers.py

def geompy::UnionIDs | ( |  | theGroup,
|  |  | theSubShapes
| ) |

| Example: see GEOM_TestOthers.py

def geompy::DifferenceList | ( |  | theGroup,
|  |  | theSubShapes
| ) |

  | 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 sub-shapes to be removed.
Example: see GEOM_TestOthers.py

def geompy::DifferenceIDs | ( |  | theGroup,
|  |  | theSubShapes
| ) |

| Example: see GEOM_TestOthers.py

def geompy::GetObjectIDs | ( |  | theGroup | ) |

  | Parameters:
  | theGroup | is a GEOM group for which a list of IDs is requested
Example: see GEOM_TestOthers.py

def geompy::GetType | ( |  | theGroup | ) |

  | Parameters:
  | theGroup | is a GEOM group which type is returned.
Example: see GEOM_TestOthers.py

def geompy::GetMainShape | ( |  | theGroup | ) |

  | Parameters:
  | theGroup | is a GEOM group for which a main shape object is requested
Returns: a GEOM object which is a main shape for theGroup Example: see GEOM_TestOthers.py

def geompy::GetEdgesByLength | ( |  | theShape,
|  |  | min_length,
|  |  | max_length,
|  |  | include_min = `1`,
|  |  | include_max = `1`
| ) |

def geompy::SelectEdges | ( |  | min_length,
|  |  | max_length,
|  |  | include_min = `1`,
|  |  | include_max = `1`
| ) |

def geompy::addPath | ( |  | Path | ) |

## Variable Documentation

tuple geompy.g = lcc.FindOrLoadComponent("FactoryServer", "GEOM")`[static]`

tuple geompy.geom = g._narrow( GEOM.GEOM_Gen )`[static]`

geompy.myBuilder = None`[static]`

int geompy.myStudyId = 0`[static]`

geompy.father = None`[static]`

geompy.BasicOp = None`[static]`

geompy.CurvesOp = None`[static]`

geompy.PrimOp = None`[static]`

geompy.ShapesOp = None`[static]`

geompy.HealOp = None`[static]`

geompy.InsertOp = None`[static]`

geompy.BoolOp = None`[static]`

geompy.TrsfOp = None`[static]`

geompy.LocalOp = None`[static]`

geompy.MeasuOp = None`[static]`

geompy.BlocksOp = None`[static]`

geompy.GroupOp = None`[static]`

dictionary geompy.ShapeType = {"COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}`[static]`

tuple geompy.g = lcc.FindOrLoadComponent("FactoryServer", "GEOM")`[static]`

tuple geompy.geom = g._narrow( GEOM.GEOM_Gen )`[static]`

geompy.myBuilder = None`[static]`

int geompy.myStudyId = 0`[static]`

geompy.father = None`[static]`

geompy.BasicOp = None`[static]`

geompy.CurvesOp = None`[static]`

geompy.PrimOp = None`[static]`

geompy.ShapesOp = None`[static]`

geompy.HealOp = None`[static]`

geompy.InsertOp = None`[static]`

geompy.BoolOp = None`[static]`

geompy.TrsfOp = None`[static]`

geompy.LocalOp = None`[static]`

geompy.MeasuOp = None`[static]`

geompy.BlocksOp = None`[static]`

geompy.GroupOp = None`[static]`

dictionary geompy.ShapeType = {"COMPOUND":0, "COMPSOLID":1, "SOLID":2, "SHELL":3, "FACE":4, "WIRE":5, "EDGE":6, "VERTEX":7, "SHAPE":8}`[static]`