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 2DMin 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 2DMin 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 3DMin 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 3DMin 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


required 
p2

Point2D


required 
p3

Point2D


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 selfintersecting. 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 3DMin 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 Brep 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

1st brep element 
required 
brep2

BRep3D

2nd 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 3Dcurves
Parameters:
Name  Type  Description  Default 

curves_object

list

vector of 3Dcurves 
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


required 
Returns:
Type  Description 

eGeometryErrorCode

tuple(error code, 
BRep3D


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 zaxis 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


required 
el2

Polyhedron3D


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


required 
el2

MinMax2D


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


required 
el2

Line2D


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


required 
el2

Polygon2D


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


required 
el2

BRep3D


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 builtin relative tolerance
Parameters:
Name  Type  Description  Default 

el1

MinMax2D


required 
el2

MinMax2D


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


required 
el2

Line2D


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


required 
el2

Axis2D


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 Bspline
Parameters:
Name  Type  Description  Default 

axis

Axis3D

3D Axis 
required 
spline

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(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


required 
el2

Line2D


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 Bspline
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 Bspline
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


required 
el2

Polyhedron3D


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 