Skip to content

NemAll_Python_Geometry

Exposed classes and functions from NemAll_Python_Geometry

AddToMinMax overloaded

AddToMinMax(minMax: MinMax2D, point: Point2D)

Calculate 2D-Min- and Max Point of an 2D point

Calculates the MinMax2D volume by the Point2D given in parameter point.

Parameters:

  • minMax (MinMax2D) –

    where to ad min max box

  • point (Point2D) –

    Point2D to be added

AddToMinMax(minMax: MinMax2D, point: Point3D)

Calculate 2D-Min- and Max Point of an 3D point

Calculates the MinMax2D volume by the Point3D given in parameter point.

Parameters:

  • minMax (MinMax2D) –

    where to ad min max box

  • point (Point3D) –

    Point3D to be added

AddToMinMax(minMax: MinMax3D, point: Point3D)

Calculate 3D-Min- and Max Point of an 3D point

Calculates the MinMax3D volume by the Point3D given in parameter point.

Parameters:

  • minMax (MinMax3D) –

    where to ad min max box

  • point (Point3D) –

    Point3D to be added

AddToMinMax(minMax: MinMax3D, point: Point2D)

Calculate 3D-Min- and Max Point of an 2D point

Calculates the MinMax3D volume by the Point2D given in parameter point.

Parameters:

  • minMax (MinMax3D) –

    where to ad min max box

  • point (Point2D) –

    Point2D to be added

CalcAngle overloaded

CalcAngle(l1: Line2D) -> tuple

compute angle of 2D line and x axis

Parameters:

Returns:

  • tuple

    result angle (normalized 2pi),

  • tuple

    NO_ERR, INVALID_LINE (lines is degenerated)

CalcAngle(point1: Point2D, point2: Point2D) -> Angle

compute angle of 2D points

Parameters:

Returns:

  • Angle

    result angle (normalized 2pi)

CalcArea overloaded

CalcArea(p1: Point2D, p2: Point2D, p3: Point2D) -> tuple

compute area of a triangle

Parameters:

Returns:

  • tuple

    area result area,

  • tuple

    POSITIVE_ORIENTATION, NEGATIVE_ORIENTATION

CalcArea(polygon: Polygon2D) -> tuple

Get the area of a 2D Polygon NEGATIVE_ORIENTATION for a CW orientated polygon, INVALID_POLYGON on error

If an instance denotes an incorrect polygon (e.g. not enough points), the method will return INVALID_POLYGON. us, one can distinguish between a collapsed polygon with area = 0.0 and a wrong shape. The polygon must not be self-intersecting. In case of self intersection the area result is currently defined and the return value indicates no error. interface: age

Parameters:

  • polygon (Polygon2D) –

    The polygon those area is requested

Returns:

  • tuple

    The area of the polygon,

  • tuple

    The eServiceResult of the operation, POSITIVE_ORIENTATION for a CCW orientated polygon,

  • tuple

    NEGATIVE_ORIENTATION for a CW orientated polygon, INVALID_POLYGON on error

CalcArea(polygon: Polygon3D) -> tuple

Get the area of a Polygon3D

Parameters:

Returns:

  • tuple

    area of the polygon,

  • tuple

    eServiceResult of the operation, POSITIVE_ORIENTATION or INVALID_POLYGON on error

CalcArea(polygonalArea: PolygonalArea3D) -> tuple

Get the area of a PolygonalArea

or INVALID_POLYGON on error e: berechnePolygonFlaeche

Returns:

  • tuple

    The area of the PolygonalArea,

  • tuple

    The eServiceResult of the operation, POSITIVE_ORIENTATION

  • tuple

    or INVALID_POLYGON on error

  • tuple

    Old interface: berechnePolygonFlaeche


CalcArea(
    areaGeo: ClosedArea2D,
    arcSegmentation: int,
    useArcSegmentation: int,
    armLength: float,
    riseValue: float,
) -> tuple

Get the area of a 2D path bounded closed area NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

Parameters:

  • areaGeo (ClosedArea2D) –

    The path bounded closed area those area is requested

  • arcSegmentation (int) –

    Number of segments the arc will be divided

  • useArcSegmentation (int) –

    type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)

  • armLength (float) –

    maximum length of a segment for polygonized arc

  • riseValue (float) –

    is the maximum distance from the actual arc and the polyline

Returns:

  • tuple

    The area of the given geometry,

  • tuple

    The eServiceResult of the operation, POSITIVE_ORIENTATION for a CCW orientated area boundary,

  • tuple

    NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

CalcArea(
    areaGeo: ClosedAreaComposite2D,
    arcSegmentation: int,
    useArcSegmentation: int,
    armLength: float,
    riseValue: float,
) -> tuple

Get the area of a 2D path bounded closed area composite NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

Parameters:

  • areaGeo (ClosedAreaComposite2D) –

    The path bounded closed area composite those area is requested

  • arcSegmentation (int) –

    Number of segments the arc will be divided

  • useArcSegmentation (int) –

    type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)

  • armLength (float) –

    maximum length of a segment for polygonized arc

  • riseValue (float) –

    is the maximum distance from the actual arc and the polyline

Returns:

  • tuple

    The area of the given geometry,

  • tuple

    The eServiceResult of the operation, POSITIVE_ORIENTATION for a CCW orientated area boundary,

  • tuple

    NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

CalcLength overloaded

CalcLength(el: Line2D) -> float

calculate length of a 2D line.

Parameters:

Returns:

  • float

    double result.

CalcLength(vec: Vector2D) -> float

calculate length of a 2D vector.

Parameters:

Returns:

  • float

    double result.

CalcLength(polyline: Polyline2D) -> float

Calculate the Length of a 2D Polyline.

Parameters:

Returns:

  • float

    Length of the given polyline.

CalcLength(polygon: Polygon2D) -> float

Calculate the Length of a 2D Polygon.

Result is length from all components, doesn't matter if it's solid or hole.

Parameters:

Returns:

  • float

    Length of the given polygon.

CalcLength(polygon: Polygon3D) -> float

Calculate the Length of a 3D Polygon.

Result is length from all components, doesn't matter if it's solid or hole.

Parameters:

Returns:

  • float

    Length of the given polygon.

CalcLength(arc: Arc2D) -> float

Calculate the Length of a 2D arc.

Parameters:

Returns:

  • float

    Length of the given arc.

CalcLength(clothoid: Clothoid2D) -> float

Calculate the Length of a 2D clothoid.

Parameters:

Returns:

  • float

    Length of the given clothoid.

CalcLength(spline: Spline2D) -> float

Calculate the Length of a 2D spline.

Parameters:

Returns:

  • float

    Length of the given spline.

CalcLength(path: Path2D) -> float

Calculate the Length of a Path 2D.

Parameters:

Returns:

  • float

    Length of the given Path2D

CalcLength(line: Line3D) -> float

calculate length of a 3D line.

Parameters:

Returns:

  • float

    double result.

CalcLength(vec: Vector3D) -> float

calculate length of a 3D vector.

Parameters:

Returns:

  • float

    double result.

CalcLength(polyline: Polyline3D) -> float

calculate length of a 3D polyline.

Parameters:

Returns:

  • float

    double result.

CalcLength(arc: Arc3D) -> float

calculate length of a 3D Arc.

Parameters:

  • arc (Arc3D) –

    3D arc.

Returns:

  • float

    double result.

CalcLength(path: Path3D) -> float

calculate length of a 3D path.

Parameters:

Returns:

  • float

    double result.

CalcLength(poly: Polyhedron3D) -> float

calculate length of a polyhedron of edge type.

Parameters:

Returns:

  • float

    double result.

CalcLength(spline: Spline3D) -> float

Calculate the Length of a 3D spline.

Parameters:

Returns:

  • float

    Length of the given spline.

CalcLength(spline: Spline3D) -> float

Calculate the Length of a 3D spline.

Parameters:

Returns:

  • float

    Length of the given spline.

CalcLength(spline: BSpline3D) -> float

Calculate the Length of a 3D bspline.

Parameters:

Returns:

  • float

    Length of the given spline.

CalcMass overloaded

CalcMass(elem: Polyhedron3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Cuboid3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Cylinder3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Ellipsoid3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Cone3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: ClippedSweptSolid3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: ExtrudedAreaSolid3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: BRep3D) -> tuple

Calculate mass values

Parameters:

Returns:

calculated volume,
calculated surface,
calculated gravity point

CalcMinMax overloaded

CalcMinMax(point: Point2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Point2D given in parameter point

Parameters:

  • point (Point2D) –

    Point2D to be calculated

Returns:

CalcMinMax(line: Line2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Line2D given in parameter line.

Parameters:

  • line (Line2D) –

    Line2D to be calculated

Returns:

CalcMinMax(polyline: Polyline2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Polyline2D given in parameter polyline.

Parameters:

  • polyline (Polyline2D) –

    Polyline2D to be calculated

Returns:

CalcMinMax(polygon: Polygon2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Polygon2D given in parameter polygon.

Parameters:

  • polygon (Polygon2D) –

    Polygon2D to be calculated

Returns:

CalcMinMax(arc: Arc2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Arc2D given in parameter arc.

Parameters:

  • arc (Arc2D) –

    Arc2D to be calculated

Returns:

CalcMinMax(spline: Spline2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Spline2D given in parameter spline.

Parameters:

  • spline (Spline2D) –

    Spline2D to be calculated

Returns:

CalcMinMax(spline: Spline3D) -> tuple[MinMax3D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax3D box of the Spline3D given in parameter spline.

Parameters:

  • spline (Spline3D) –

    Spline3D to be calculated

Returns:

CalcMinMax(spline: BSpline3D) -> tuple[MinMax3D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax3D box of the BSpline3D given in parameter spline.

Parameters:

  • spline (BSpline3D) –

    BSpline3D to be calculated

Returns:

CalcMinMax(spline: BSpline2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the BSpline2D given in parameter spline.

Parameters:

  • spline (BSpline2D) –

    BSpline2D to be calculated

Returns:

CalcMinMax(clothoid: Clothoid2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Clothoid2D given in parameter clothoid.

Parameters:

  • clothoid (Clothoid2D) –

    Clothoid to be calculated

Returns:

CalcMinMax(path: Path2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the Path2D.

Parameters:

  • path (Path2D) –

    Path2D to be calculated

Returns:

CalcMinMax(area: ClosedArea2D) -> tuple[MinMax2D, eServiceResult]

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedArea2D.

Parameters:

Returns:

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedAreaComposite2D.

Parameters:

Returns:

CalcMinMax(point: Point3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Point3D given in parameter point.

Parameters:

  • point (Point3D) –

    Point3D to be calculated

Returns:

CalcMinMax(line: Line3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Line3D given in parameter line.

Parameters:

  • line (Line3D) –

    Line3D to be calculated

Returns:

CalcMinMax(polyline: Polyline3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Polyline3D given in parameter polyline.

Parameters:

  • polyline (Polyline3D) –

    Polyline3D to be calculated

Returns:

CalcMinMax(pointCloud: object) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the PointCloud3D given in parameter point cloud.

Parameters:

  • pointCloud (object) –

    PointCloud3D to be calculated

Returns:

CalcMinMax(polygon: Polygon3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Polygon3D given in parameter polygon.

Parameters:

  • polygon (Polygon3D) –

    Polygon3D to be calculated

Returns:

CalcMinMax(arc: Arc3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Arc3D given in parameter arc.

Parameters:

  • arc (Arc3D) –

    Arc3D to be calculated

Returns:

CalcMinMax(polyhedron: Polyhedron3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Polyhedron3D given in parameter polyhedron.

Parameters:

  • polyhedron (Polyhedron3D) –

    Polyhedron3D to be calculated

Returns:

CalcMinMax(cuboid: Cuboid3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Cuboid3D given in parameter cuboid.

Parameters:

  • cuboid (Cuboid3D) –

    Cuboid3D to be calculated

Returns:

CalcMinMax(cylinder: Cylinder3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Cylinder3D given in parameter cylinder.

Parameters:

  • cylinder (Cylinder3D) –

    Cylinder3D to be calculated

Returns:

CalcMinMax(cone: Cone3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Cone3D given in parameter cylinder.

Parameters:

  • cone (Cone3D) –

    Cone3D to be calculated

Returns:

CalcMinMax(ellipsoid: Ellipsoid3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the Ellipsoid3D given in parameter ellpsoid.

Parameters:

  • ellipsoid (Ellipsoid3D) –

    Ellipsoid3D to be calculated

Returns:

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the PolygonalArea3D given in parameter area.

Parameters:

Returns:

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the ExtrudedAreaSolid3D given in parameter solid.

Parameters:

Returns:

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume by the ClippedSweptSolid3D given in parameter solid.

Parameters:

Returns:

CalcMinMax(geo: Path3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D-Min- and Max Point of an element.

Calculates the MinMax3D volume for the Path3D element.

Parameters:

  • geo (Path3D) –

    Path3D to be calculated

Returns:

CalcMinMax(geo: BRep3D) -> tuple[MinMax3D, eServiceResult]

Calculate 3D minmax of the B-rep body

Parameters:

  • geo (BRep3D) –

    BRep3D geometry

Returns:

CalcProjectedMinMax

CalcProjectedMinMax(
    geo: BRep3D, matrix: Matrix3D
) -> tuple[MinMax3D, eServiceResult]

Calculate minmax of brep in given projection

Parameters:

  • geo (BRep3D) –

    BRep3D to calculate minmax for

  • matrix (Matrix3D) –

    projection minmax

Returns:

CalcSurface

CalcSurface(elem: BRep3D) -> tuple

Calculate surface of BRep3D

Parameters:

  • elem (BRep3D) –

    input BRep3D

Returns:

result surface

CalcVolume

CalcVolume(elem: BRep3D) -> tuple

Calculate volume of BRep3D

Parameters:

  • elem (BRep3D) –

    input BRep3D

Returns:

result volume

CalculateNormal

CalculateNormal(brep: BRep3D, inputPnt: Point3D) -> Vector3D

Calculate normal vector of BRep at point

Parameters:

Returns:

CalculateSplineLengthToPoint

CalculateSplineLengthToPoint(spline: Spline2D, splinePointIndex: int) -> float

Calculate spline length from spline start to defined spline point.

This function returns correct result even if the various points of the spline

have the same coordinates ( PointLocal(.....) function fails in that case ).

Parameters:

  • spline (Spline2D) –

    2D Spline

  • splinePointIndex (int) –

    Spline point index

Returns:

  • float

    Length if everything is OK. -1.0 in case of error.

Clipping

Clipping(el1: Line2D, el2: MinMax2D) -> eBoolOpResult

test 2D line and minmax box for clipping

Parameters:

Returns:

  • eBoolOpResult

    eInside (line inside the box), eOutside (line outside the box), eClip

Colliding overloaded

Colliding(polygon1: Polygon2D, polygon2: Polygon2D) -> bool

Test for collision between 2 geometry objects

Parameters:

Returns:

  • bool

    true when colliding, otherwise false.

Colliding(polygon: Polygon2D, line: Line2D) -> bool

Test for collision between 2 geometry objects

Parameters:

Returns:

  • bool

    true when colliding, otherwise false.

Colliding(minMax: MinMax2D, polygon: Polygon2D) -> bool

Test for collision between 2 geometry objects

Parameters:

Returns:

  • bool

    true when colliding, otherwise false.

Colliding(brep1: BRep3D, brep2: BRep3D) -> bool

Test for collision between 2 breps (touch is not collision)

Parameters:

  • brep1 (BRep3D) –

    1-st brep element

  • brep2 (BRep3D) –

    2-nd brep element

Returns:

  • bool

    true when colliding, otherwise false.

Convert3DRotation

Convert3DRotation(axis: Axis3D, angle: Angle) -> tuple

Convert a 3D Rotation to series of 2D operations: scale, rotation, scale, rotation.

Parameters:

  • axis (Axis3D) –

    3D axis

  • angle (Angle) –

    Angle of 3D rotation

Returns:

  • tuple

    The first scale in X axis,

  • tuple

    The first scale in Y axis,

  • tuple

    The angle of the first 2D rotation,

  • tuple

    The second scale in X axis (scale in Y axis is 1.0),

  • tuple

    The angle of the second 2D rotation

ConvertTo2D overloaded

ConvertTo2D(line3D: Line3D) -> tuple[bool, Line2D]

Converts Line3D to Line2D

Parameters:

  • line3D (Line3D) –

    Line3D to convert

Returns:

  • tuple[bool, Line2D]

    tuple(line2D is valid: true/false, Converted Line3D)

ConvertTo2D(polyline3D: Polyline3D) -> tuple[bool, Polyline2D]

Converts Polyline3D to Polyline2D

Parameters:

  • polyline3D (Polyline3D) –

    Polyline3D to convert

Returns:

  • tuple[bool, Polyline2D]

    tuple(polyline2D is valid: true/false, Converted Polyline3D)

ConvertTo2D(axis3D: Axis3D) -> tuple[bool, Axis2D]

Converts Axis3D to Axis2D

Parameters:

  • axis3D (Axis3D) –

    Axis3D to convert

Returns:

  • tuple[bool, Axis2D]

    tuple(axis2D is valid: true/false, Converted Axis3D)

ConvertTo2D(point3D: Point3D) -> tuple[bool, Point2D]

Converts Point3D to Point2D

Parameters:

  • point3D (Point3D) –

    Point3D to convert

Returns:

  • tuple[bool, Point2D]

    tuple(point3D is valid: true/false, Converted Point3D)

ConvertTo2D(polygon3D: Polygon3D) -> tuple[bool, Polygon2D]

Converts Polygon3D to Polygon2D

Parameters:

  • polygon3D (Polygon3D) –

    Polygon3D to convert

Returns:

  • tuple[bool, Polygon2D]

    tuple(polygon3D is valid: true/false, Converted Polygon3D)

ConvertTo2D(arc3D: Arc3D) -> tuple[bool, Arc2D]

Converts Arc3D to Arc2D

function converts successfully only 3D circle and 3D ellipse which are parallel to standard plane

Parameters:

  • arc3D (Arc3D) –

    Arc3D to convert

Returns:

  • tuple[bool, Arc2D]

    tuple(Arc3D is valid: true/false, Converted Arc3D)

ConvertTo2D(spline3D: Spline3D) -> tuple[bool, Spline2D]

Converts Spline3D to Spline2D

function converts successfully only 3D spline which is parallel to standard plane

Parameters:

  • spline3D (Spline3D) –

    Spline3D to convert

Returns:

  • tuple[bool, Spline2D]

    tuple(Spline3D is valid: true/false, Converted Spline3D)

ConvertTo2D(bspline3D: BSpline3D) -> tuple[bool, BSpline2D]

Converts BSpline3D to BSpline2D

function converts successfully only 3D bspline which is parallel to standard plane

Parameters:

  • bspline3D (BSpline3D) –

    BSpline3D to convert

Returns:

  • tuple[bool, BSpline2D]

    tuple(BSpline3D is valid: true/false, Converted BSpline3D)

ConvertTo2D(points3D: Point3DList) -> tuple[bool, list[Point2D]]

Converts vector of Point3D to vector of Point2D

Parameters:

Returns:

  • tuple[bool, list[Point2D]]

    tuple(if success true, Vector of converted points)

ConvertTo2D(path3D: Path3D) -> tuple[bool, Path2D]

Converts Path3D to Path2D

Parameters:

  • path3D (Path3D) –

    source path 2D

Returns:

  • tuple[bool, Path2D]

    tuple(if success true, resulting path 3D)

ConvertTo2D(geo_object: object) -> object

Converts geometry to 2D geometry

Currently works on Line3D, Polyline3D, Axis3D, Arc3D, Point3D and Polygon3D. 2D geometries are cloned without modification.

Parameters:

  • geo_object (object) –

    geometry to convert

Returns:

  • object

    nullptr if conversion is not possible, otherwise converted geometry

ConvertTo3D overloaded

ConvertTo3D(line2D: Line2D, zPlane: float = 0) -> tuple[bool, Line3D]

Converts Line2D to Line3D

Parameters:

  • line2D (Line2D) –

    Line2D to convert

  • zPlane (float, default: 0 ) –

    Z value

Returns:

  • tuple[bool, Line3D]

    tuple(line3D is valid: true/false, Converted Line3D)

ConvertTo3D(
    polyline2D: Polyline2D, zPlane: float = 0
) -> tuple[bool, Polyline3D]

Converts Polyline2D to Polyline3D

Parameters:

  • polyline2D (Polyline2D) –

    Polyline2D to convert

  • zPlane (float, default: 0 ) –

    Z value

Returns:

  • tuple[bool, Polyline3D]

    tuple(polyline3D is valid: true/false, Converted Polyline2D)

ConvertTo3D(axis2D: Axis2D, zPlane: float = 0) -> tuple[bool, Axis3D]

Converts Axis2D to Axis3D

Parameters:

  • axis2D (Axis2D) –

    Axis2D to convert

  • zPlane (float, default: 0 ) –

    Z value

Returns:

  • tuple[bool, Axis3D]

    tuple(axis3D is valid: true/false, Converted Axis3D)

ConvertTo3D(spline2D: Spline2D, zPlane: float = 0) -> tuple[bool, Spline3D]

Create an elevated 3D spline from a 2D spline

Parameters:

  • spline2D (Spline2D) –

    Spline to convert

  • zPlane (float, default: 0 ) –

    Z plane for the spline

Returns:

  • tuple[bool, Spline3D]

    tuple(spline3D is valid: true/false, Converted spline3D)

ConvertTo3D(arc2D: Arc2D, zPlane: float = 0) -> tuple[bool, Arc3D]

Converts Arc2D to Arc3D

Parameters:

  • arc2D (Arc2D) –

    Arc2D to convert

  • zPlane (float, default: 0 ) –

    Z value

Returns:

  • tuple[bool, Arc3D]

    tuple(arc3D is valid: true/false, Converted Arc2D)

ConvertTo3D(bspline2D: BSpline2D, zPlane: float = 0) -> tuple[bool, BSpline3D]

Create an elevated 3D bspline from a 2D bspline

Parameters:

  • bspline2D (BSpline2D) –

    BSpline2D to convert

  • zPlane (float, default: 0 ) –

    Z plane for the spline

Returns:

  • tuple[bool, BSpline3D]

    tuple(BSpline3D is valid: true/false, Converted BSpline3D)

ConvertTo3D(path2D: Path2D, zPlane: float = 0) -> tuple[bool, Path3D]

Convert Path2D to Path3D

Parameters:

  • path2D (Path2D) –

    Path2D to convert

  • zPlane (float, default: 0 ) –

    Z plane for the curve

Returns:

  • tuple[bool, Path3D]

    tuple(bool (true = success), converted Path3D)

ConvertTo3D(
    points2D: Point2DList, zPlane: float = 0
) -> tuple[bool, list[Point3D]]

Convert vector of 2D points to a vector of 3D points

Parameters:

  • points2D (Point2DList) –

    vector of 2D points

  • zPlane (float, default: 0 ) –

    Z coordinate to be set by conversion

Returns:

  • tuple[bool, list[Point3D]]

    tuple(true if success, vector of converted 3D points)

ConvertTo3D(polygon: Polygon2D, zPlane: float = 0) -> tuple[bool, Polygon3D]

Convert 2D polygon to a 3D polygon

Parameters:

  • polygon (Polygon2D) –

    2D polygon

  • zPlane (float, default: 0 ) –

    Z coordinate to be set by conversion

Returns:

ConvertTo3D(
    clothoid2D: Clothoid2D, zPlane: float = 0
) -> tuple[bool, BSpline3D]

Convert 2D clothoid to a 3D bspline

Parameters:

  • clothoid2D (Clothoid2D) –

    2D clothoid

  • zPlane (float, default: 0 ) –

    Z coordinate to be set by conversion

Returns:

ConvertToBSpline2D overloaded

ConvertToBSpline2D(arc3D: Arc3D) -> tuple[bool, BSpline2D]

Converts Arc3D to BSpline2D

Parameters:

  • arc3D (Arc3D) –

    Arc3D to convert

Returns:

  • tuple[bool, BSpline2D]

    tuple(bspline2D is valid: true/false, Converted BSpline2D)

ConvertToBSpline2D(spline3D: Spline3D) -> tuple[bool, BSpline2D]

Converts Spline3D to BSpline2D

Parameters:

  • spline3D (Spline3D) –

    Spline3D to convert

Returns:

  • tuple[bool, BSpline2D]

    tuple(bspline2D is valid: true/false, Converted BSpline2D)

CreateBRep3D overloaded

CreateBRep3D(polyhedron: Polyhedron3D) -> tuple

Create BRep3D by converting a polyhedron

Parameters:

Returns:

BRep3D to create
CreateBRep3D(brep: BRep3D, faceindex: int) -> tuple

Create brep from brep face

Parameters:

  • brep (BRep3D) –

    brep to copy face from

  • faceindex (int) –

    face index

Returns:

result brep

CreateFrustumOfPyramid

CreateFrustumOfPyramid(
    length: float,
    width: float,
    height: float,
    offset: float,
    bottomPlane: Plane3D,
) -> tuple

) -> tuple : Create a frustum of pyramid

Parameters:

  • length (float) –

    Length of the bottom

  • width (float) –

    Width of the bottom

  • height (float) –

    Height of the bottom

  • offset (float) –

    Offset of the top

  • bottomPlane (Plane3D) –

    Bottom plane

Returns:

CreateLoftedBRep3D

CreateLoftedBRep3D(
    outerProfiles: Curve3DList,
    innerProfiles: Curve3DList,
    closecaps: bool,
    createprofileedges: bool,
    linear: bool,
    periodic: bool,
) -> tuple

Create BRep3D by means of lofting through a set of profiles (incl. hole)

Parameters:

  • outerProfiles (Curve3DList) –

    outer profiles to loft

  • innerProfiles (Curve3DList) –

    inner profiles to loft (represents hole in outer profile)

  • closecaps (bool) –

    close brep if possible (all profiles are closed)

  • createprofileedges (bool) –

    create profile edges and more surfaces or just create one surface

  • linear (bool) –

    linear or cubic interpolation

  • periodic (bool) –

    if the start profile is also to be the end profile

Returns:

  • tuple

    tuple(error code, result BRep3D)

CreatePatchBRep3D

CreatePatchBRep3D(curves: list) -> tuple[eCreatePatchResult, BRep3DList]

Create breps as patch from given closed 3D-curves

Parameters:

  • curves (list) –

    list of 3D-curves

Returns:

CreatePlanarBRep3D overloaded

CreatePlanarBRep3D(
    icurve: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
) -> tuple

Create brep as planar surface

Parameters:

Returns:

  • tuple

    tuple(error code, - resulting BRep3D ( one planar face ))

CreatePlanarBRep3D(profiles: Curve3DList) -> tuple

Create brep as planar surface

Parameters:

  • profiles (Curve3DList) –

    border of planar surface ( must be closed )

Returns:

  • tuple

    tuple(error code, resulting BRep3D ( one planar face ))

CreatePlanarSurface

CreatePlanarSurface(geometries: list) -> tuple[ePlanarSurfaceError, BRep3DList]

create planar brep

Parameters:

  • geometries (list) –

    input geometries pointers

Returns:

CreatePolygon3D overloaded

CreatePolygon3D(polyhedron: Polyhedron3D, faceIndex: int) -> tuple

Creates a Polygon3D element from a Polyhedron face

Parameters:

  • polyhedron (Polyhedron3D) –

    Polyhedron to get face from

  • faceIndex (int) –

    Index of the face in polyhedron

Returns:

  • tuple

    eOK if successful, else eError,

  • tuple

    Created polygon

CreatePolygon3D(polygon2D: Polygon2D, plane: Plane3D) -> tuple

Creates a Polygon3D element as a projection of 2D polygon onto given plane

Parameters:

  • polygon2D (Polygon2D) –

    2D polygon

  • plane (Plane3D) –

    plane to project 2D polygon to

Returns:

  • tuple

    eOK if successful, else eError,

  • tuple

    Output 3D polygon

CreatePolygon3D(polyline: Polyline3D) -> tuple

Creates a Polygon3D from Polyline3D

Parameters:

Returns:

  • tuple

    eOK if successful, else eError,

  • tuple

    Output 3D polygon

CreatePolygon3DFromIndex

CreatePolygon3DFromIndex(arg2: Polygon3D, arg3: int, arg4: int) -> Polygon3D

Create a 3D polygon from a start and end polygon, an index and a division count

CreatePolyhedron overloaded

CreatePolyhedron(
    polyhedronType: PolyhedronType,
    verticesCount: int,
    edgeCount: int,
    faceCount: int,
    negativeOrientation: bool,
) -> tuple

Create and initialize new Polyhedron3D

Parameters:

  • polyhedronType (PolyhedronType) –

    Polyhedron type - edges, faces or volume.

  • verticesCount (int) –

    Count of expected vertices.

  • edgeCount (int) –

    Count of expected edges.

  • faceCount (int) –

    Count of expected faces.

  • negativeOrientation (bool) –

    True for negative orientation.

Returns:

  • tuple

    Error code,

  • tuple

    pointer to 3D Polyhedron which will be created

CreatePolyhedron(solid: ClippedSweptSolid3D) -> tuple

Create polyhedron from input parametric solid

Parameters:

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(solid: ExtrudedAreaSolid3D) -> tuple

Create polyhedron from input parametric solid

Parameters:

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(cylinder: Cylinder3D, countOfSegments: int) -> tuple

Create polyhedron from input Cylinder

Parameters:

  • cylinder (Cylinder3D) –

    Cylinder to convert

  • countOfSegments (int) –

    Count of segments

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(igeo: object, options: ApproximationSettings) -> tuple

Create polyhedron from arbitrary solid

Parameters:

  • geoObject

    Geometry object

  • options (ApproximationSettings) –

    ApproximationSettings structure holding options for approximation

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(brep: BRep3D, options: ApproximationSettings) -> tuple

Create polyhedron as approximation of arbitrary BRep3D

Parameters:

Returns:

  • tuple

    Error code,

  • tuple

    polyhedron to create

CreatePolyhedron(polygon: Polygon3D) -> tuple

Create polyhedron from Polygon3D

Parameters:

  • polygon (Polygon3D) –

    Reference to Polygon3D

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(line: Line3D) -> tuple

Create polyhedron from Line3D

Parameters:

  • line (Line3D) –

    Reference to Line3D

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(lines: Line3DList) -> tuple

Create polyhedron from vector of 3D lines

Parameters:

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(polyline: Polyline3D) -> tuple

Create polyhedron from Polyline3D

Parameters:

  • polyline (Polyline3D) –

    Reference to Polyline3D

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(base: Polygon3D, path: Polyline3D) -> tuple

Create translation polyhedron from base polygon and path

Parameters:

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(base: Polygon2D, refPoint: Point2D, path: Polyline3D) -> tuple

Create translation polyhedron from base polygon and path

Parameters:

  • base (Polygon2D) –

    base polygon 2D

  • refPoint (Point2D) –

    reference point used for transformation

  • path (Polyline3D) –

    translation path

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CreatePolyhedron(
    polygon: Polygon2D, bottomPlane: Plane3D, topPlane: Plane3D
) -> tuple

Create translation polyhedron from 2D polygon, bottom and top plane

Parameters:

  • polygon (Polygon2D) –

    polygon 2D

  • bottomPlane (Plane3D) –

    the bottom plane

  • topPlane (Plane3D) –

    the top plane

Returns:

  • tuple

    error code,

  • tuple

    Polyhedron which will be created

CreatePolyhedron(
    baseOutline: Polygon2D,
    leftOffset: float,
    rightOffset: float,
    frontOffset: float,
    backOffset: float,
    bottomPlane: Plane3D,
    topPlane: Plane3D,
) -> tuple

Create conical polyhedron from 2D polygon, given offsets, bottom and top plane

Parameters:

  • baseOutline (Polygon2D) –

    base outline polygon 2D (rectangle of 4 points)

  • leftOffset (float) –

    offset from base outline on the left side

  • rightOffset (float) –

    offset from base outline on the right side

  • frontOffset (float) –

    offset from base outline on the front side

  • backOffset (float) –

    offset from base outline on the back side

  • bottomPlane (Plane3D) –

    element's bottom plane

  • topPlane (Plane3D) –

    element's top plane

Returns:

  • tuple

    Error code,

  • tuple

    polyhedron which will be created

CreatePolyhedron(startPolygon: Polygon3D, endPolygon: Polygon3D) -> tuple

Create a polyhedron from a 3D start and end polygon

Parameters:

Returns:

CreatePolyline3D overloaded

CreatePolyline3D(polyhedron: Polyhedron3D) -> tuple

Creates a Polyline3D element from a Polyhedron

Parameters:

  • polyhedron (Polyhedron3D) –

    Polyhedron to create line from

Returns:

  • tuple

    eOK if converted successful, else eError,

Created Polyline
CreatePolyline3D(polyline2D: Polyline2D) -> tuple

Create Polyline3D from Polyline2D

Parameters:

  • polyline2D (Polyline2D) –

    Reference to Polyline2D

Returns:

  • tuple

    eOK if created successful, else eError,

Reference to empty Polyline3D
CreatePolyline3D(polygon: Polygon3D) -> tuple

Creates a Polyline3D from Polygon3D

Parameters:

Returns:

  • tuple

    eOK if successful, else eError,

Output 3D polyline

CreatePolyline3DFromIndex

CreatePolyline3DFromIndex(
    startPol: Polyline3D, endPol: Polyline3D, index: int, count: int
) -> Polyline3D

Create a 3D polyline from a start and end polyline, an index and a division count Args: startPol: Start polyline endPol: End polyline index: Division index count: Division count

Returns:

  • Polyline3D

    eOK if converted successful, else eError,

Created Polyline

CreateRailSweptBRep3D overloaded

CreateRailSweptBRep3D(
    profiles: Curve3DList,
    rails: Curve3DList,
    closecaps: bool,
    uniformScaling: bool,
    railrotation: bool,
) -> tuple

Create BRep3D by rail sweeping of profiles. Rails must start/ends on profiles start/end points

Parameters:

  • profiles (Curve3DList) –

    profiles to sweep

  • rails (Curve3DList) –

    rails to control sweeping

  • closecaps (bool) –

    if true, create closed solid if possible, if false just surface(s) will be created

  • uniformScaling (bool) –

    use uniform scaling for profiles along the rails

  • railrotation (bool) –

    use rotation the shape to maintain a constant angle with the rail

Returns:

  • tuple

    tuple(error code, result BRep3D (1 swept face))

CreateRailSweptBRep3D(
    profiles: Curve3DList,
    rails: Curve3DList,
    path: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
    closecaps: bool,
    uniformScaling: bool,
    railrotation: bool,
    proportionalVertexMatch: bool,
) -> tuple

Create BRep3D by rail sweeping of profiles. Rails must start/ends on profiles start/end points

Parameters:

  • profiles (Curve3DList) –

    profiles to sweep

  • rails (Curve3DList) –

    rails to control sweeping

  • path (Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D) –

    user defined path

  • closecaps (bool) –

    if true, create closed solid if possible, if false just surface(s) will be created

  • uniformScaling (bool) –

    use uniform scaling for profiles along the rails

  • railrotation (bool) –

    use rotation the shape to maintain a constant angle with the rail

  • proportionalVertexMatch (bool) –

    Flag whether to use proportional vertex matching

Returns:

  • tuple

    tuple(error code, result BRep3D (1 swept face), path for body creation)

CreateRevolvedBRep3D

CreateRevolvedBRep3D(
    profiles: Curve3DList,
    axis: Axis3D,
    rotationAngle: Angle,
    closecaps: bool,
    numprofiles: int,
) -> tuple

Create brep as revolved body.

Parameters:

  • profiles (Curve3DList) –

    list of profile curves

  • axis (Axis3D) –

    axis of rotation

  • rotationAngle (Angle) –

    angle of rotation

  • closecaps (bool) –

    if true, create closed solid if possible, if false just surface(s) will be created

  • numprofiles (int) –

    number of control profiles created along the created surfaces (division of surface parameter)

Returns:

  • tuple

    tuple(error code, created brep)

CreateSweptBRep3D overloaded

CreateSweptBRep3D(
    profile: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
    path: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
    railrotation: bool,
    rotAxis: Vector3D | None = None,
) -> tuple

Create BRep3D by means of a profile extrusion along a path

Parameters:

Returns:

  • tuple

    tuple(error code, result BRep3D)

CreateSweptBRep3D(
    profiles: Curve3DList,
    path: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
    closecaps: bool,
    railrotation: SweepRotationType,
    rotAxis: Vector3D | None = None,
    numprofiles: int = 0,
) -> tuple

Create BRep3D by means of a vector of profiles extrusion along a path

Parameters:

  • profiles (Curve3DList) –

    profiles to extrude, if closed solid will be created, otherwise a surface only

  • path (Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D) –

    path to extrude along

  • closecaps (bool) –

    if true, create closed solid if possible, if false just surface(s) will be created

  • railrotation (SweepRotationType) –

    if true, rotate profile along the path

  • rotAxis (Vector3D | None, default: None ) –

    if set, profile will be rotated along this axis along the path

  • numprofiles (int, default: 0 ) –

    number of control profiles created along the created surfaces (divisionn of surface parameter)

Returns:

  • tuple

    tuple(error code, result BRep3D)

CreateSweptBRep3D(
    profiles: list,
    path_object: object,
    closecaps: bool,
    railrotation: bool,
    rotAxis: Vector3D | None = None,
    numprofiles: int = 0,
) -> tuple[eGeometryErrorCode, BRep3D]

Create BRep3D by means of a vector of profiles extrusion along a path

Parameters:

  • profiles (list) –

    profiles to extrude, if closed solid will be created, otherwise a surface only

  • path_object (object) –

    path to extrude along

  • closecaps (bool) –

    if true, create closed solid if possible, if false just surface(s) will be created

  • railrotation (bool) –

    if true, rotate profile along the path

  • rotAxis (Vector3D | None, default: None ) –

    if set, profile will be rotated along this axis along the path

  • numprofiles (int, default: 0 ) –

    number of control profiles created along the created surfaces (divisionn of surface parameter)

Returns:

CreateSweptPolyhedron3D

CreateSweptPolyhedron3D(
    profiles: Polyline3DList,
    path: Polyline3D,
    closecaps: bool,
    railrotation: bool,
    rotAxis: Vector3D,
) -> tuple

Create translation polyhedron from base polygon and path

Parameters:

  • profiles (Polyline3DList) –

    profiles to sweep

  • path (Polyline3D) –

    translation path

  • closecaps (bool) –

    create closed volume (in case of closed profiles) or open shell only

  • railrotation (bool) –

    rotate profiles along path - standard rotation = true (keep angle between profile and a path), rotation along z-axis vector = false

  • rotAxis (Vector3D) –

    if set, profile will be rotated along this axis along the path

Returns:

  • tuple

    Error code,

  • tuple

    Polyhedron3D which will be created

CutBrepWithPlane

CutBrepWithPlane(
    original: BRep3D, plane: Plane3D
) -> tuple[bool, BRep3D, BRep3D]

Cut Brep with plane - create two independent BReps

Parameters:

  • original (BRep3D) –

    original brep

  • plane (Plane3D) –

    cutting plane

Returns:

  • tuple[bool, BRep3D, BRep3D]

    tuple(true if plane cuts the brep. If the plane is above or below brep, it returns false, but one of the result brep is filled with original according to plane position - use brep.IsValid() to check., result brep above the plane, result brep below the plane)

CutPolyhedronWithPlane

CutPolyhedronWithPlane(
    original: Polyhedron3D, plane: Plane3D
) -> tuple[bool, Polyhedron3D, Polyhedron3D]

Cut polyhedron with plane - create two independent polyhedra

Parameters:

Returns:

  • tuple[bool, Polyhedron3D, Polyhedron3D]

    tuple(true if there is a cut, otherwise false, one of polyhedron above/below is filled when whole body is above/below the plane, result polyhedron above the plane, result polyhedron below the plane)

DeletePolyhedronLastFace

DeletePolyhedronLastFace(polyhedron: Polyhedron3D) -> eGeometryErrorCode

Delete the last face of given polyhedron

Parameters:

Returns:

FaceShell

FaceShell(
    inputBrep: BRep3D,
    distance: float,
    direction: int,
    faceIndices: VecSizeTList,
    useOffsetStepPierce: bool,
    useOrthoVXSplit: bool,
    punchDirection: Vector3D,
) -> tuple[eGeometryErrorCode, BRep3D]

Execute face shell

Parameters:

  • inputBrep (BRep3D) –

    inputBrep

  • distance (float) –

    distance for offset

  • direction (int) –

    offset direction 0 - in face normal direction, 1 - in both directions, 2 - opposite to face normal

  • faceIndices (VecSizeTList) –

    face indexes

  • useOffsetStepPierce (bool) –

    if to use offset step pierce

  • useOrthoVXSplit (bool) –

    if to use OrthoVXSplit option

  • punchDirection (Vector3D) –

    defined direction for shell (optional)

Returns:

FindMinDistancePoint overloaded

FindMinDistancePoint(point: Point3D, bspline: BSpline3D) -> tuple

Find minimal distance point between Point3D and BSpline3D

Parameters:

Returns:

point on bspline with minimal distance
FindMinDistancePoint(point: Point3D, brep: BRep3D) -> tuple

Find minimal distance point between Point3D and BSpline3D

Parameters:

Returns:

  • tuple

    error code,

  • tuple

    point on brep with minimal distance

GetAbsoluteTolerance

GetAbsoluteTolerance() -> float

get absolute tolerance

Returns:

  • float

    absolute tolerance

GetAllIntersections

GetAllIntersections(
    geoObject1: object, geoObject2: object, eps: float, maxSolutions: int
) -> tuple

Calculate all intersections of two geometry objects Intersection point must not be located on the elements, it can be outside

Parameters:

  • geoObject1 (object) –

    First object

  • geoObject2 (object) –

    Second object

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector which includes all resulting intersection points

GetAngleTolerance

GetAngleTolerance() -> Angle

Get angle tolerance

This tolerance is using for angle comparison. Use it with Comparison::Equal(value, value, GetAngleTolerance())

Returns:

  • Angle

    Tolerance using for angle comparison [rad]

GetClosestIntersection

GetClosestIntersection(
    geometrie1: object,
    geometrie2: object,
    inputPoint: Point3D,
    eps: float,
    bOnlyInsidePoints: bool,
) -> tuple

Function to calculate the nearest intersection between two geometries to a reference point Intersection point must not be located on the elements, it can be outside

Parameters:

  • geometrie1 (object) –

    First object

  • geometrie2 (object) –

    Second object

  • inputPoint (Point3D) –

    Reference Point / Cursor point

  • eps (float) –

    Tolerance

  • bOnlyInsidePoints (bool) –

    Return point must be on both objects

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    intersection point

GetCurvatureTolerance

GetCurvatureTolerance() -> float

Get curvature tolerance

This tolerance is using for curvature comparison. Use it with Comparison::Equal(value, value, GetCurvatureTolerance())

Returns:

  • float

    Tolerance using for curvature comparison

GetCurveLengthTolerance

GetCurveLengthTolerance() -> float

Get tolerance for curve length comparison

This tolerance is using for length of curve comparison. Use it with Comparison::Equal(value, value, GetCurveLengthTolerance())

Returns:

  • float

    Tolerance using for length of curve comparison [mm]

GetIntersectionPoints

GetIntersectionPoints(
    geoObject1: object, geoObject2: object, eps: float
) -> tuple

Function to calculate the nearest intersection between two geometries to a reference point Intersection point must not be located on the elements, it can be outside

Parameters:

  • geoObject1 (object) –

    First object

  • geoObject2 (object) –

    Second object

  • eps (float) –

    Tolerance (optional)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector of intersection points and additional information

GetRelativeTolerance

GetRelativeTolerance() -> float

get relative tolerance

Returns:

  • float

    relative tolerance

GetRotationMatrix overloaded

GetRotationMatrix(zeroPoint: Point2D, angle: Angle) -> Matrix2D

Creates 2D rotation matrix

Parameters:

  • zeroPoint (Point2D) –

    Rotation point

  • angle (Angle) –

    Rotation angle

Returns:

GetRotationMatrix(axis: Axis3D, angle: Angle) -> Matrix3D

Creates 3D rotation matrix

Parameters:

  • axis (Axis3D) –

    Rotation axis

  • angle (Angle) –

    Rotation angle

Returns:

GetRotationMatrix(line: Line3D, angle: Angle) -> Matrix3D

Creates 3D rotation matrix

Parameters:

  • line (Line3D) –

    Rotation line, extended to axis

  • angle (Angle) –

    Rotation angle

Returns:

GroundViewHiddenCalculation overloaded

GroundViewHiddenCalculation(
    brep: BRep3D,
) -> tuple[eGeometryErrorCode, list[typingAny], list[typingAny]]

Hidden calculation with ground view of BRep

Parameters:

Returns:

  • tuple[eGeometryErrorCode, list[typingAny], list[typingAny]]

    tuple(Error code, Vector of visible edges, Vector of hidden edges)

GroundViewHiddenCalculation(
    poly: Polyhedron3D,
) -> tuple[eGeometryErrorCode, list[Line3D], list[Line3D]]

Hidden calculation with ground view of polyhedron.

Parameters:

Returns:

ImprintProfileOnFaces

ImprintProfileOnFaces(
    brep: BRep3D,
    targetFaces: list[int] | VecUIntList,
    profile: (
        Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
    ),
) -> tuple

Imprint edges on brep

Parameters:

Returns:

  • tuple

    tuple(eOK if successful otherwise eError, Brep, new faces after imprint)

Intersect overloaded

Intersect(bodies1: PolyhedronTypesList, bodies2: PolyhedronTypesList) -> tuple

compute intersection of set of bodies

Parameters:

Returns:

  • tuple

    tuple(true when intersecting, otherwise false., resulted polyhedron)

Intersect(el1: Plane3D, el2: Plane3D) -> tuple[bool, Axis3D]

calculate intersection between 2 3D planes

Parameters:

  • el1 (Plane3D) –

    the first plane

  • el2 (Plane3D) –

    the second plane

Returns:

  • tuple[bool, Axis3D]

    tuple(true when intersecting, otherwise false., common axis of planes)

Intersect(el1: Polyhedron3D, el2: Polyhedron3D) -> tuple[bool, Polyhedron3D]

compute intersection of 2 3D polyhedron

Parameters:

Returns:

  • tuple[bool, Polyhedron3D]

    tuple(true when intersecting, otherwise false., resulted polyhedron)

Intersect(brep1: BRep3D, brep2: BRep3D) -> tuple[eGeometryErrorCode, BRep3D]

Compute intersection of 2 breps

Parameters:

  • brep1 (BRep3D) –

    first brep

  • brep2 (BRep3D) –

    second brep

Returns:

Intersect(
    brep: BRep3D, polyhedron: Polyhedron3D
) -> tuple[eGeometryErrorCode, BRep3D]

Compute intersection of 2 bodies

Parameters:

  • brep (BRep3D) –

    first element - BRep3D

  • polyhedron (Polyhedron3D) –

    second element - Polyhedron3D

Returns:

IntersectRayBRep

IntersectRayBRep(
    rayPoint: Point3D, rayVector: Vector3D, brep: BRep3D, bNegativPrefered: bool
) -> tuple[int, IntersectionRayBRep]

Intersection of Ray and BRep

Parameters:

  • rayPoint (Point3D) –

    ray Point

  • rayVector (Vector3D) –

    direction vector of ray

  • brep (BRep3D) –

    BRep

  • bNegativPrefered (bool) –

    if true -> return first solution when ray point is out of object

Returns:

IntersectRayPolyhedron

IntersectRayPolyhedron(
    rayPoint: Point3D,
    rayVector: Vector3D,
    polyhedron: Polyhedron3D,
    flag: IntersectRayPolyhedronFlag,
    selFaces: list[int] | VecIntList | None = None,
    searchDistance: float = 0.0,
    pixelSize: float = 0,
) -> tuple[int, IntersectionRayPolyhedron]

Intersection of Ray and Polyhedron

Parameters:

  • rayPoint (Point3D) –

    ray Point

  • rayVector (Vector3D) –

    direction vector of ray

  • polyhedron (Polyhedron3D) –

    polyhedron

  • flag (IntersectRayPolyhedronFlag) –

    flag for determining the "best" intersection

  • selFaces (list[int] | VecIntList | None, default: None ) –

    optional list of faces used for intersection, if default value is used, all faces are checked

  • searchDistance (float, default: 0.0 ) –

    used for eNegativeVerticalPreferred to find vertical faces near point found on not-vertical face

  • pixelSize (float, default: 0 ) –

    in mm used for eNegativeVerticalPreferred to find vertical faces

Returns:

Intersecting overloaded

Intersecting(el1: MinMax2D, el2: MinMax2D) -> bool

test 2 2D minmaxes for intersection

Parameters:

Returns:

  • bool

    true when intersecting, otherwise false.

Intersecting(el1: Line2D, el2: Line2D, tol: float) -> bool

test 2 2D lines for intersection

Parameters:

  • el1 (Line2D) –
    1. element
  • el2 (Line2D) –
    1. element
  • tol (float) –

    tolerance

Returns:

  • bool

    true when intersecting, otherwise false.

Intersecting(el1: Polygon2D, el2: Polygon2D, tol: float) -> bool

test 2 2D polygons for intersection throw Exception in case of internal error.

Parameters:

Returns:

  • bool

    true when intersecting, otherwise false.

Intersecting(el1: BRep3D, el2: BRep3D) -> bool

test 2 breps for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: BRep3D, el2: Polyhedron3D) -> bool

test brep and polyhedron for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: Arc3D, el2: Polyhedron3D) -> bool

test 3D arc and polyhedron for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: Arc3D, el2: BRep3D) -> bool

test 3D arc and brep for intersection

Parameters:

  • el1 (Arc3D) –

    arc to check

  • el2 (BRep3D) –

    brep to check

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: Spline3D, el2: Polyhedron3D) -> bool

test 3D spline and polyhedron for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: Spline3D, el2: BRep3D) -> bool

test 3D spline and brep for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: BSpline3D, el2: Polyhedron3D) -> bool

test 3D bspline and polyhedron for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

Intersecting(el1: BSpline3D, el2: BRep3D) -> bool

test 3D bspline and brep for intersection

Parameters:

Returns:

  • bool

    bool true when intersecting

IntersectingRel overloaded

IntersectingRel(el1: MinMax2D, el2: MinMax2D) -> bool

test 2 geo 2D minmaxes for intersection using built-in relative tolerance

Parameters:

Returns:

  • bool

    true when intersecting, otherwise false.

IntersectingRel(el1: Line2D, el2: Line2D) -> bool

test 2 2D lines for intersection

Parameters:

Returns:

  • bool

    true when intersecting, otherwise false.

IntersectionCalculus overloaded

IntersectionCalculus(el1: Axis2D, el2: Axis2D) -> tuple

compute intersection of 2 2D axis

Parameters:

Returns:

  • tuple

    true when intersecting, otherwise false.,

  • tuple

    result intersection point if possible

IntersectionCalculus(axis: Axis2D, line: Line2D) -> tuple

compute intersection between 2D axis and 2D line

Parameters:

Returns:

  • tuple

    true when intersecting, otherwise false.,

  • tuple

    result intersection point if possible

IntersectionCalculus(axis2D: Axis2D, axis3D: Axis3D) -> tuple

Calculate the intersection between a 2D and a 3D axis

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(axis2D: Axis2D, arc2D: Arc2D, eps: float) -> tuple

Calculate the intersection between a 2D axis and a 2D arc

emarks There are known precision issues with the background function lksplk

Args:
    axis2D: 2D Axis
    arc2D:  2D Arc
    eps:    precision

Returns:
        true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculus(axis2D: Axis2D, polyline: Polyline2D) -> tuple

Calculate the intersection between a 2D axis and a 2D polyline

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(axis2D: Axis2D, polygon: Polygon2D) -> tuple

Calculate the intersection between a 2D axis and a 2D polygon

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    axis2D: Axis2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D axis and a 2D spline

Parameters:

  • axis2D (Axis2D) –

    2D Axis

  • spline (Spline2D) –

    2D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    axis2D: Axis2D, bspline: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D axis and a 2D bspline

Parameters:

  • axis2D (Axis2D) –

    2D Axis

  • bspline (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(axis1: Axis3D, axis2: Axis3D) -> tuple

Calculate the intersection between two 3D axis

Parameters:

  • axis1 (Axis3D) –

    First 3D Axis

  • axis2 (Axis3D) –

    Second 3D Axis

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(axis: Axis3D, line: Line2D) -> tuple

Calculate the intersection between 3D axis and 2D line

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(axis: Axis3D, arc: Arc2D, eps: float) -> tuple

Calculate the intersection between a 3D axis and a 2D arc

emarks There are known precision issues with the background function lksplk

Args:
    axis: 3D Axis
    arc:  2D Arc
    eps:  precision

Returns:
        true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculus(axis: Axis3D, polyline: Polyline2D) -> tuple

Calculate the intersection between a 3D axis and a 2D polyline

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(axis: Axis3D, polygon: Polygon2D) -> tuple

Calculate the intersection between a 3D axis and a 2D polygon

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    axis: Axis3D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D axis and a 2D spline

Parameters:

  • axis (Axis3D) –

    3D Axis

  • spline (Spline2D) –

    2D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    axis: Axis3D, spline: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D axis and a 3D spline

Parameters:

  • axis (Axis3D) –

    3D Axis

  • spline (Spline3D) –

    3D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    axis: Axis3D, spline: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D axis and a 3D B-spline

Parameters:

  • axis (Axis3D) –

    3D Axis

  • spline (BSpline3D) –

    3D B-Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(axis: Axis3D, plane: Plane3D, eps: float) -> tuple

Calculate the intersection between a 3D axis and a 3D plane

Parameters:

  • axis (Axis3D) –

    3D Axis

  • plane (Plane3D) –

    3D Plane

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(line: Line3D, plane: Plane3D, eps: float) -> tuple

Calculate the intersection between a 3D axis and a 3D plane

Parameters:

  • line (Line3D) –

    3D Line

  • plane (Plane3D) –

    3D Plane

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(axis: Axis3D, arc: Arc3D, eps: float) -> tuple

Calculate the intersection between a 3D axis and a 3D arc

Parameters:

  • axis (Axis3D) –

    3D Axis

  • arc (Arc3D) –

    3D Arc

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection points
IntersectionCalculus(line: Line3D, arc: Arc3D, eps: float) -> tuple

Calculate the intersection between a 3D line and a 3D arc

Parameters:

  • line (Line3D) –

    3D Line

  • arc (Arc3D) –

    3D Arc

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection points
IntersectionCalculus(el1: Line2D, el2: Line2D) -> tuple

compute intersection of 2 2D line

Parameters:

Returns:

  • tuple

    true when intersecting, otherwise false.,

  • tuple

    result intersection point if possible

IntersectionCalculus(line2D: Line2D, line3D: Line3D) -> tuple

Calculate the intersection between a 2D and a 3D line

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(line2D: Line2D, arc2D: Arc2D, eps: float) -> tuple

Calculate the intersection between a 2D line and a 2D arc

emarks There are known precision issues with the background function lksplk

Args:
    line2D: 2D Line
    arc2D:  2D Arc
    eps:    precision

Returns:
        true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculus(line2D: Line2D, polyline: Polyline2D) -> tuple

Calculate the intersection between a 2D line and a 2D polyline

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(line2D: Line2D, polygon: Polygon2D) -> tuple

Calculate the intersection between a 2D line and a 2D polygon

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    line: Line2D, bspline: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D line and a 2D bspline

Parameters:

  • line (Line2D) –

    2D Line

  • bspline (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    line2D: Line2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D line and a 2D spline

Parameters:

  • line2D (Line2D) –

    2D Line

  • spline (Spline2D) –

    2D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(line1: Line3D, line2: Line3D) -> tuple

Calculate the intersection between two 3D line

Parameters:

  • line1 (Line3D) –

    First 3D Line

  • line2 (Line3D) –

    Second 3D Line

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Resulting intersection point
IntersectionCalculus(line: Line3D, arc: Arc2D, eps: float) -> tuple

Calculate the intersection between a 3D line and a 2D arc

emarks There are known precision issues with the background function lksplk

Args:
    line: 3D Line
    arc:  2D Arc
    eps:  precision

Returns:
        true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculus(line: Line3D, polyline: Polyline2D) -> tuple

Calculate the intersection between a 3D line and a 2D polyline

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(line: Line3D, polygon: Polygon2D) -> tuple

Calculate the intersection between a 3D line and a 2D polygon

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    line: Line3D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D line and a 2D spline

Parameters:

  • line (Line3D) –

    3D Line

  • spline (Spline2D) –

    2D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    line: Line3D, spline: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D line and a 3D spline

Parameters:

  • line (Line3D) –

    3D Line

  • spline (Spline3D) –

    3D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    line: Line3D, bspline: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D line and a 3D bspline

Parameters:

  • line (Line3D) –

    3D Line

  • bspline (BSpline3D) –

    3D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(arc1: Arc2D, arc2: Arc2D) -> tuple

Calculate the intersection between two arcs

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(arc: Arc2D, polyline: Polyline2D, eps: float) -> tuple

Calculate the intersection between a 2D arc and a 2D polyline

emarks There are known precision issues with the background function lksplk

Args:
    arc:      2D Arc
    polyline: 2D Polyline
    eps:      precision

Returns:
        true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculus(
    arc: Arc2D, polygon: Polygon2D, intersectionPnts: float
) -> tuple

Calculate the intersection between a 2D arc and a 2D polygon

emarks There are known precision issues with the background function lksplk

Args:
    arc:              2D Arc
    polygon:          2D Polygon
    intersectionPnts: Vector which includes all resulting intersection points

Returns:
        true, if an intersection was found, otherwise false,
    precision
IntersectionCalculus(
    arc: Arc2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D arc and a 2D spline

Parameters:

  • arc (Arc2D) –

    2D Arc

  • spline (Spline2D) –

    2D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    arc: Arc2D, bspline: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D arc and a 2D spline

Parameters:

  • arc (Arc2D) –

    2D Arc

  • bspline (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    arc: Arc3D, arc2: Arc3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D arc and a 3D B-spline

Parameters:

  • arc (Arc3D) –

    First 3D Arc

  • arc2 (Arc3D) –

    Second 3D Arc

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    arc: Arc3D, spline: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D arc and a 3D spline

Parameters:

  • arc (Arc3D) –

    3D Arc

  • spline (Spline3D) –

    3D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    arc: Arc3D, bspline: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D arc and a 3D B-spline

Parameters:

  • arc (Arc3D) –

    3D Arc

  • bspline (BSpline3D) –

    3D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(polyline1: Polyline2D, polyline2: Polyline2D) -> tuple

Calculate the intersection between two polylines

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(polyline: Polyline2D, polygon: Polygon2D) -> tuple

Calculate the intersection between polyline and polygon

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(polygon1: Polygon2D, polygon2: Polygon2D) -> tuple

Calculate the intersection between two polygons

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    polyline: Polyline2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D polyline and a 2D spline

Parameters:

  • polyline (Polyline2D) –

    First 2D polyline

  • spline (Spline2D) –

    Second 2D spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    polyline: Polyline2D, spline: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D polyline and a 2D bspline

Parameters:

  • polyline (Polyline2D) –

    2D Polyline

  • spline (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    polyline: Polyline3D, spline: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D polyline and a 3D bspline

Parameters:

  • polyline (Polyline3D) –

    3D Polyline

  • spline (BSpline3D) –

    3D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    polygon: Polygon2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D polygon and a 2D spline

Parameters:

  • polygon (Polygon2D) –

    First 2D polygon

  • spline (Spline2D) –

    Second 2D spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(plane: Plane3D, line: Line3D, eps: float) -> tuple

Calculate the intersection between 3D plane and 3D line

Parameters:

  • plane (Plane3D) –

    3D plane

  • line (Line3D) –

    3D line

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(plane: Plane3D, line: Polyline3D, eps: float) -> tuple

Calculate the intersection between 3D plane and 3D polyline

Parameters:

  • plane (Plane3D) –

    3D plane

  • line (Polyline3D) –

    3D polyline

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(plane: Plane3D, arc: Arc3D, eps: float) -> tuple

Calculate the intersection between 3D plane and 3D arc

Parameters:

  • plane (Plane3D) –

    3D plane

  • arc (Arc3D) –

    3D arc

  • eps (float) –

    Tolerance

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    plane: Plane3D, spline: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between 3D plane and 3D arc

Parameters:

  • plane (Plane3D) –

    3D plane

  • spline (Spline3D) –

    3D spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: Spline2D, spline2: Spline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between two 2D splines

Parameters:

  • spline1 (Spline2D) –

    First 2D spline

  • spline2 (Spline2D) –

    Second 2D spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: Spline2D, spline2: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between 2D spline and 3D spline

ote 2D spline is converted to 3D spline and calculation between 3D splines is called

Parameters:

  • spline1 (Spline2D) –

    First 2D spline

  • spline2 (Spline3D) –

    Second 3D spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: Spline3D, spline2: Spline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D Spline and a 3D Spline

Parameters:

  • spline1 (Spline3D) –

    3D Spline

  • spline2 (Spline3D) –

    3D Spline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: Spline2D, spline2: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D Spline and a 2D BSpline

Parameters:

  • spline1 (Spline2D) –

    2D Spline

  • spline2 (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: Spline3D, spline2: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D BSpline and a 3D Spline

Parameters:

  • spline1 (Spline3D) –

    3D Spline

  • spline2 (BSpline3D) –

    3D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: BSpline2D, spline2: BSpline2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D BSpline and a 2D BSpline

Parameters:

  • spline1 (BSpline2D) –

    2D BSpline

  • spline2 (BSpline2D) –

    2D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    spline1: BSpline3D, spline2: BSpline3D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D BSpline and a 3D BSpline

Parameters:

  • spline1 (BSpline3D) –

    3D BSpline

  • spline2 (BSpline3D) –

    3D BSpline

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

Vector which includes all resulting intersection points
IntersectionCalculus(
    ele1: object, ele2: object, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 3D axis and a 3D spline

Parameters:

  • ele1 (object) –

    First element

  • ele2 (object) –

    Second element

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector which includes all resulting intersection points

IntersectionCalculusEx overloaded

IntersectionCalculusEx(axis2D: Axis2D, arc2D: Arc2D, eps: float) -> tuple

Calculate the intersection between a 2D axis and a 2D arc Intersection point must not be located on the elements, it can be outside

emarks There are known precision issues with the background function lksplk

Args:
    axis2D: 2D Axis
    arc2D:  2D Arc
    eps:    precision

Returns:
    true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculusEx(axis2D: Axis2D, polyline: Polyline2D) -> tuple

Calculate the intersection between a 2D axis and a 2D polyline Intersection point must not be located on the elements, it can be outside

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector which includes all resulting intersection points

IntersectionCalculusEx(axis2D: Axis2D, polygon: Polygon2D) -> tuple

Calculate the intersection between a 2D axis and a 2D polygon Intersection point must not be located on the elements, it can be outside

Parameters:

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector which includes all resulting intersection points

IntersectionCalculusEx(
    axis2D: Axis2D, clothoid2D: Clothoid2D, eps: float, maxSolutions: int
) -> tuple

Calculate the intersection between a 2D axis and a 2D clothoid Intersection point must not be located on the elements, it can be outside

Parameters:

  • axis2D (Axis2D) –

    2D axis

  • clothoid2D (Clothoid2D) –

    2D Clothoid

  • eps (float) –

    Tolerance

  • maxSolutions (int) –

    Maximum number of solution (especially for splines and clothoids)

Returns:

  • tuple

    true, if an intersection was found, otherwise false,

  • tuple

    Vector which includes all resulting intersection points

IntersectionCalculusEx(axis: Axis3D, arc: Arc2D, eps: float) -> tuple

Calculate the intersection between a 3D axis and a 2D arc Intersection point must not be located on the elements, it can be outside

emarks There are known precision issues with the background function lksplk

Args:
    axis: 3D Axis
    arc:  2D Arc
    eps:  precision

Returns:
    true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculusEx(axis: Axis3D, polyline