# 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 | MakeTangentOnCurve
| Create a tangent, 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 | MakeThruSections
| Create a shell or solid passing through set of sections.Sections should be wires,edges or vertices.
def | MakePipeWithDifferentSections
| Create a shape by extrusion of the profile shape along the path shape.
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 | GetShapesOnPlaneWithLocation
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified plane by the certain way, defined through theState parameter.
def | GetShapesOnPlaneWithLocationIDs
| 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 | GetShapesOnBox
| Find in theShape all sub-shapes of type theShapeType, situated relatively the specified theBox by the certain way, defined through theState parameter.
def | GetShapesOnBoxIDs
| 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 | GetSame
| Get sub-shape of theShapeWhere, which is equal to theShapeWhat.
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 | ChangeOrientationShell
| Change orientation of the given object.
def | ChangeOrientationShellCopy
| Change orientation of the given 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 | MakePartitionNonSelfIntersectedShape
| 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 | MakeRotationThreePoints
| Rotate given object around vector perpendicular to plane containing three points, 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 | GetPosition
| Get position (LCS) of theShape.
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
| Create group of edges of theShape, whose length is in range [min_length, max_length].
def | SelectEdges
| Create group of edges of selected shape, whose length is in range [min_length, max_length].
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::MakeTangentOnCurve | ( |  | theRefCurve,
|  |  | theParameter
| ) |

  | Parameters:
  | theRefCurve | The referenced curve.
  | theParameter | Value of parameter on the referenced curve.
Returns: New GEOM_Object, containing the created tangent.

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 or LCS(Marker).
  | 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 or LCS(Marker) 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::MakeThruSections | ( |  | theSeqSections,
|  |  | theModeSolid,
|  |  | thePreci,
|  |  | theRuled
| ) |

  | Parameters:
  | theSeqSections | - set of specified sections.
  | theModeSolid | - mode defining building solid or shell
  | thePreci | - precision 3D used for smoothing by default 1.e-6
  | theRuled | - mode defining type of the result surfaces (ruled or smoothed).
Returns: New GEOM_Object, containing the created shell or solid. Example: see GEOM_TestAll.py

def geompy::MakePipeWithDifferentSections | ( |  | theSeqBases,
|  |  | theLocations,
|  |  | thePath,
|  |  | theWithContact,
|  |  | theWithCorrection
| ) |

  | The path shape can be a wire or an edge. the several profiles can be specified in the several locations of path. Parameters:
  | theSeqBases | - list of Bases shape to be extruded.
  | theLocations | - list of locations on the path corresponding specified list of the Bases shapes. Number of locations should be equal to number of bases or list of locations can be empty.
  | thePath | - Path shape to extrude the base shape along it.
  | theWithContact | - the mode defining that the section is translated to be in contact with the spine.
  | - | WithCorrection - defining that the section is rotated to be orthogonal to the spine tangent in the correspondent point
Returns: New GEOM_Object, containing the created pipe. 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 | closed Wire or Edge 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 closed wires or edges 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::GetShapesOnPlaneWithLocation | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAx1,
|  |  | thePnt,
|  |  | 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 of the plane to find shapes on.
  | thePnt | Point specifying 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::GetShapesOnPlaneWithLocationIDs | ( |  | theShape,
|  |  | theShapeType,
|  |  | theAx1,
|  |  | thePnt,
|  |  | 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.
  | theTopLeftPoint | Point, specifying top left corner of a quadrangle
  | theTopRigthPoint | Point, specifying top right corner of a quadrangle
  | theBottomLeftPoint | Point, specifying bottom left corner of a quadrangle
  | theBottomRigthPoint | Point, specifying bottom right corner of a quadrangle
  | 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::GetShapesOnBox | ( |  | theBox,
|  |  | theShape,
|  |  | theShapeType,
|  |  | theState
| ) |

  | Parameters:
  | theBox | Shape for relative comparing.
  | theShape | Shape to find sub-shapes of.
  | theShapeType | Type of sub-shapes to be retrieved.
  | 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.

def geompy::GetShapesOnBoxIDs | ( |  | theBox,
|  |  | theShape,
|  |  | theShapeType,
|  |  | theState
| ) |

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::GetSame | ( |  | theShapeWhere,
|  |  | theShapeWhat
| ) |

  | Parameters:
  | theShapeWhere | Shape to find sub-shape of.
  | theShapeWhat | Shape, specifying what to find.
Returns: New GEOM_Object for found sub-shape.

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::ChangeOrientationShell | ( |  | theObject | ) |

  | Parameters:
  | theObject | Shape to be processed. given shape

def geompy::ChangeOrientationShellCopy | ( |  | theObject | ) |

  | Parameters:
  | theObject | Shape to be processed.
Returns: New GEOM_Object, containing processed shape.

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. !!!NOTE: Each compound from ListShapes and ListTools will be exploded in order to avoid possible intersection between shapes from this compound.
  | Limit | Type of resulting shapes (corresponding to TopAbs_ShapeEnum).
  After implementation new version of PartitionAlgo (October 2006) other parameters are ignored by current functionality. They are kept in this function only for support old versions. Ignored parameters: Parameters:
  | ListKeepInside | Shapes, outside which the results will be deleted. Each shape from theKeepInside must belong to theShapes also.
  | ListRemoveInside | Shapes, inside which the results will be deleted. Each shape from theRemoveInside must belong to theShapes also.
  | RemoveWebs | If TRUE, perform Glue 3D algorithm.
  | ListMaterials | Material indices for each shape. Make sence, only if theRemoveWebs is TRUE.
Returns: New GEOM_Object, containing the result shapes. Example: see GEOM_TestAll.py

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

| This method may be useful if it is needed to make a partition for compound contains nonintersected shapes. Performance will be better since intersection between shapes from compound is not performed. Description of all parameters as in previous method MakePartition() !!!NOTE: Passed compounds (via ListShapes or via ListTools) have to consist of nonintersecting shapes. Returns: New GEOM_Object, containing the result shapes.

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::MakeRotationThreePoints | ( |  | theObject,
|  |  | theCentPoint,
|  |  | thePoint1,
|  |  | thePoint2
| ) |

  | Parameters:
  | theObject | The object to be rotated.
  | theCentPoint | central point - the axis is the vector perpendicular to the plane containing the three points.
  | thePoint1 | and thePoint2 - in a perpendicular plan of the axis.
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
| ) |

  | Parameters:
  | theObject | The object to be displaced.
  | theStartLCS | Coordinate system to perform displacement from it. If theStartLCS is NULL, displacement will be performed from global CS. If theObject itself is used as theStartLCS, its location will be changed to theEndLCS.
  | theEndLCS | Coordinate system to perform displacement to it.
Returns: New GEOM_Object, containing the displaced shape. 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,
|  |  | theIsCheckGeom = `0`
| ) |

  | Parameters:
  | theShape | Shape to check validity of.
  | theIsCheckGeom | If FALSE, only the shape's topology will be checked, if TRUE, the shape's geometry will be checked also.
Returns: TRUE, if the shape "seems to be valid". If theShape is invalid, prints a description of problem. Example: see GEOM_TestMeasures.py

def geompy::GetPosition | ( |  | theShape | ) |

  | Origin of the LCS is situated at the shape's center of mass. Axes of the LCS are obtained from shape's location or, if the shape is a planar face, from position of its plane. Parameters:
  | theShape | Shape to calculate position of.
Returns: [Ox,Oy,Oz, Zx,Zy,Zz, Xx,Xy,Xz]. Ox,Oy,Oz: Coordinates of shape's LCS origin. Zx,Zy,Zz: Coordinates of shape's LCS normal(main) direction. Xx,Xy,Xz: Coordinates of shape's LCS X direction. 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. It means that this faces must have references to one C++ surface object (handle). 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`
| ) |

| If include_min/max == 0, edges with length == min/max_length will not be included in result.

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

| If include_min/max == 0, edges with length == min/max_length will not be included in result.

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]`