Skip to content

Functions of the module Geometry

Module full path: NemAll_Python_Geometry

Exposed classes and functions from NemAll_Python_Geometry

AddToMinMax overload

AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax2D

where to ad min max box

required
point Point2D

Point2D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax2D

where to ad min max box

required
point Point3D

Point3D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax3D

where to ad min max box

required
point Point3D

Point3D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax3D

where to ad min max box

required
point Point2D

Point2D to be added

required

CalcAngle overload

CalcAngle(l1)

compute angle of 2D line and x axis

Parameters:

Name Type Description Default
l1 Line2D

2D Line

required

Returns:

Type Description
tuple

result angle (normalized 2pi),

tuple

NO_ERR, INVALID_LINE (lines is degenerated)

CalcAngle(point1, point2)

compute angle of 2D points

Parameters:

Name Type Description Default
point1 Point2D

1st point

required
point2 Point2D

2nd point

required

Returns:

Type Description
Angle

result angle (normalized 2pi)

CalcArea overload

CalcArea(p1, p2, p3)

compute area of a triangle

Parameters:

Name Type Description Default
p1 Point2D
  1. Point
required
p2 Point2D
  1. Point
required
p3 Point2D
  1. Point
required

Returns:

Type Description
tuple

area result area,

tuple

POSITIVE_ORIENTATION, NEGATIVE_ORIENTATION

CalcArea(polygon)

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:

Name Type Description Default
polygon Polygon2D

The polygon those area is requested

required

Returns:

Type Description
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)

Get the area of a Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

polygon to measure

required

Returns:

Type Description
tuple

area of the polygon,

tuple

eServiceResult of the operation, POSITIVE_ORIENTATION or INVALID_POLYGON on error

CalcArea(polygonalArea)

Get the area of a PolygonalArea

or INVALID_POLYGON on error e: berechnePolygonFlaeche

Parameters:

Name Type Description Default
polygonalArea PolygonalArea3D
required

Returns:

Type Description
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, arcSegmentation, useArcSegmentation, armLength, riseValue)

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

Parameters:

Name Type Description Default
areaGeo ClosedArea2D

The path bounded closed area those area is requested

required
arcSegmentation int

Number of segments the arc will be divided

required
useArcSegmentation int

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

required
armLength float

maximum length of a segment for polygonized arc

required
riseValue float

is the maximum distance from the actual arc and the polyline

required

Returns:

Type Description
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, arcSegmentation, useArcSegmentation, armLength, riseValue)

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

Parameters:

Name Type Description Default
areaGeo ClosedAreaComposite2D

The path bounded closed area composite those area is requested

required
arcSegmentation int

Number of segments the arc will be divided

required
useArcSegmentation int

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

required
armLength float

maximum length of a segment for polygonized arc

required
riseValue float

is the maximum distance from the actual arc and the polyline

required

Returns:

Type Description
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 overload

CalcLength(el)

calculate length of a 2D line.

Parameters:

Name Type Description Default
el Line2D

2D line.

required

Returns:

Type Description
float

double result.

CalcLength(vec)

calculate length of a 2D vector.

Parameters:

Name Type Description Default
vec Vector2D

2D vector.

required

Returns:

Type Description
float

double result.

CalcLength(polyline)

Calculate the Length of a 2D Polyline.

Parameters:

Name Type Description Default
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
float

Length of the given polyline.

CalcLength(polygon)

Calculate the Length of a 2D Polygon.

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

Parameters:

Name Type Description Default
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
float

Length of the given polygon.

CalcLength(polygon)

Calculate the Length of a 3D Polygon.

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

Parameters:

Name Type Description Default
polygon Polygon3D

3D Polygon

required

Returns:

Type Description
float

Length of the given polygon.

CalcLength(arc)

Calculate the Length of a 2D arc.

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required

Returns:

Type Description
float

Length of the given arc.

CalcLength(clothoid)

Calculate the Length of a 2D clothoid.

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D Clothoid

required

Returns:

Type Description
float

Length of the given clothoid.

CalcLength(spline)

Calculate the Length of a 2D spline.

Parameters:

Name Type Description Default
spline Spline2D

2D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(path)

Calculate the Length of a Path 2D.

Parameters:

Name Type Description Default
path Path2D

Path2D

required

Returns:

Type Description
float

Length of the given Path2D

CalcLength(line)

calculate length of a 3D line.

Parameters:

Name Type Description Default
line Line3D

3D line.

required

Returns:

Type Description
float

double result.

CalcLength(vec)

calculate length of a 3D vector.

Parameters:

Name Type Description Default
vec Vector3D

3D vector.

required

Returns:

Type Description
float

double result.

CalcLength(polyline)

calculate length of a 3D polyline.

Parameters:

Name Type Description Default
polyline Polyline3D

3D polyline.

required

Returns:

Type Description
float

double result.

CalcLength(arc)

calculate length of a 3D Arc.

Parameters:

Name Type Description Default
arc Arc3D

3D arc.

required

Returns:

Type Description
float

double result.

CalcLength(path)

calculate length of a 3D path.

Parameters:

Name Type Description Default
path Path3D

3D path.

required

Returns:

Type Description
float

double result.

CalcLength(poly)

calculate length of a polyhedron of edge type.

Parameters:

Name Type Description Default
poly Polyhedron3D

Polyhedron3D.

required

Returns:

Type Description
float

double result.

CalcLength(spline)

Calculate the Length of a 3D spline.

Parameters:

Name Type Description Default
spline Spline3D

3D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(spline)

Calculate the Length of a 3D spline.

Parameters:

Name Type Description Default
spline Spline3D

3D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(spline)

Calculate the Length of a 3D bspline.

Parameters:

Name Type Description Default
spline BSpline3D

3D BSpline

required

Returns:

Type Description
float

Length of the given spline.

CalcMass overload

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Polyhedron3D

Polyhedron3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cuboid3D

Cuboid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cylinder3D

Cylinder3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Ellipsoid3D

Ellipsoid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cone3D

Cone3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem ClippedSweptSolid3D

ClippedSweptSolid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem ExtrudedAreaSolid3D

ExtrudedAreaSolid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem BRep3D

BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMinMax overload

CalcMinMax(point)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Point2D given in parameter point

Parameters:

Name Type Description Default
point Point2D

Point2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(line)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
line Line2D

Line2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(polyline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
polyline Polyline2D

Polyline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(polygon)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
polygon Polygon2D

Polygon2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(arc)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
arc Arc2D

Arc2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline Spline2D

Spline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline Spline3D

Spline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline BSpline3D

BSpline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline BSpline2D

BSpline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(clothoid)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

Clothoid to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(path)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the Path2D.

Parameters:

Name Type Description Default
path Path2D

Path2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(area)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedArea2D.

Parameters:

Name Type Description Default
area ClosedArea2D

ClosedArea2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(area)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedAreaComposite2D.

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

ClosedAreaComposite2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(point)

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

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

Parameters:

Name Type Description Default
point Point3D

Point3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(line)

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

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

Parameters:

Name Type Description Default
line Line3D

Line3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(polyline)

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

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

Parameters:

Name Type Description Default
polyline Polyline3D

Polyline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(pointCloud)

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

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

Parameters:

Name Type Description Default
pointCloud object

PointCloud3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(polygon)

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

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

Parameters:

Name Type Description Default
polygon Polygon3D

Polygon3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(arc)

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

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

Parameters:

Name Type Description Default
arc Arc3D

Arc3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(polyhedron)

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

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

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(cuboid)

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

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

Parameters:

Name Type Description Default
cuboid Cuboid3D

Cuboid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CUBOID)

CalcMinMax(cylinder)

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

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

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CYLINDER)

CalcMinMax(cone)

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

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

Parameters:

Name Type Description Default
cone Cone3D

Cone3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CONE)

CalcMinMax(ellipsoid)

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

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

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_ELLIPSOID)

CalcMinMax(area)

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

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

Parameters:

Name Type Description Default
area PolygonalArea3D

PolygonalArea3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(solid)

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

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

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

ExtrudedAreaSolid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(solid)

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

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

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

ClippedSweptSolid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(geo)

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

Calculates the MinMax3D volume for the Path3D element.

Parameters:

Name Type Description Default
geo Path3D

Path3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_SURFACE)

CalcMinMax(geo)

Calculate 3D minmax of the B-rep body

Parameters:

Name Type Description Default
geo BRep3D

BRep3D geometry

required

Returns:

Type Description
MinMax3D

tuple(calculated MinMax3D,

eServiceResult

result code)

CalcProjectedMinMax(geo, matrix)

Calculate minmax of brep in given projection

Parameters:

Name Type Description Default
geo BRep3D

BRep3D to calculate minmax for

required
matrix Matrix3D

projection minmax

required

Returns:

Type Description
MinMax3D

tuple(minmax 3D,

eServiceResult

NO_ERR if successful)

CalcSurface(elem)

Calculate surface of BRep3D

Parameters:

Name Type Description Default
elem BRep3D

input BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

result surface

CalcVolume(elem)

Calculate volume of BRep3D

Parameters:

Name Type Description Default
elem BRep3D

input BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

result volume

CalculateNormal(brep, inputPnt)

Calculate normal vector of BRep at point

Parameters:

Name Type Description Default
brep BRep3D

BRep

required
inputPnt Point3D

input point

required

Returns:

Type Description
Vector3D

normal vector

CalculateSplineLengthToPoint(spline, splinePointIndex)

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:

Name Type Description Default
spline Spline2D

2D Spline

required
splinePointIndex int

Spline point index

required

Returns:

Type Description
float

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

Clipping(el1, el2)

test 2D line and minmax box for clipping

Parameters:

Name Type Description Default
el1 Line2D

2D line

required
el2 MinMax2D

2D minmax

required

Returns:

Type Description
eBoolOpResult

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

Colliding overload

Colliding(polygon1, polygon2)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
polygon1 Polygon2D

the first polygon

required
polygon2 Polygon2D

the second polygon

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(polygon, line)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
polygon Polygon2D

polygon

required
line Line2D

line

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(minMax, polygon)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
minMax MinMax2D

MinMax

required
polygon Polygon2D

polygon

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(brep1, brep2)

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

Parameters:

Name Type Description Default
brep1 BRep3D

1-st brep element

required
brep2 BRep3D

2-nd brep element

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Convert3DRotation(axis, angle)

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

Parameters:

Name Type Description Default
axis Axis3D

3D axis

required
angle Angle

Angle of 3D rotation

required

Returns:

Type Description
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 overload

ConvertTo2D(line3D)

Converts Line3D to Line2D

Parameters:

Name Type Description Default
line3D Line3D

Line3D to convert

required

Returns:

Type Description
bool

tuple(line2D is valid: true/false,

Line2D

Converted Line3D)

ConvertTo2D(polyline3D)

Converts Polyline3D to Polyline2D

Parameters:

Name Type Description Default
polyline3D Polyline3D

Polyline3D to convert

required

Returns:

Type Description
bool

tuple(polyline2D is valid: true/false,

Polyline2D

Converted Polyline3D)

ConvertTo2D(axis3D)

Converts Axis3D to Axis2D

Parameters:

Name Type Description Default
axis3D Axis3D

Axis3D to convert

required

Returns:

Type Description
bool

tuple(axis2D is valid: true/false,

Axis2D

Converted Axis3D)

ConvertTo2D(point3D)

Converts Point3D to Point2D

Parameters:

Name Type Description Default
point3D Point3D

Point3D to convert

required

Returns:

Type Description
bool

tuple(point3D is valid: true/false,

Point2D

Converted Point3D)

ConvertTo2D(polygon3D)

Converts Polygon3D to Polygon2D

Parameters:

Name Type Description Default
polygon3D Polygon3D

Polygon3D to convert

required

Returns:

Type Description
bool

tuple(polygon3D is valid: true/false,

Polygon2D

Converted Polygon3D)

ConvertTo2D(arc3D)

Converts Arc3D to Arc2D

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

Parameters:

Name Type Description Default
arc3D Arc3D

Arc3D to convert

required

Returns:

Type Description
bool

tuple(Arc3D is valid: true/false,

Arc2D

Converted Arc3D)

ConvertTo2D(spline3D)

Converts Spline3D to Spline2D

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

Parameters:

Name Type Description Default
spline3D Spline3D

Spline3D to convert

required

Returns:

Type Description
bool

tuple(Spline3D is valid: true/false,

Spline2D

Converted Spline3D)

ConvertTo2D(bspline3D)

Converts BSpline3D to BSpline2D

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

Parameters:

Name Type Description Default
bspline3D BSpline3D

BSpline3D to convert

required

Returns:

Type Description
bool

tuple(BSpline3D is valid: true/false,

BSpline2D

Converted BSpline3D)

ConvertTo2D(points3D)

Converts vector of Point3D to vector of Point2D

Parameters:

Name Type Description Default
points3D Point3DList

points to convert

required

Returns:

Type Description
bool

tuple(if success true,

list[Point2D]

Vector of converted points)

ConvertTo2D(path3D)

Converts Path3D to Path2D

Parameters:

Name Type Description Default
path3D Path3D

source path 2D

required

Returns:

Type Description
bool

tuple(if success true,

Path2D

resulting path 3D)

ConvertTo2D(geo_object)

Converts geometry to 2D geometry

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

Parameters:

Name Type Description Default
geo_object object

geometry to convert

required

Returns:

Type Description
object

nullptr if conversion is not possible, otherwise converted geometry

ConvertTo3D overload

ConvertTo3D(line2D, zPlane=0)

Converts Line2D to Line3D

Parameters:

Name Type Description Default
line2D Line2D

Line2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(line3D is valid: true/false,

Line3D

Converted Line3D)

ConvertTo3D(polyline2D, zPlane=0)

Converts Polyline2D to Polyline3D

Parameters:

Name Type Description Default
polyline2D Polyline2D

Polyline2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(polyline3D is valid: true/false,

Polyline3D

Converted Polyline2D)

ConvertTo3D(axis2D, zPlane=0)

Converts Axis2D to Axis3D

Parameters:

Name Type Description Default
axis2D Axis2D

Axis2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(axis3D is valid: true/false,

Axis3D

Converted Axis3D)

ConvertTo3D(spline2D, zPlane=0)

Create an elevated 3D spline from a 2D spline

Parameters:

Name Type Description Default
spline2D Spline2D

Spline to convert

required
zPlane float

Z plane for the spline

0

Returns:

Type Description
bool

tuple(spline3D is valid: true/false,

Spline3D

Converted spline3D)

ConvertTo3D(arc2D, zPlane=0)

Converts Arc2D to Arc3D

Parameters:

Name Type Description Default
arc2D Arc2D

Arc2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(arc3D is valid: true/false,

Arc3D

Converted Arc2D)

ConvertTo3D(bspline2D, zPlane=0)

Create an elevated 3D bspline from a 2D bspline

Parameters:

Name Type Description Default
bspline2D BSpline2D

BSpline2D to convert

required
zPlane float

Z plane for the spline

0

Returns:

Type Description
bool

tuple(BSpline3D is valid: true/false,

BSpline3D

Converted BSpline3D)

ConvertTo3D(path2D, zPlane=0)

Convert Path2D to Path3D

Parameters:

Name Type Description Default
path2D Path2D

Path2D to convert

required
zPlane float

Z plane for the curve

0

Returns:

Type Description
bool

tuple(bool (true = success),

Path3D

converted Path3D)

ConvertTo3D(points2D, zPlane=0)

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

Parameters:

Name Type Description Default
points2D Point2DList

vector of 2D points

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

list[Point3D]

vector of converted 3D points)

ConvertTo3D(polygon, zPlane=0)

Convert 2D polygon to a 3D polygon

Parameters:

Name Type Description Default
polygon Polygon2D

2D polygon

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

Polygon3D

3D polygon)

ConvertTo3D(clothoid2D, zPlane=0)

Convert 2D clothoid to a 3D bspline

Parameters:

Name Type Description Default
clothoid2D Clothoid2D

2D clothoid

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

BSpline3D

3D bspline)

ConvertToBSpline2D overload

ConvertToBSpline2D(arc3D)

Converts Arc3D to BSpline2D

Parameters:

Name Type Description Default
arc3D Arc3D

Arc3D to convert

required

Returns:

Type Description
bool

tuple(bspline2D is valid: true/false,

BSpline2D

Converted BSpline2D)

ConvertToBSpline2D(spline3D)

Converts Spline3D to BSpline2D

Parameters:

Name Type Description Default
spline3D Spline3D

Spline3D to convert

required

Returns:

Type Description
bool

tuple(bspline2D is valid: true/false,

BSpline2D

Converted BSpline2D)

CreateBRep3D overload

CreateBRep3D(polyhedron)

Create BRep3D by converting a polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

polyhedron to convert

required

Returns:

Type Description
tuple

error code,

tuple

BRep3D to create

CreateBRep3D(brep, faceindex)

Create brep from brep face

Parameters:

Name Type Description Default
brep BRep3D

brep to copy face from

required
faceindex int

face index

required

Returns:

Type Description
tuple

error code,

tuple

result brep

CreateFrustumOfPyramid(length, width, height, offset, bottomPlane)

) -> tuple : Create a frustum of pyramid

Parameters:

Name Type Description Default
length float

Length of the bottom

required
width float

Width of the bottom

required
height float

Height of the bottom

required
offset float

Offset of the top

required
bottomPlane Plane3D

Bottom plane

required

Returns:

Type Description
tuple

Error code

tuple

Polyhedron

CreateLoftedBRep3D(outerProfiles_object, innerProfiles_object, closecaps, createprofileedges, linear, periodic)

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

Parameters:

Name Type Description Default
outerProfiles_object list

outer profiles to loft

required
innerProfiles_object list

inner profiles to loft (represents hole in outer profile)

required
closecaps bool

close brep if possible (all profiles are closed)

required
createprofileedges bool

create profile edges and more surfaces or just create one surface

required
linear bool

linear or cubic interpolation

required
periodic bool

if the start profile is also to be the end profile

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

CreatePatchBRep3D(curves_object)

Create breps as patch from given closed 3D-curves

Parameters:

Name Type Description Default
curves_object list

vector of 3D-curves

required

Returns:

Type Description
eCreatePatchResult

tuple(Result of patch creation,

BRep3DList

created BReps)

CreatePlanarBRep3D overload

CreatePlanarBRep3D(profiles_object)

Create brep as planar surface

Parameters:

Name Type Description Default
profiles_object list

border of planar surface ( must be closed )

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

resulting BRep3D ( one planar face ))

CreatePlanarBRep3D(icurve_object)

Create brep as planar surface

Parameters:

Name Type Description Default
icurve_object object
  • border of planar surface ( must be closed )
required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D
  • resulting BRep3D ( one planar face ))

CreatePlanarSurface(geometries_object)

create planar brep

Parameters:

Name Type Description Default
geometries_object list

input geometries pointers

required

Returns:

Type Description
ePlanarSurfaceError

tuple(surface error code,

BRep3DList

planar surfaces)

CreatePolygon3D overload

CreatePolygon3D(polyhedron, faceIndex)

Creates a Polygon3D element from a Polyhedron face

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron to get face from

required
faceIndex int

Index of the face in polyhedron

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Created polygon

CreatePolygon3D(polygon2D, plane)

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

Parameters:

Name Type Description Default
polygon2D Polygon2D

2D polygon

required
plane Plane3D

plane to project 2D polygon to

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polygon

CreatePolygon3D(polyline)

Creates a Polygon3D from Polyline3D

Parameters:

Name Type Description Default
polyline Polyline3D

3D polygline

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polygon

CreatePolygon3DFromIndex(arg2, arg3, arg4)

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

CreatePolyhedron overload

CreatePolyhedron(polyhedronType, verticesCount, edgeCount, faceCount, negativeOrientation)

Create and initialize new Polyhedron3D

Parameters:

Name Type Description Default
polyhedronType PolyhedronType

Polyhedron type - edges, faces or volume.

required
verticesCount int

Count of expected vertices.

required
edgeCount int

Count of expected edges.

required
faceCount int

Count of expected faces.

required
negativeOrientation bool

True for negative orientation.

required

Returns:

Type Description
tuple

Error code,

tuple

pointer to 3D Polyhedron which will be created

CreatePolyhedron(solid)

Create polyhedron from input parametric solid

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

clipped swept solid

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(solid)

Create polyhedron from input parametric solid

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

extruded area solid

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(cylinder, countOfSegments)

Create polyhedron from input Cylinder

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder to convert

required
countOfSegments int

Count of segments

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(igeo, options)

Create polyhedron from arbitrary solid

Parameters:

Name Type Description Default
geoObject

Geometry object

required
options ApproximationSettings

ApproximationSettings structure holding options for approximation

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(brep, options)

Create polyhedron as approximation of arbitrary BRep3D

Parameters:

Name Type Description Default
brep BRep3D

arbitrary BRep3D

required
options ApproximationSettings

approximation settings

required

Returns:

Type Description
tuple

Error code,

tuple

polyhedron to create

CreatePolyhedron(polygon)

Create polyhedron from Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

Reference to Polygon3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(line)

Create polyhedron from Line3D

Parameters:

Name Type Description Default
line Line3D

Reference to Line3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(lines)

Create polyhedron from vector of 3D lines

Parameters:

Name Type Description Default
lines Line3DList

vector of lines

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(polyline)

Create polyhedron from Polyline3D

Parameters:

Name Type Description Default
polyline Polyline3D

Reference to Polyline3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(base, path)

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
base Polygon3D

base polygon

required
path Polyline3D

translation path

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(base, refPoint, path)

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
base Polygon2D

base polygon 2D

required
refPoint Point2D

reference point used for transformation

required
path Polyline3D

translation path

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(polygon, bottomPlane, topPlane)

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

Parameters:

Name Type Description Default
polygon Polygon2D

polygon 2D

required
bottomPlane Plane3D

the bottom plane

required
topPlane Plane3D

the top plane

required

Returns:

Type Description
tuple

error code,

tuple

Polyhedron which will be created

CreatePolyhedron(baseOutline, leftOffset, rightOffset, frontOffset, backOffset, bottomPlane, topPlane)

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

Parameters:

Name Type Description Default
baseOutline Polygon2D

base outline polygon 2D (rectangle of 4 points)

required
leftOffset float

offset from base outline on the left side

required
rightOffset float

offset from base outline on the right side

required
frontOffset float

offset from base outline on the front side

required
backOffset float

offset from base outline on the back side

required
bottomPlane Plane3D

element's bottom plane

required
topPlane Plane3D

element's top plane

required

Returns:

Type Description
tuple

Error code,

tuple

polyhedron which will be created

CreatePolyhedron(startPolygon, endPolygon)

Create a polyhedron from a 3D start and end polygon

Parameters:

Name Type Description Default
startPolygon Polygon3D

Start polygon

required
endPolygon Polygon3D

End polygon

required

Returns:

Type Description
tuple

Error code

tuple

Polyhedron

CreatePolyline3D overload

CreatePolyline3D(polyhedron)

Creates a Polyline3D element from a Polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron to create line from

required

Returns:

Type Description
tuple

eOK if converted successful, else eError,

tuple

Created Polyline

CreatePolyline3D(polyline2D)

Create Polyline3D from Polyline2D

Parameters:

Name Type Description Default
polyline2D Polyline2D

Reference to Polyline2D

required

Returns:

Type Description
tuple

eOK if created successful, else eError,

tuple

Reference to empty Polyline3D

CreatePolyline3D(polygon)

Creates a Polyline3D from Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

3D polygon

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polyline

CreatePolyline3DFromIndex(startPol, endPol, index, count)

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:

Type Description
Polyline3D

eOK if converted successful, else eError,

Polyline3D

Created Polyline

CreateRailSweptBRep3D overload

CreateRailSweptBRep3D(profiles_object, rails_object, closecaps, uniformScaling, railrotation)

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

Parameters:

Name Type Description Default
profiles_object list

profiles to sweep

required
rails_object list

rails to control sweeping

required
closecaps bool

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

required
uniformScaling bool

use uniform scaling for profiles along the rails

required
railrotation bool

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

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D (1 swept face))

CreateRailSweptBRep3D(profiles_object, rails_object, path_object, closecaps, uniformScaling, railrotation, proportionalVertexMatch)

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

Parameters:

Name Type Description Default
profiles_object list

profiles to sweep

required
rails_object list

rails to control sweeping

required
path_object object

user defined path

required
closecaps bool

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

required
uniformScaling bool

use uniform scaling for profiles along the rails

required
railrotation bool

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

required
proportionalVertexMatch bool

Flag whether to use proportional vertex matching

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D (1 swept face),

Path3D

path for body creation)

CreateRevolvedBRep3D(profiles_object, axis, rotationAngle, closecaps, numprofiles)

Create brep as revolved body.

Parameters:

Name Type Description Default
profiles_object list

vector of profile curves

required
axis Axis3D

axis of rotation

required
rotationAngle Angle

angle of rotation

required
closecaps bool

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

required
numprofiles int

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

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

created brep)

CreateSweptBRep3D overload

CreateSweptBRep3D(profiles_object, path_object, closecaps, railrotation, rotAxis=None, numprofiles=0)

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

Parameters:

Name Type Description Default
profiles_object list

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

required
path_object object

path to extrude along

required
closecaps bool

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

required
railrotation SweepRotationType

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None
numprofiles int

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

0

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

CreateSweptBRep3D(profiles_object, path_object, closecaps, railrotation, rotAxis=None, numprofiles=0)

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

Parameters:

Name Type Description Default
profiles_object list

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

required
path_object object

path to extrude along

required
closecaps bool

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

required
railrotation bool

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None
numprofiles int

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

0

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

CreateSweptBRep3D(profile_object, path_object, railrotation, rotAxis=None)

Create BRep3D by means of a profile extrusion along a path

Parameters:

Name Type Description Default
profile_object object

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

required
path_object object

path to extrude along

required
railrotation bool

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

CreateSweptPolyhedron3D(profiles, path, closecaps, railrotation, rotAxis)

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
profiles Polyline3DList

profiles to sweep

required
path Polyline3D

translation path

required
closecaps bool

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

required
railrotation bool

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

required
rotAxis Vector3D

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

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CutBrepWithPlane(original, plane)

Cut Brep with plane - create two independent BReps

Parameters:

Name Type Description Default
original BRep3D

original brep

required
plane Plane3D

cutting plane

required

Returns:

Type Description
bool

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.,

BRep3D

result brep above the plane,

BRep3D

result brep below the plane)

CutPolyhedronWithPlane(original, plane)

Cut polyhedron with plane - create two independent polyhedra

Parameters:

Name Type Description Default
original Polyhedron3D

original polyhedron

required
plane Plane3D

cutting plane

required

Returns:

Type Description
bool

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

Polyhedron3D

result polyhedron above the plane,

Polyhedron3D

result polyhedron below the plane)

DeletePolyhedronLastFace(polyhedron)

Delete the last face of given polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron3D

required

Returns:

Type Description
object

Error code

FindMinDistancePoint overload

FindMinDistancePoint(point, bspline)

Find minimal distance point between Point3D and BSpline3D

Parameters:

Name Type Description Default
point Point3D

Point3D

required
bspline BSpline3D

BSpline3D

required

Returns:

Type Description
tuple

error code,

tuple

point on bspline with minimal distance

FindMinDistancePoint(point, brep)

Find minimal distance point between Point3D and BSpline3D

Parameters:

Name Type Description Default
point Point3D

Point3D

required
brep BRep3D

BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

point on brep with minimal distance

GetAbsoluteTolerance()

get absolute tolerance

Returns:

Type Description
float

absolute tolerance

GetAllIntersections(geoObject1, geoObject2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

GetAngleTolerance()

Get angle tolerance

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

Returns:

Type Description
Angle

Tolerance using for angle comparison [rad]

GetClosestIntersection(geometrie1, geometrie2, inputPoint, eps, bOnlyInsidePoints)

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:

Name Type Description Default
geometrie1 object

First object

required
geometrie2 object

Second object

required
inputPoint Point3D

Reference Point / Cursor point

required
eps float

Tolerance

required
bOnlyInsidePoints bool

Return point must be on both objects

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

intersection point

GetCurvatureTolerance()

Get curvature tolerance

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

Returns:

Type Description
float

Tolerance using for curvature comparison

GetCurveLengthTolerance()

Get tolerance for curve length comparison

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

Returns:

Type Description
float

Tolerance using for length of curve comparison [mm]

GetIntersectionPoints(geoObject1, geoObject2, eps)

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:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance (optional)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector of intersection points and additional information

GetRelativeTolerance()

get relative tolerance

Returns:

Type Description
float

relative tolerance

GetRotationMatrix overload

GetRotationMatrix(zeroPoint, angle)

Creates 2D rotation matrix

Parameters:

Name Type Description Default
zeroPoint Point2D

Rotation point

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix2D

2D rotation matrix

GetRotationMatrix(axis, angle)

Creates 3D rotation matrix

Parameters:

Name Type Description Default
axis Axis3D

Rotation axis

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix3D

3D rotation Matrix

GetRotationMatrix(line, angle)

Creates 3D rotation matrix

Parameters:

Name Type Description Default
line Line3D

Rotation line, extended to axis

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix3D

3D rotation Matrix

GroundViewHiddenCalculation overload

GroundViewHiddenCalculation(brep)

Hidden calculation with ground view of BRep

Parameters:

Name Type Description Default
brep BRep3D

BRep

required

Returns:

Type Description
eGeometryErrorCode

tuple(Error code,

list[Any]

Vector of visible edges,

list[Any]

Vector of hidden edges)

GroundViewHiddenCalculation(poly)

Hidden calculation with ground view of polyhedron.

Parameters:

Name Type Description Default
poly Polyhedron3D

polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(Error code,

list[Line3D]

Vector of visible edges,

list[Line3D]

Vector of hidden edges)

ImprintProfileOnFaces(brep, targetFaces, profile_object)

Imprint edges on brep

Parameters:

Name Type Description Default
brep BRep3D

Brep

required
targetFaces [list[int] | VecUIntList]

faces where to imprint edges

required
profile_object Union[Arc3D, BSpline3D, Line3D, Path3D, Polyline3D, Polygon3D, Spline3D]

imprinted profile

required

Returns:

Type Description
eGeometryErrorCode

tuple(eOK if successful otherwise eError,

BRep3D

Brep

[list[int] | VecUIntList]

new faces after imprint)

Intersect overload

Intersect(bodies1_list, bodies2_list)

compute intersection of set of bodies

Parameters:

Name Type Description Default
bodies1_list PolyhedronTypesList

list of bodies

required
bodies2_list PolyhedronTypesList

list of bodies

required

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Polyhedron3D

resulted polyhedron)

Intersect(el1, el2)

calculate intersection between 2 3D planes

Parameters:

Name Type Description Default
el1 Plane3D

the first plane

required
el2 Plane3D

the second plane

required

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Axis3D

common axis of planes)

Intersect(el1, el2)

compute intersection of 2 3D polyhedron

Parameters:

Name Type Description Default
el1 Polyhedron3D
  1. element
required
el2 Polyhedron3D
  1. element
required

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Polyhedron3D

resulted polyhedron)

Intersect(brep1, brep2)

Compute intersection of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(true when intersecting, otherwise false.,

BRep3D

result brep of intersection)

Intersect(brep, polyhedron)

Compute intersection of 2 bodies

Parameters:

Name Type Description Default
brep BRep3D

first element - BRep3D

required
polyhedron Polyhedron3D

second element - Polyhedron3D

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

IntersectRayBRep(rayPoint, rayVector, brep, bNegativPrefered)

Intersection of Ray and BRep

Parameters:

Name Type Description Default
rayPoint Point3D

ray Point

required
rayVector Vector3D

direction vector of ray

required
brep BRep3D

BRep

required
bNegativPrefered bool

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

required

Returns:

Type Description
int

tuple(0 if no error occurs,

IntersectionRayBRep

structure with result of intersection)

IntersectRayPolyhedron(rayPoint, rayVector, polyhedron, flag, selFaces=None)

Intersection of Ray and Polyhedron

Parameters:

Name Type Description Default
rayPoint Point3D

ray Point

required
rayVector Vector3D

direction vector of ray

required
polyhedron Polyhedron3D

polyhedron

required
flag IntersectRayPolyhedronFlag

flag for determining the "best" intersection

required
selFaces Optional[[list[int] | VecIntList]]

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

None

Returns:

Type Description
int

tuple(0 if no error occured,

IntersectionRayPolyhedron

structure with result of intersection)

Intersecting overload

Intersecting(el1, el2)

test 2 2D minmaxes for intersection

Parameters:

Name Type Description Default
el1 MinMax2D
  1. element
required
el2 MinMax2D
  1. element
required

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2, tol)

test 2 2D lines for intersection

Parameters:

Name Type Description Default
el1 Line2D
  1. element
required
el2 Line2D
  1. element
required
tol float

tolerance

required

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2, tol)

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

Parameters:

Name Type Description Default
el1 Polygon2D
  1. element
required
el2 Polygon2D
  1. element
required
tol float

tolerance

required

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2)

test 2 breps for intersection

Parameters:

Name Type Description Default
el1 BRep3D
  1. element
required
el2 BRep3D
  1. element
required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test brep and polyhedron for intersection

Parameters:

Name Type Description Default
el1 BRep3D

brep to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D arc and polyhedron for intersection

Parameters:

Name Type Description Default
el1 Arc3D

arc to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D arc and brep for intersection

Parameters:

Name Type Description Default
el1 Arc3D

arc to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D spline and polyhedron for intersection

Parameters:

Name Type Description Default
el1 Spline3D

spline to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D spline and brep for intersection

Parameters:

Name Type Description Default
el1 Spline3D

spline to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D bspline and polyhedron for intersection

Parameters:

Name Type Description Default
el1 BSpline3D

bspline to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D bspline and brep for intersection

Parameters:

Name Type Description Default
el1 BSpline3D

bspline to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

IntersectingRel overload

IntersectingRel(el1, el2)

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

Parameters:

Name Type Description Default
el1 MinMax2D
  1. element
required
el2 MinMax2D
  1. element
required

Returns:

Type Description
bool

true when intersecting, otherwise false.

IntersectingRel(el1, el2)

test 2 2D lines for intersection

Parameters:

Name Type Description Default
el1 Line2D
  1. element
required
el2 Line2D
  1. element
required

Returns:

Type Description
bool

true when intersecting, otherwise false.

IntersectionCalculus overload

IntersectionCalculus(el1, el2)

compute intersection of 2 2D axis

Parameters:

Name Type Description Default
el1 Axis2D
  1. element
required
el2 Axis2D
  1. element
required

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(axis, line)

compute intersection between 2D axis and 2D line

Parameters:

Name Type Description Default
axis Axis2D

2D Axis

required
line Line2D

2D line

required

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(axis2D, axis3D)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
axis3D Axis3D

3D Axis

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis2D, arc2D, eps)

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, polyline)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, polygon)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis1, axis2)

Calculate the intersection between two 3D axis

Parameters:

Name Type Description Default
axis1 Axis3D

First 3D Axis

required
axis2 Axis3D

Second 3D Axis

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, line)

Calculate the intersection between 3D axis and 2D line

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
line Line2D

2D line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, arc, eps)

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, polyline)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, polygon)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline BSpline3D

3D B-Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, plane, eps)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
plane Plane3D

3D Plane

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line, plane, eps)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
plane Plane3D

3D Plane

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, arc, eps)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
arc Arc3D

3D Arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection points

IntersectionCalculus(line, arc, eps)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
arc Arc3D

3D Arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection points

IntersectionCalculus(el1, el2)

compute intersection of 2 2D line

Parameters:

Name Type Description Default
el1 Line2D
  1. element
required
el2 Line2D
  1. element
required

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(line2D, line3D)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
line3D Line3D

3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line2D, arc2D, eps)

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, polyline)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line2D, polygon)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line2D

2D Line

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line1, line2)

Calculate the intersection between two 3D line

Parameters:

Name Type Description Default
line1 Line3D

First 3D Line

required
line2 Line3D

Second 3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line, arc, eps)

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, polyline)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, polygon)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
bspline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc1, arc2)

Calculate the intersection between two arcs

Parameters:

Name Type Description Default
arc1 Arc2D

2D Arc

required
arc2 Arc2D

2D Arc

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, polyline, eps)

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, polygon, intersectionPnts)

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, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, arc2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

First 3D Arc

required
arc2 Arc3D

Second 3D Arc

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
bspline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline1, polyline2)

Calculate the intersection between two polylines

Parameters:

Name Type Description Default
polyline1 Polyline2D

2D polyline

required
polyline2 Polyline2D

2D polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, polygon)

Calculate the intersection between polyline and polygon

Parameters:

Name Type Description Default
polyline Polyline2D

2D polyline

required
polygon Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polygon1, polygon2)

Calculate the intersection between two polygons

Parameters:

Name Type Description Default
polygon1 Polygon2D

2D polygon

required
polygon2 Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

First 2D polyline

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

2D Polyline

required
spline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline3D

3D Polyline

required
spline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polygon, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polygon Polygon2D

First 2D polygon

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, line, eps)

Calculate the intersection between 3D plane and 3D line

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
line Line3D

3D line

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, line, eps)

Calculate the intersection between 3D plane and 3D polyline

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
line Polyline3D

3D polyline

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, arc, eps)

Calculate the intersection between 3D plane and 3D arc

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
arc Arc3D

3D arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, spline, eps, maxSolutions)

Calculate the intersection between 3D plane and 3D arc

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
spline Spline3D

3D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

Calculate the intersection between two 2D splines

Parameters:

Name Type Description Default
spline1 Spline2D

First 2D spline

required
spline2 Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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:

Name Type Description Default
spline1 Spline2D

First 2D spline

required
spline2 Spline3D

Second 3D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline3D

3D Spline

required
spline2 Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline2D

2D Spline

required
spline2 BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline3D

3D Spline

required
spline2 BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 BSpline2D

2D BSpline

required
spline2 BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 BSpline3D

3D BSpline

required
spline2 BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(ele1, ele2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
ele1 object

First element

required
ele2 object

Second element

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx overload

IntersectionCalculusEx(axis2D, arc2D, eps)

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, polyline)

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:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis2D, polygon)

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:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis2D, clothoid2D, eps, maxSolutions)

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:

Name Type Description Default
axis2D Axis2D

2D axis

required
clothoid2D Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis, arc, eps)

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, polyline)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis, polygon)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line1, line2)

Calculate the intersection between two 2D lines. Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
line1 Line2D

First 2D Line

required
line2 Line2D

Second 2D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line2D, line3D)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
line3D Line3D

3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line2D, arc2D, eps)

Calculate the intersection between a 2D line 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:
    line2D:  2D Line
    arc2D:   2D Arc
    eps:     precision

Returns:
    true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculusEx(line2D, clothoid2D, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
clothoid2D Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, polyline)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, polygon)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, spline, eps, maxSolutions)

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

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line1, line2)

Calculate the intersection between two 3D line Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
line1 Line3D

First 3D Line

required
line2 Line3D

Second 3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line, arc, eps)

Calculate the intersection between a 3D line 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:
    line:  3D Line
    arc:   2D Arc
    eps:   precision

Returns:
    true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculusEx(line, arc, eps)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
arc Arc3D

3D Arc

required
eps float

precision

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, clothoid, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
clothoid Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solutions (Defines the maximum size of the solution vector)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, polyline)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, polygon)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc1, arc2)

Calculate the intersection between two arcs Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
arc1 Arc2D

2D Arc

required
arc2 Arc2D

2D Arc

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, clothoid, eps, maxSolutions)

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

emarks There are known precision issues with the background function kurve6 which is only correct for circles

Args:
    arc:           2D Arc
    clothoid:      2D Clothoid
    eps:           Tolerance
    maxSolutions:  Maximum number of solution (especially for splines and clothoids)

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

Calculate the intersection between a 2D arc and a 2D polyline 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:
    arc:       2D Arc
    polyline:  2D Polyline
    eps:       precision

Returns:
    true, if an intersection was found, otherwise false,
    Vector which includes all resulting intersection points
IntersectionCalculusEx(arc, polygon, intersectionPnts)

Calculate the intersection between a 2D arc and a 2D polygon 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:
    arc:               2D Arc
    polygon:           2D Polygon
    intersectionPnts:  Vector which includes all resulting intersection points

Returns:
    true, if an intersection was found, otherwise false,
    precision
IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc1, arc2, eps, maxSolutions)

Calculate the intersection between two arcs Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
arc1 Arc3D

3D Arc

required
arc2 Arc3D

3D Arc

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline BSpline3D

3D bSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(clothoid, polyline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
polyline Polyline2D

2D polyline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(clothoid, polygon, eps, maxSolutions)

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
polygon Polygon2D

2D polygon

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polyline1, polyline2)

Calculate the intersection between two 2D polylines Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
polyline1 Polyline2D

2D polyline

required
polyline2 Polyline2D

2D polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polygon1, polygon2)

Calculate the intersection between two 2D polygons Intersection point must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
polygon1 Polygon2D

2D polygon

required
polygon2 Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

First 2D polyline

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polygon, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polygon Polygon2D

First 2D polygon

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(geoObject1, geoObject2, eps, maxSolutions, bOnlyInsidePoints)

Calculate intersections between two geometry objects Intersection points must not be located on the elements, it can be outside

Parameters:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required
bOnlyInsidePoints bool

Intersection points must be on both objects

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IsCoplanar overload

IsCoplanar(geoVector_object)

Check if the 3D geometry objects are coplanar and calculate plane

Parameters:

Name Type Description Default
geoVector_object list

vector of object geometries

required

Returns:

Type Description
bool

tuple(True if objects are coplanar, false otherwise.,

Plane3D

result plane - if collinear plane is not valid)

IsCoplanar(igeo1_object, igeo2_object)

Check if two 3D curved geometry objects are coplanar and calculate plane

Parameters:

Name Type Description Default
igeo1_object object

first object geometry

required
igeo2_object object

second object geometry

required

Returns:

Type Description
bool

tuple(True if objects are coplanar, false otherwise.,

Plane3D

result plane,

bool

flag if lines are parallel)

IsCoplanar(plane, geo_object)

Find out if plane and geometry are coplanar

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
geo_object object

objects geometry

required

Returns:

Type Description
bool

True, if geometry is lying in the plane otherwise return false.

IsCoplanar(plane, point)

Find out if point lies on plane

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
point Point3D

Point3D

required

Returns:

Type Description
bool

True, if point lies on plane otherwise return false.

IsCoplanar(plane, line)

Find out if line lies on plane

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
line Line3D

Line3D

required

Returns:

Type Description
bool

True, if line lies on plane otherwise return false.

IsCoplanar(plane1, plane2)

Find out if planes are coplanar

Parameters:

Name Type Description Default
plane1 Plane3D

Plane3D

required
plane2 Plane3D

Plane3D

required

Returns:

Type Description
bool

True, if planes are coplanar otherwise return false.

IsCoplanar(point1, point2, point3, point4)

Find out if four points are coplanar

Parameters:

Name Type Description Default
point1 Point3D

Point3D

required
point2 Point3D

Point3D

required
point3 Point3D

Point3D

required
point4 Point3D

Point3D

required

Returns:

Type Description
bool

True, if points are coplanar otherwise return false.

IsCoplanar(line1, line2)

Find out if two lines are coplanar

Parameters:

Name Type Description Default
line1 Line3D

Line3D

required
line2 Line3D

Line3D

required

Returns:

Type Description
bool

True, if lines are coplanar otherwise return false.

IsCoplanar(line1, line2)

Check if lines are coplanar and calculate plane

Parameters:

Name Type Description Default
line1 Line3D

Line3D

required
line2 Line3D

Line3D]

required

Returns:

Type Description
bool

tuple(True, if lines are coplanar.,

Plane3D

result plane)

MakeBoolean overload

MakeBoolean(el1, el2)

make boolean operation between line and polygon

Parameters:

Name Type Description Default
el1 Line2D

Line2D

required
el2 Polygon2D

Polygon2D

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Line2DList

set of line segments which are inside input polygon, NULL if not desired,

Line2DList

set of line segments which are outside input polygon, NULL if not desired)

MakeBoolean(el1, el2)

make boolean operation between two 2D profile elements

Now it is done for Polygon2D, later with new Profile element.

Parameters:

Name Type Description Default
el1 Polygon2D

first element geometry

required
el2 Polygon2D

second element geometry

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

output 2D profile of intersection,

Polygon2D

output 2D profile of union,

Polygon2D

output 2D profile of subtraction element1 minus element2,

Polygon2D

output 2D profile of subtraction element2 minus element1)

MakeBoolean(el1, el2)

make boolean operation between two 3D bodies

As input arbitrary element which represents 3D is possible.

Throws exception when element is not suitable for booleans

Parameters:

Name Type Description Default
el1 Polyhedron3D

first element geometry

required
el2 Polyhedron3D

second element geometry

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of intersection,

Polyhedron3D

output 3D body of union,

Polyhedron3D

output 3D body of subtraction element1 minus element2,

Polyhedron3D

output 3D body of subtraction element2 minus element1)

MakeIntersection overload

MakeIntersection(brep1, breps)

Compute intersection of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
breps BRep3DList

second brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(eOK if intersection was successful,

BRep3D

result brep of intersection)

MakeIntersection(brep1, brep2)

Deprecated: use Intersect(...)

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep

required

Returns:

Type Description
tuple

error code, eOK if intersection was successful,

tuple

result brep of intersection

MakeIntersection(brep, polyhedron)

Deprecated: use Intersect(...)

Parameters:

Name Type Description Default
brep BRep3D

first element - BRep3D

required
polyhedron Polyhedron3D

second element - Polyhedron3D

required

Returns:

Type Description
tuple

error code,

tuple

result BRep3D

MakeIntersection(el1, el2)

Deprecated: use Intersect(...)

Parameters:

Name Type Description Default
el1 Polyhedron3D
  1. element
required
el2 Polyhedron3D
  1. element
required

Returns:

Type Description
tuple

error code, eOK if intersection was successful,

tuple

resulted polyhedron

MakeSectionWithSurfaces(brep1, brep2)

Compute section of brep and surface brep

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

section brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3DList

section resulting breps)

MakeSubtraction overload

MakeSubtraction(body_object, voidbodies_list)

make subtraction of 3D bodies from given body

Parameters:

Name Type Description Default
body_object Union[Polyhedron3D, Cylinder3D, ExtrudedAreaSolid3D, Line3D, Polyline3D, Polygon3D, ClippedSweptSolid3D]

input body

required
voidbodies_list PolyhedronTypesList

list of 3D bodies to subtract

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of subtraction)

MakeSubtraction(poly1, poly2)

make subtraction of 2D polygons, if wished intersection is computed too.

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

output 2D polygon of subtraction,

Polygon2D

output 2D polygon of intersection)

MakeSubtraction(polyhed1, polyhed2)

make subtraction of polyhed1 - polyhed2

Parameters:

Name Type Description Default
polyhed1 Polyhedron3D

first polyhedron

required
polyhed2 Polyhedron3D

second polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

result 3D polyhedron of subtraction)

MakeSubtraction(brep1, brep2)

Compute subtraction of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep to be subtracted from the first brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of subtraction)

MakeSubtraction(brep1, breps)

Compute subtraction of brep and vector of breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
breps BRep3DList

vector of brep to be subtracted from the first brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of subtraction)

MakeSubtraction(poly1, poly2, intersection)

Deprecated: use MakeSubtraction(const Polygon2D& poly1, const Polygon2D& poly2)

make subtraction of 2D polygons, if wished intersection is computed too.

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required
intersection Polygon2D

output 2D polygon of intersection, as input NULL if not required

required

Returns:

Type Description
tuple

GeoErrorCode,

tuple

output 2D polygon of subtraction

MakeUnion overload

MakeUnion(bodies_list, voidbodies_list)

make union of 3D bodies

As input arbitrary elements which represents 3D is possible.

Parameters:

Name Type Description Default
bodies_list PolyhedronTypesList

list of 3D bodies

required
voidbodies_list PolyhedronTypesList

list of 3D bodies to subtract

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of union)

MakeUnion(poly1, poly2)

make union of 2D polygons

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

result 2D polygon of union)

MakeUnion(polyhed1, polyhed2)

make union of 3D polyhedrons

Parameters:

Name Type Description Default
polyhed1 Polyhedron3D

first polyhedron

required
polyhed2 Polyhedron3D

second polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

result 3D polyhedron of union)

MakeUnion(bodies)

Compute bulk union of more polyhedra at once

Parameters:

Name Type Description Default
bodies Polyhedron3DList

polyhedra to unite

required

Returns:

Type Description
tuple[bool, Polyhedron3D]

if success result polyhedron otherwise nullopt

MakeUnion(brep1, brep2)

Compute union of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep