Skip to content

Functions of the module Geometry

Module full path: NemAll_Python_Geometry

Exposed classes and functions from NemAll_Python_Geometry

AddToMinMax overload

AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax2D

where to ad min max box

required
point Point2D

Point2D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax2D

where to ad min max box

required
point Point3D

Point3D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax3D

where to ad min max box

required
point Point3D

Point3D to be added

required
AddToMinMax(minMax, point)

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

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

Parameters:

Name Type Description Default
minMax MinMax3D

where to ad min max box

required
point Point2D

Point2D to be added

required

CalcAngle overload

CalcAngle(l1)

compute angle of 2D line and x axis

Parameters:

Name Type Description Default
l1 Line2D

2D Line

required

Returns:

Type Description
tuple

result angle (normalized 2pi),

tuple

NO_ERR, INVALID_LINE (lines is degenerated)

CalcAngle(point1, point2)

compute angle of 2D points

Parameters:

Name Type Description Default
point1 Point2D

1st point

required
point2 Point2D

2nd point

required

Returns:

Type Description
Angle

result angle (normalized 2pi)

CalcArea overload

CalcArea(p1, p2, p3)

compute area of a triangle

Parameters:

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

Returns:

Type Description
tuple

area result area,

tuple

POSITIVE_ORIENTATION, NEGATIVE_ORIENTATION

CalcArea(polygon)

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

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

Parameters:

Name Type Description Default
polygon Polygon2D

The polygon those area is requested

required

Returns:

Type Description
tuple

The area of the polygon,

tuple

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

tuple

NEGATIVE_ORIENTATION for a CW orientated polygon, INVALID_POLYGON on error

CalcArea(polygon)

Get the area of a Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

polygon to measure

required

Returns:

Type Description
tuple

area of the polygon,

tuple

eServiceResult of the operation, POSITIVE_ORIENTATION or INVALID_POLYGON on error

CalcArea(polygonalArea)

Get the area of a PolygonalArea

or INVALID_POLYGON on error e: berechnePolygonFlaeche

Parameters:

Name Type Description Default
polygonalArea PolygonalArea3D
required

Returns:

Type Description
tuple

The area of the PolygonalArea,

tuple

The eServiceResult of the operation, POSITIVE_ORIENTATION

tuple

or INVALID_POLYGON on error

tuple

Old interface: berechnePolygonFlaeche


CalcArea(areaGeo, arcSegmentation, useArcSegmentation, armLength, riseValue)

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

Parameters:

Name Type Description Default
areaGeo ClosedArea2D

The path bounded closed area those area is requested

required
arcSegmentation int

Number of segments the arc will be divided

required
useArcSegmentation int

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

required
armLength float

maximum length of a segment for polygonized arc

required
riseValue float

is the maximum distance from the actual arc and the polyline

required

Returns:

Type Description
tuple

The area of the given geometry,

tuple

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

tuple

NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

CalcArea(areaGeo, arcSegmentation, useArcSegmentation, armLength, riseValue)

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

Parameters:

Name Type Description Default
areaGeo ClosedAreaComposite2D

The path bounded closed area composite those area is requested

required
arcSegmentation int

Number of segments the arc will be divided

required
useArcSegmentation int

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

required
armLength float

maximum length of a segment for polygonized arc

required
riseValue float

is the maximum distance from the actual arc and the polyline

required

Returns:

Type Description
tuple

The area of the given geometry,

tuple

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

tuple

NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error

CalcLength overload

CalcLength(el)

calculate length of a 2D line.

Parameters:

Name Type Description Default
el Line2D

2D line.

required

Returns:

Type Description
float

double result.

CalcLength(vec)

calculate length of a 2D vector.

Parameters:

Name Type Description Default
vec Vector2D

2D vector.

required

Returns:

Type Description
float

double result.

CalcLength(polyline)

Calculate the Length of a 2D Polyline.

Parameters:

Name Type Description Default
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
float

Length of the given polyline.

CalcLength(polygon)

Calculate the Length of a 2D Polygon.

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

Parameters:

Name Type Description Default
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
float

Length of the given polygon.

CalcLength(polygon)

Calculate the Length of a 3D Polygon.

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

Parameters:

Name Type Description Default
polygon Polygon3D

3D Polygon

required

Returns:

Type Description
float

Length of the given polygon.

CalcLength(arc)

Calculate the Length of a 2D arc.

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required

Returns:

Type Description
float

Length of the given arc.

CalcLength(clothoid)

Calculate the Length of a 2D clothoid.

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D Clothoid

required

Returns:

Type Description
float

Length of the given clothoid.

CalcLength(spline)

Calculate the Length of a 2D spline.

Parameters:

Name Type Description Default
spline Spline2D

2D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(path)

Calculate the Length of a Path 2D.

Parameters:

Name Type Description Default
path Path2D

Path2D

required

Returns:

Type Description
float

Length of the given Path2D

CalcLength(line)

calculate length of a 3D line.

Parameters:

Name Type Description Default
line Line3D

3D line.

required

Returns:

Type Description
float

double result.

CalcLength(vec)

calculate length of a 3D vector.

Parameters:

Name Type Description Default
vec Vector3D

3D vector.

required

Returns:

Type Description
float

double result.

CalcLength(polyline)

calculate length of a 3D polyline.

Parameters:

Name Type Description Default
polyline Polyline3D

3D polyline.

required

Returns:

Type Description
float

double result.

CalcLength(arc)

calculate length of a 3D Arc.

Parameters:

Name Type Description Default
arc Arc3D

3D arc.

required

Returns:

Type Description
float

double result.

CalcLength(path)

calculate length of a 3D path.

Parameters:

Name Type Description Default
path Path3D

3D path.

required

Returns:

Type Description
float

double result.

CalcLength(poly)

calculate length of a polyhedron of edge type.

Parameters:

Name Type Description Default
poly Polyhedron3D

Polyhedron3D.

required

Returns:

Type Description
float

double result.

CalcLength(spline)

Calculate the Length of a 3D spline.

Parameters:

Name Type Description Default
spline Spline3D

3D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(spline)

Calculate the Length of a 3D spline.

Parameters:

Name Type Description Default
spline Spline3D

3D Spline

required

Returns:

Type Description
float

Length of the given spline.

CalcLength(spline)

Calculate the Length of a 3D bspline.

Parameters:

Name Type Description Default
spline BSpline3D

3D BSpline

required

Returns:

Type Description
float

Length of the given spline.

CalcMass overload

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Polyhedron3D

Polyhedron3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cuboid3D

Cuboid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cylinder3D

Cylinder3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Ellipsoid3D

Ellipsoid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem Cone3D

Cone3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem ClippedSweptSolid3D

ClippedSweptSolid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem ExtrudedAreaSolid3D

ExtrudedAreaSolid3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMass(elem)

Calculate mass values

Parameters:

Name Type Description Default
elem BRep3D

BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

calculated volume,

tuple

calculated surface,

tuple

calculated gravity point

CalcMinMax overload

CalcMinMax(point)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box by the Point2D given in parameter point

Parameters:

Name Type Description Default
point Point2D

Point2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(line)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
line Line2D

Line2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(polyline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
polyline Polyline2D

Polyline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(polygon)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
polygon Polygon2D

Polygon2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(arc)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
arc Arc2D

Arc2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline Spline2D

Spline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline Spline3D

Spline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline BSpline3D

BSpline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(spline)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
spline BSpline2D

BSpline2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(clothoid)

Calculate Min- and Max Point of an element.

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

Clothoid to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(path)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the Path2D.

Parameters:

Name Type Description Default
path Path2D

Path2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(area)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedArea2D.

Parameters:

Name Type Description Default
area ClosedArea2D

ClosedArea2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(area)

Calculate Min- and Max Point of an element.

Calculates the MinMax2D box of the ClosedAreaComposite2D.

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

ClosedAreaComposite2D to be calculated

required

Returns:

Type Description
MinMax2D

tuple(MinMax2D,

eServiceResult

NO_ERR)

CalcMinMax(point)

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

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

Parameters:

Name Type Description Default
point Point3D

Point3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(line)

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

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

Parameters:

Name Type Description Default
line Line3D

Line3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR)

CalcMinMax(polyline)

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

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

Parameters:

Name Type Description Default
polyline Polyline3D

Polyline3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(pointCloud)

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

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

Parameters:

Name Type Description Default
pointCloud object

PointCloud3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYLINE)

CalcMinMax(polygon)

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

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

Parameters:

Name Type Description Default
polygon Polygon3D

Polygon3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(arc)

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

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

Parameters:

Name Type Description Default
arc Arc3D

Arc3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(polyhedron)

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

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

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYGON)

CalcMinMax(cuboid)

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

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

Parameters:

Name Type Description Default
cuboid Cuboid3D

Cuboid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CUBOID)

CalcMinMax(cylinder)

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

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

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CYLINDER)

CalcMinMax(cone)

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

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

Parameters:

Name Type Description Default
cone Cone3D

Cone3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_CONE)

CalcMinMax(ellipsoid)

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

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

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_ELLIPSOID)

CalcMinMax(area)

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

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

Parameters:

Name Type Description Default
area PolygonalArea3D

PolygonalArea3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(solid)

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

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

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

ExtrudedAreaSolid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(solid)

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

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

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

ClippedSweptSolid3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_POLYHEDRON)

CalcMinMax(geo)

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

Calculates the MinMax3D volume for the Path3D element.

Parameters:

Name Type Description Default
geo Path3D

Path3D to be calculated

required

Returns:

Type Description
MinMax3D

tuple(MinMax3D,

eServiceResult

NO_ERR, INVALID_SURFACE)

CalcMinMax(geo)

Calculate 3D minmax of the B-rep body

Parameters:

Name Type Description Default
geo BRep3D

BRep3D geometry

required

Returns:

Type Description
MinMax3D

tuple(calculated MinMax3D,

eServiceResult

result code)

CalcProjectedMinMax(geo, matrix)

Calculate minmax of brep in given projection

Parameters:

Name Type Description Default
geo BRep3D

BRep3D to calculate minmax for

required
matrix Matrix3D

projection minmax

required

Returns:

Type Description
MinMax3D

tuple(minmax 3D,

eServiceResult

NO_ERR if successful)

CalcSurface(elem)

Calculate surface of BRep3D

Parameters:

Name Type Description Default
elem BRep3D

input BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

result surface

CalcVolume(elem)

Calculate volume of BRep3D

Parameters:

Name Type Description Default
elem BRep3D

input BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

result volume

CalculateNormal(brep, inputPnt)

Calculate normal vector of BRep at point

Parameters:

Name Type Description Default
brep BRep3D

BRep

required
inputPnt Point3D

input point

required

Returns:

Type Description
Vector3D

normal vector

CalculateSplineLengthToPoint(spline, splinePointIndex)

Calculate spline length from spline start to defined spline point.

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

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

Parameters:

Name Type Description Default
spline Spline2D

2D Spline

required
splinePointIndex int

Spline point index

required

Returns:

Type Description
float

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

Clipping(el1, el2)

test 2D line and minmax box for clipping

Parameters:

Name Type Description Default
el1 Line2D

2D line

required
el2 MinMax2D

2D minmax

required

Returns:

Type Description
eBoolOpResult

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

Colliding overload

Colliding(polygon1, polygon2)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
polygon1 Polygon2D

the first polygon

required
polygon2 Polygon2D

the second polygon

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(polygon, line)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
polygon Polygon2D

polygon

required
line Line2D

line

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(minMax, polygon)

Test for collision between 2 geometry objects

Parameters:

Name Type Description Default
minMax MinMax2D

MinMax

required
polygon Polygon2D

polygon

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Colliding(brep1, brep2)

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

Parameters:

Name Type Description Default
brep1 BRep3D

1-st brep element

required
brep2 BRep3D

2-nd brep element

required

Returns:

Type Description
bool

true when colliding, otherwise false.

Convert3DRotation(axis, angle)

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

Parameters:

Name Type Description Default
axis Axis3D

3D axis

required
angle Angle

Angle of 3D rotation

required

Returns:

Type Description
tuple

The first scale in X axis,

tuple

The first scale in Y axis,

tuple

The angle of the first 2D rotation,

tuple

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

tuple

The angle of the second 2D rotation

ConvertTo2D overload

ConvertTo2D(line3D)

Converts Line3D to Line2D

Parameters:

Name Type Description Default
line3D Line3D

Line3D to convert

required

Returns:

Type Description
bool

tuple(line2D is valid: true/false,

Line2D

Converted Line3D)

ConvertTo2D(polyline3D)

Converts Polyline3D to Polyline2D

Parameters:

Name Type Description Default
polyline3D Polyline3D

Polyline3D to convert

required

Returns:

Type Description
bool

tuple(polyline2D is valid: true/false,

Polyline2D

Converted Polyline3D)

ConvertTo2D(axis3D)

Converts Axis3D to Axis2D

Parameters:

Name Type Description Default
axis3D Axis3D

Axis3D to convert

required

Returns:

Type Description
bool

tuple(axis2D is valid: true/false,

Axis2D

Converted Axis3D)

ConvertTo2D(point3D)

Converts Point3D to Point2D

Parameters:

Name Type Description Default
point3D Point3D

Point3D to convert

required

Returns:

Type Description
bool

tuple(point3D is valid: true/false,

Point2D

Converted Point3D)

ConvertTo2D(polygon3D)

Converts Polygon3D to Polygon2D

Parameters:

Name Type Description Default
polygon3D Polygon3D

Polygon3D to convert

required

Returns:

Type Description
bool

tuple(polygon3D is valid: true/false,

Polygon2D

Converted Polygon3D)

ConvertTo2D(arc3D)

Converts Arc3D to Arc2D

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

Parameters:

Name Type Description Default
arc3D Arc3D

Arc3D to convert

required

Returns:

Type Description
bool

tuple(Arc3D is valid: true/false,

Arc2D

Converted Arc3D)

ConvertTo2D(spline3D)

Converts Spline3D to Spline2D

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

Parameters:

Name Type Description Default
spline3D Spline3D

Spline3D to convert

required

Returns:

Type Description
bool

tuple(Spline3D is valid: true/false,

Spline2D

Converted Spline3D)

ConvertTo2D(bspline3D)

Converts BSpline3D to BSpline2D

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

Parameters:

Name Type Description Default
bspline3D BSpline3D

BSpline3D to convert

required

Returns:

Type Description
bool

tuple(BSpline3D is valid: true/false,

BSpline2D

Converted BSpline3D)

ConvertTo2D(points3D)

Converts vector of Point3D to vector of Point2D

Parameters:

Name Type Description Default
points3D Point3DList

points to convert

required

Returns:

Type Description
bool

tuple(if success true,

list[Point2D]

Vector of converted points)

ConvertTo2D(path3D)

Converts Path3D to Path2D

Parameters:

Name Type Description Default
path3D Path3D

source path 2D

required

Returns:

Type Description
bool

tuple(if success true,

Path2D

resulting path 3D)

ConvertTo2D(geo_object)

Converts geometry to 2D geometry

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

Parameters:

Name Type Description Default
geo_object object

geometry to convert

required

Returns:

Type Description
object

nullptr if conversion is not possible, otherwise converted geometry

ConvertTo3D overload

ConvertTo3D(line2D, zPlane=0)

Converts Line2D to Line3D

Parameters:

Name Type Description Default
line2D Line2D

Line2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(line3D is valid: true/false,

Line3D

Converted Line3D)

ConvertTo3D(polyline2D, zPlane=0)

Converts Polyline2D to Polyline3D

Parameters:

Name Type Description Default
polyline2D Polyline2D

Polyline2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(polyline3D is valid: true/false,

Polyline3D

Converted Polyline2D)

ConvertTo3D(axis2D, zPlane=0)

Converts Axis2D to Axis3D

Parameters:

Name Type Description Default
axis2D Axis2D

Axis2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(axis3D is valid: true/false,

Axis3D

Converted Axis3D)

ConvertTo3D(spline2D, zPlane=0)

Create an elevated 3D spline from a 2D spline

Parameters:

Name Type Description Default
spline2D Spline2D

Spline to convert

required
zPlane float

Z plane for the spline

0

Returns:

Type Description
bool

tuple(spline3D is valid: true/false,

Spline3D

Converted spline3D)

ConvertTo3D(arc2D, zPlane=0)

Converts Arc2D to Arc3D

Parameters:

Name Type Description Default
arc2D Arc2D

Arc2D to convert

required
zPlane float

Z value

0

Returns:

Type Description
bool

tuple(arc3D is valid: true/false,

Arc3D

Converted Arc2D)

ConvertTo3D(bspline2D, zPlane=0)

Create an elevated 3D bspline from a 2D bspline

Parameters:

Name Type Description Default
bspline2D BSpline2D

BSpline2D to convert

required
zPlane float

Z plane for the spline

0

Returns:

Type Description
bool

tuple(BSpline3D is valid: true/false,

BSpline3D

Converted BSpline3D)

ConvertTo3D(path2D, zPlane=0)

Convert Path2D to Path3D

Parameters:

Name Type Description Default
path2D Path2D

Path2D to convert

required
zPlane float

Z plane for the curve

0

Returns:

Type Description
bool

tuple(bool (true = success),

Path3D

converted Path3D)

ConvertTo3D(points2D, zPlane=0)

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

Parameters:

Name Type Description Default
points2D Point2DList

vector of 2D points

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

list[Point3D]

vector of converted 3D points)

ConvertTo3D(polygon, zPlane=0)

Convert 2D polygon to a 3D polygon

Parameters:

Name Type Description Default
polygon Polygon2D

2D polygon

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

Polygon3D

3D polygon)

ConvertTo3D(clothoid2D, zPlane=0)

Convert 2D clothoid to a 3D bspline

Parameters:

Name Type Description Default
clothoid2D Clothoid2D

2D clothoid

required
zPlane float

Z coordinate to be set by conversion

0

Returns:

Type Description
bool

tuple(true if success,

BSpline3D

3D bspline)

ConvertToBSpline2D overload

ConvertToBSpline2D(arc3D)

Converts Arc3D to BSpline2D

Parameters:

Name Type Description Default
arc3D Arc3D

Arc3D to convert

required

Returns:

Type Description
bool

tuple(bspline2D is valid: true/false,

BSpline2D

Converted BSpline2D)

ConvertToBSpline2D(spline3D)

Converts Spline3D to BSpline2D

Parameters:

Name Type Description Default
spline3D Spline3D

Spline3D to convert

required

Returns:

Type Description
bool

tuple(bspline2D is valid: true/false,

BSpline2D

Converted BSpline2D)

CreateBRep3D overload

CreateBRep3D(polyhedron)

Create BRep3D by converting a polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

polyhedron to convert

required

Returns:

Type Description
tuple

error code,

tuple

BRep3D to create

CreateBRep3D(brep, faceindex)

Create brep from brep face

Parameters:

Name Type Description Default
brep BRep3D

brep to copy face from

required
faceindex int

face index

required

Returns:

Type Description
tuple

error code,

tuple

result brep

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

) -> tuple : Create a frustum of pyramid

Parameters:

Name Type Description Default
length float

Length of the bottom

required
width float

Width of the bottom

required
height float

Height of the bottom

required
offset float

Offset of the top

required
bottomPlane Plane3D

Bottom plane

required

Returns:

Type Description
tuple

Error code

tuple

Polyhedron

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

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

Parameters:

Name Type Description Default
outerProfiles_object list

outer profiles to loft

required
innerProfiles_object list

inner profiles to loft (represents hole in outer profile)

required
closecaps bool

close brep if possible (all profiles are closed)

required
createprofileedges bool

create profile edges and more surfaces or just create one surface

required
linear bool

linear or cubic interpolation

required
periodic bool

if the start profile is also to be the end profile

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

CreatePatchBRep3D(curves_object)

Create breps as patch from given closed 3D-curves

Parameters:

Name Type Description Default
curves_object list

vector of 3D-curves

required

Returns:

Type Description
eCreatePatchResult

tuple(Result of patch creation,

BRep3DList

created BReps)

CreatePlanarBRep3D overload

CreatePlanarBRep3D(profiles_object)

Create brep as planar surface

Parameters:

Name Type Description Default
profiles_object list

border of planar surface ( must be closed )

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

resulting BRep3D ( one planar face ))

CreatePlanarBRep3D(icurve_object)

Create brep as planar surface

Parameters:

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

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D
  • resulting BRep3D ( one planar face ))

CreatePlanarSurface(geometries_object)

create planar brep

Parameters:

Name Type Description Default
geometries_object list

input geometries pointers

required

Returns:

Type Description
ePlanarSurfaceError

tuple(surface error code,

BRep3DList

planar surfaces)

CreatePolygon3D overload

CreatePolygon3D(polyhedron, faceIndex)

Creates a Polygon3D element from a Polyhedron face

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron to get face from

required
faceIndex int

Index of the face in polyhedron

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Created polygon

CreatePolygon3D(polygon2D, plane)

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

Parameters:

Name Type Description Default
polygon2D Polygon2D

2D polygon

required
plane Plane3D

plane to project 2D polygon to

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polygon

CreatePolygon3D(polyline)

Creates a Polygon3D from Polyline3D

Parameters:

Name Type Description Default
polyline Polyline3D

3D polygline

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polygon

CreatePolygon3DFromIndex(arg2, arg3, arg4)

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

CreatePolyhedron overload

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

Create and initialize new Polyhedron3D

Parameters:

Name Type Description Default
polyhedronType PolyhedronType

Polyhedron type - edges, faces or volume.

required
verticesCount int

Count of expected vertices.

required
edgeCount int

Count of expected edges.

required
faceCount int

Count of expected faces.

required
negativeOrientation bool

True for negative orientation.

required

Returns:

Type Description
tuple

Error code,

tuple

pointer to 3D Polyhedron which will be created

CreatePolyhedron(solid)

Create polyhedron from input parametric solid

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

clipped swept solid

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(solid)

Create polyhedron from input parametric solid

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

extruded area solid

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(cylinder, countOfSegments)

Create polyhedron from input Cylinder

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder to convert

required
countOfSegments int

Count of segments

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(igeo, options)

Create polyhedron from arbitrary solid

Parameters:

Name Type Description Default
geoObject

Geometry object

required
options ApproximationSettings

ApproximationSettings structure holding options for approximation

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(brep, options)

Create polyhedron as approximation of arbitrary BRep3D

Parameters:

Name Type Description Default
brep BRep3D

arbitrary BRep3D

required
options ApproximationSettings

approximation settings

required

Returns:

Type Description
tuple

Error code,

tuple

polyhedron to create

CreatePolyhedron(polygon)

Create polyhedron from Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

Reference to Polygon3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(line)

Create polyhedron from Line3D

Parameters:

Name Type Description Default
line Line3D

Reference to Line3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(lines)

Create polyhedron from vector of 3D lines

Parameters:

Name Type Description Default
lines Line3DList

vector of lines

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(polyline)

Create polyhedron from Polyline3D

Parameters:

Name Type Description Default
polyline Polyline3D

Reference to Polyline3D

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(base, path)

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
base Polygon3D

base polygon

required
path Polyline3D

translation path

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(base, refPoint, path)

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
base Polygon2D

base polygon 2D

required
refPoint Point2D

reference point used for transformation

required
path Polyline3D

translation path

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CreatePolyhedron(polygon, bottomPlane, topPlane)

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

Parameters:

Name Type Description Default
polygon Polygon2D

polygon 2D

required
bottomPlane Plane3D

the bottom plane

required
topPlane Plane3D

the top plane

required

Returns:

Type Description
tuple

error code,

tuple

Polyhedron which will be created

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

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

Parameters:

Name Type Description Default
baseOutline Polygon2D

base outline polygon 2D (rectangle of 4 points)

required
leftOffset float

offset from base outline on the left side

required
rightOffset float

offset from base outline on the right side

required
frontOffset float

offset from base outline on the front side

required
backOffset float

offset from base outline on the back side

required
bottomPlane Plane3D

element's bottom plane

required
topPlane Plane3D

element's top plane

required

Returns:

Type Description
tuple

Error code,

tuple

polyhedron which will be created

CreatePolyhedron(startPolygon, endPolygon)

Create a polyhedron from a 3D start and end polygon

Parameters:

Name Type Description Default
startPolygon Polygon3D

Start polygon

required
endPolygon Polygon3D

End polygon

required

Returns:

Type Description
tuple

Error code

tuple

Polyhedron

CreatePolyline3D overload

CreatePolyline3D(polyhedron)

Creates a Polyline3D element from a Polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron to create line from

required

Returns:

Type Description
tuple

eOK if converted successful, else eError,

tuple

Created Polyline

CreatePolyline3D(polyline2D)

Create Polyline3D from Polyline2D

Parameters:

Name Type Description Default
polyline2D Polyline2D

Reference to Polyline2D

required

Returns:

Type Description
tuple

eOK if created successful, else eError,

tuple

Reference to empty Polyline3D

CreatePolyline3D(polygon)

Creates a Polyline3D from Polygon3D

Parameters:

Name Type Description Default
polygon Polygon3D

3D polygon

required

Returns:

Type Description
tuple

eOK if successful, else eError,

tuple

Output 3D polyline

CreatePolyline3DFromIndex(startPol, endPol, index, count)

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

Returns:

Type Description
Polyline3D

eOK if converted successful, else eError,

Polyline3D

Created Polyline

CreateRailSweptBRep3D overload

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

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

Parameters:

Name Type Description Default
profiles_object list

profiles to sweep

required
rails_object list

rails to control sweeping

required
closecaps bool

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

required
uniformScaling bool

use uniform scaling for profiles along the rails

required
railrotation bool

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

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D (1 swept face))

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

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

Parameters:

Name Type Description Default
profiles_object list

profiles to sweep

required
rails_object list

rails to control sweeping

required
path_object object

user defined path

required
closecaps bool

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

required
uniformScaling bool

use uniform scaling for profiles along the rails

required
railrotation bool

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

required
proportionalVertexMatch bool

Flag whether to use proportional vertex matching

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D (1 swept face),

Path3D

path for body creation)

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

Create brep as revolved body.

Parameters:

Name Type Description Default
profiles_object list

vector of profile curves

required
axis Axis3D

axis of rotation

required
rotationAngle Angle

angle of rotation

required
closecaps bool

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

required
numprofiles int

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

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

created brep)

CreateSweptBRep3D overload

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

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

Parameters:

Name Type Description Default
profiles_object list

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

required
path_object object

path to extrude along

required
closecaps bool

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

required
railrotation SweepRotationType

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None
numprofiles int

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

0

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

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

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

Parameters:

Name Type Description Default
profiles_object list

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

required
path_object object

path to extrude along

required
closecaps bool

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

required
railrotation bool

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None
numprofiles int

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

0

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

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

Create BRep3D by means of a profile extrusion along a path

Parameters:

Name Type Description Default
profile_object object

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

required
path_object object

path to extrude along

required
railrotation bool

if true, rotate profile along the path

required
rotAxis Optional[Vector3D]

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

None

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

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

Create translation polyhedron from base polygon and path

Parameters:

Name Type Description Default
profiles Polyline3DList

profiles to sweep

required
path Polyline3D

translation path

required
closecaps bool

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

required
railrotation bool

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

required
rotAxis Vector3D

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

required

Returns:

Type Description
tuple

Error code,

tuple

Polyhedron3D which will be created

CutBrepWithPlane(original, plane)

Cut Brep with plane - create two independent BReps

Parameters:

Name Type Description Default
original BRep3D

original brep

required
plane Plane3D

cutting plane

required

Returns:

Type Description
bool

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

BRep3D

result brep above the plane,

BRep3D

result brep below the plane)

CutPolyhedronWithPlane(original, plane)

Cut polyhedron with plane - create two independent polyhedra

Parameters:

Name Type Description Default
original Polyhedron3D

original polyhedron

required
plane Plane3D

cutting plane

required

Returns:

Type Description
bool

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

Polyhedron3D

result polyhedron above the plane,

Polyhedron3D

result polyhedron below the plane)

DeletePolyhedronLastFace(polyhedron)

Delete the last face of given polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

Polyhedron3D

required

Returns:

Type Description
object

Error code

FindMinDistancePoint overload

FindMinDistancePoint(point, bspline)

Find minimal distance point between Point3D and BSpline3D

Parameters:

Name Type Description Default
point Point3D

Point3D

required
bspline BSpline3D

BSpline3D

required

Returns:

Type Description
tuple

error code,

tuple

point on bspline with minimal distance

FindMinDistancePoint(point, brep)

Find minimal distance point between Point3D and BSpline3D

Parameters:

Name Type Description Default
point Point3D

Point3D

required
brep BRep3D

BRep3D

required

Returns:

Type Description
tuple

error code,

tuple

point on brep with minimal distance

GetAbsoluteTolerance()

get absolute tolerance

Returns:

Type Description
float

absolute tolerance

GetAllIntersections(geoObject1, geoObject2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

GetAngleTolerance()

Get angle tolerance

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

Returns:

Type Description
Angle

Tolerance using for angle comparison [rad]

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

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

Parameters:

Name Type Description Default
geometrie1 object

First object

required
geometrie2 object

Second object

required
inputPoint Point3D

Reference Point / Cursor point

required
eps float

Tolerance

required
bOnlyInsidePoints bool

Return point must be on both objects

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

intersection point

GetCurvatureTolerance()

Get curvature tolerance

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

Returns:

Type Description
float

Tolerance using for curvature comparison

GetCurveLengthTolerance()

Get tolerance for curve length comparison

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

Returns:

Type Description
float

Tolerance using for length of curve comparison [mm]

GetIntersectionPoints(geoObject1, geoObject2, eps)

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

Parameters:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance (optional)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector of intersection points and additional information

GetRelativeTolerance()

get relative tolerance

Returns:

Type Description
float

relative tolerance

GetRotationMatrix overload

GetRotationMatrix(zeroPoint, angle)

Creates 2D rotation matrix

Parameters:

Name Type Description Default
zeroPoint Point2D

Rotation point

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix2D

2D rotation matrix

GetRotationMatrix(axis, angle)

Creates 3D rotation matrix

Parameters:

Name Type Description Default
axis Axis3D

Rotation axis

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix3D

3D rotation Matrix

GetRotationMatrix(line, angle)

Creates 3D rotation matrix

Parameters:

Name Type Description Default
line Line3D

Rotation line, extended to axis

required
angle Angle

Rotation angle

required

Returns:

Type Description
Matrix3D

3D rotation Matrix

GroundViewHiddenCalculation overload

GroundViewHiddenCalculation(brep)

Hidden calculation with ground view of BRep

Parameters:

Name Type Description Default
brep BRep3D

BRep

required

Returns:

Type Description
eGeometryErrorCode

tuple(Error code,

list[Any]

Vector of visible edges,

list[Any]

Vector of hidden edges)

GroundViewHiddenCalculation(poly)

Hidden calculation with ground view of polyhedron.

Parameters:

Name Type Description Default
poly Polyhedron3D

polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(Error code,

list[Line3D]

Vector of visible edges,

list[Line3D]

Vector of hidden edges)

ImprintProfileOnFaces(brep, targetFaces, profile_object)

Imprint edges on brep

Parameters:

Name Type Description Default
brep BRep3D

Brep

required
targetFaces [list[int] | VecUIntList]

faces where to imprint edges

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

imprinted profile

required

Returns:

Type Description
eGeometryErrorCode

tuple(eOK if successful otherwise eError,

BRep3D

Brep

[list[int] | VecUIntList]

new faces after imprint)

Intersect overload

Intersect(bodies1_list, bodies2_list)

compute intersection of set of bodies

Parameters:

Name Type Description Default
bodies1_list PolyhedronTypesList

list of bodies

required
bodies2_list PolyhedronTypesList

list of bodies

required

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Polyhedron3D

resulted polyhedron)

Intersect(el1, el2)

calculate intersection between 2 3D planes

Parameters:

Name Type Description Default
el1 Plane3D

the first plane

required
el2 Plane3D

the second plane

required

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Axis3D

common axis of planes)

Intersect(el1, el2)

compute intersection of 2 3D polyhedron

Parameters:

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

Returns:

Type Description
bool

tuple(true when intersecting, otherwise false.,

Polyhedron3D

resulted polyhedron)

Intersect(brep1, brep2)

Compute intersection of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(true when intersecting, otherwise false.,

BRep3D

result brep of intersection)

Intersect(brep, polyhedron)

Compute intersection of 2 bodies

Parameters:

Name Type Description Default
brep BRep3D

first element - BRep3D

required
polyhedron Polyhedron3D

second element - Polyhedron3D

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result BRep3D)

IntersectRayBRep(rayPoint, rayVector, brep, bNegativPrefered)

Intersection of Ray and BRep

Parameters:

Name Type Description Default
rayPoint Point3D

ray Point

required
rayVector Vector3D

direction vector of ray

required
brep BRep3D

BRep

required
bNegativPrefered bool

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

required

Returns:

Type Description
int

tuple(0 if no error occurs,

IntersectionRayBRep

structure with result of intersection)

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

Intersection of Ray and Polyhedron

Parameters:

Name Type Description Default
rayPoint Point3D

ray Point

required
rayVector Vector3D

direction vector of ray

required
polyhedron Polyhedron3D

polyhedron

required
flag IntersectRayPolyhedronFlag

flag for determining the "best" intersection

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

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

None

Returns:

Type Description
int

tuple(0 if no error occured,

IntersectionRayPolyhedron

structure with result of intersection)

Intersecting overload

Intersecting(el1, el2)

test 2 2D minmaxes for intersection

Parameters:

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

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2, tol)

test 2 2D lines for intersection

Parameters:

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

tolerance

required

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2, tol)

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

Parameters:

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

tolerance

required

Returns:

Type Description
bool

true when intersecting, otherwise false.

Intersecting(el1, el2)

test 2 breps for intersection

Parameters:

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

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test brep and polyhedron for intersection

Parameters:

Name Type Description Default
el1 BRep3D

brep to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D arc and polyhedron for intersection

Parameters:

Name Type Description Default
el1 Arc3D

arc to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D arc and brep for intersection

Parameters:

Name Type Description Default
el1 Arc3D

arc to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D spline and polyhedron for intersection

Parameters:

Name Type Description Default
el1 Spline3D

spline to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D spline and brep for intersection

Parameters:

Name Type Description Default
el1 Spline3D

spline to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D bspline and polyhedron for intersection

Parameters:

Name Type Description Default
el1 BSpline3D

bspline to check

required
el2 Polyhedron3D

polyhedron to check

required

Returns:

Type Description
bool

bool true when intersecting

Intersecting(el1, el2)

test 3D bspline and brep for intersection

Parameters:

Name Type Description Default
el1 BSpline3D

bspline to check

required
el2 BRep3D

brep to check

required

Returns:

Type Description
bool

bool true when intersecting

IntersectingRel overload

IntersectingRel(el1, el2)

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

Parameters:

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

Returns:

Type Description
bool

true when intersecting, otherwise false.

IntersectingRel(el1, el2)

test 2 2D lines for intersection

Parameters:

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

Returns:

Type Description
bool

true when intersecting, otherwise false.

IntersectionCalculus overload

IntersectionCalculus(el1, el2)

compute intersection of 2 2D axis

Parameters:

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

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(axis, line)

compute intersection between 2D axis and 2D line

Parameters:

Name Type Description Default
axis Axis2D

2D Axis

required
line Line2D

2D line

required

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(axis2D, axis3D)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
axis3D Axis3D

3D Axis

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis2D, arc2D, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, polygon)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis2D, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis1, axis2)

Calculate the intersection between two 3D axis

Parameters:

Name Type Description Default
axis1 Axis3D

First 3D Axis

required
axis2 Axis3D

Second 3D Axis

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, line)

Calculate the intersection between 3D axis and 2D line

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
line Line2D

2D line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, arc, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, polygon)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
spline BSpline3D

3D B-Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(axis, plane, eps)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
plane Plane3D

3D Plane

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line, plane, eps)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
plane Plane3D

3D Plane

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(axis, arc, eps)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
arc Arc3D

3D Arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection points

IntersectionCalculus(line, arc, eps)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
arc Arc3D

3D Arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection points

IntersectionCalculus(el1, el2)

compute intersection of 2 2D line

Parameters:

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

Returns:

Type Description
tuple

true when intersecting, otherwise false.,

tuple

result intersection point if possible

IntersectionCalculus(line2D, line3D)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
line3D Line3D

3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line2D, arc2D, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line2D, polygon)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line2D

2D Line

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line1, line2)

Calculate the intersection between two 3D line

Parameters:

Name Type Description Default
line1 Line3D

First 3D Line

required
line2 Line3D

Second 3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculus(line, arc, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, polygon)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(line, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
bspline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc1, arc2)

Calculate the intersection between two arcs

Parameters:

Name Type Description Default
arc1 Arc2D

2D Arc

required
arc2 Arc2D

2D Arc

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, polyline, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, arc2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

First 3D Arc

required
arc2 Arc3D

Second 3D Arc

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(arc, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
bspline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline1, polyline2)

Calculate the intersection between two polylines

Parameters:

Name Type Description Default
polyline1 Polyline2D

2D polyline

required
polyline2 Polyline2D

2D polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, polygon)

Calculate the intersection between polyline and polygon

Parameters:

Name Type Description Default
polyline Polyline2D

2D polyline

required
polygon Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polygon1, polygon2)

Calculate the intersection between two polygons

Parameters:

Name Type Description Default
polygon1 Polygon2D

2D polygon

required
polygon2 Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

First 2D polyline

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

2D Polyline

required
spline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline3D

3D Polyline

required
spline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(polygon, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polygon Polygon2D

First 2D polygon

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, line, eps)

Calculate the intersection between 3D plane and 3D line

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
line Line3D

3D line

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, line, eps)

Calculate the intersection between 3D plane and 3D polyline

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
line Polyline3D

3D polyline

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, arc, eps)

Calculate the intersection between 3D plane and 3D arc

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
arc Arc3D

3D arc

required
eps float

Tolerance

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(plane, spline, eps, maxSolutions)

Calculate the intersection between 3D plane and 3D arc

Parameters:

Name Type Description Default
plane Plane3D

3D plane

required
spline Spline3D

3D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

Calculate the intersection between two 2D splines

Parameters:

Name Type Description Default
spline1 Spline2D

First 2D spline

required
spline2 Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

Calculate the intersection between 2D spline and 3D spline

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

Parameters:

Name Type Description Default
spline1 Spline2D

First 2D spline

required
spline2 Spline3D

Second 3D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline3D

3D Spline

required
spline2 Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline2D

2D Spline

required
spline2 BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 Spline3D

3D Spline

required
spline2 BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 BSpline2D

2D BSpline

required
spline2 BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(spline1, spline2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
spline1 BSpline3D

3D BSpline

required
spline2 BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculus(ele1, ele2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
ele1 object

First element

required
ele2 object

Second element

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx overload

IntersectionCalculusEx(axis2D, arc2D, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis2D, polygon)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis2D, clothoid2D, eps, maxSolutions)

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

Parameters:

Name Type Description Default
axis2D Axis2D

2D axis

required
clothoid2D Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis, arc, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(axis, polygon)

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

Parameters:

Name Type Description Default
axis Axis3D

3D Axis

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line1, line2)

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

Parameters:

Name Type Description Default
line1 Line2D

First 2D Line

required
line2 Line2D

Second 2D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line2D, line3D)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
line3D Line3D

3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line2D, arc2D, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
clothoid2D Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, polyline)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, polygon)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, spline, eps, maxSolutions)

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

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line2D, bspline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line2D Line2D

2D Line

required
bspline BSpline2D

2D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line1, line2)

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

Parameters:

Name Type Description Default
line1 Line3D

First 3D Line

required
line2 Line3D

Second 3D Line

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Resulting intersection point

IntersectionCalculusEx(line, arc, eps)

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
arc Arc3D

3D Arc

required
eps float

precision

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, clothoid, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
clothoid Clothoid2D

2D Clothoid

required
eps float

Tolerance

required
maxSolutions int

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

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, polyline)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polyline Polyline2D

2D Polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, polygon)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
polygon Polygon2D

2D Polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(line, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
line Line3D

3D Line

required
spline BSpline3D

3D BSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc1, arc2)

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

Parameters:

Name Type Description Default
arc1 Arc2D

2D Arc

required
arc2 Arc2D

2D Arc

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, clothoid, eps, maxSolutions)

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

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

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

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

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

emarks There are known precision issues with the background function lksplk

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

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

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

emarks There are known precision issues with the background function lksplk

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

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

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline2D

2D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

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

Parameters:

Name Type Description Default
arc Arc2D

2D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc1, arc2, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc1 Arc3D

3D Arc

required
arc2 Arc3D

3D Arc

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline Spline3D

3D Spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(arc, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
arc Arc3D

3D Arc

required
spline BSpline3D

3D bSpline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(clothoid, polyline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
polyline Polyline2D

2D polyline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(clothoid, polygon, eps, maxSolutions)

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

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
polygon Polygon2D

2D polygon

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polyline1, polyline2)

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

Parameters:

Name Type Description Default
polyline1 Polyline2D

2D polyline

required
polyline2 Polyline2D

2D polyline

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polygon1, polygon2)

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

Parameters:

Name Type Description Default
polygon1 Polygon2D

2D polygon

required
polygon2 Polygon2D

2D polygon

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polyline, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polyline Polyline2D

First 2D polyline

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IntersectionCalculusEx(polygon, spline, eps, maxSolutions)

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

Parameters:

Name Type Description Default
polygon Polygon2D

First 2D polygon

required
spline Spline2D

Second 2D spline

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

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

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

Parameters:

Name Type Description Default
geoObject1 object

First object

required
geoObject2 object

Second object

required
eps float

Tolerance

required
maxSolutions int

Maximum number of solution (especially for splines and clothoids)

required
bOnlyInsidePoints bool

Intersection points must be on both objects

required

Returns:

Type Description
tuple

true, if an intersection was found, otherwise false,

tuple

Vector which includes all resulting intersection points

IsCoplanar overload

IsCoplanar(geoVector_object)

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

Parameters:

Name Type Description Default
geoVector_object list

vector of object geometries

required

Returns:

Type Description
bool

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

Plane3D

result plane - if collinear plane is not valid)

IsCoplanar(igeo1_object, igeo2_object)

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

Parameters:

Name Type Description Default
igeo1_object object

first object geometry

required
igeo2_object object

second object geometry

required

Returns:

Type Description
bool

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

Plane3D

result plane,

bool

flag if lines are parallel)

IsCoplanar(plane, geo_object)

Find out if plane and geometry are coplanar

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
geo_object object

objects geometry

required

Returns:

Type Description
bool

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

IsCoplanar(plane, point)

Find out if point lies on plane

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
point Point3D

Point3D

required

Returns:

Type Description
bool

True, if point lies on plane otherwise return false.

IsCoplanar(plane, line)

Find out if line lies on plane

Parameters:

Name Type Description Default
plane Plane3D

Plane3D

required
line Line3D

Line3D

required

Returns:

Type Description
bool

True, if line lies on plane otherwise return false.

IsCoplanar(plane1, plane2)

Find out if planes are coplanar

Parameters:

Name Type Description Default
plane1 Plane3D

Plane3D

required
plane2 Plane3D

Plane3D

required

Returns:

Type Description
bool

True, if planes are coplanar otherwise return false.

IsCoplanar(point1, point2, point3, point4)

Find out if four points are coplanar

Parameters:

Name Type Description Default
point1 Point3D

Point3D

required
point2 Point3D

Point3D

required
point3 Point3D

Point3D

required
point4 Point3D

Point3D

required

Returns:

Type Description
bool

True, if points are coplanar otherwise return false.

IsCoplanar(line1, line2)

Find out if two lines are coplanar

Parameters:

Name Type Description Default
line1 Line3D

Line3D

required
line2 Line3D

Line3D

required

Returns:

Type Description
bool

True, if lines are coplanar otherwise return false.

IsCoplanar(line1, line2)

Check if lines are coplanar and calculate plane

Parameters:

Name Type Description Default
line1 Line3D

Line3D

required
line2 Line3D

Line3D]

required

Returns:

Type Description
bool

tuple(True, if lines are coplanar.,

Plane3D

result plane)

MakeBoolean overload

MakeBoolean(el1, el2)

make boolean operation between line and polygon

Parameters:

Name Type Description Default
el1 Line2D

Line2D

required
el2 Polygon2D

Polygon2D

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Line2DList

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

Line2DList

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

MakeBoolean(el1, el2)

make boolean operation between two 2D profile elements

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

Parameters:

Name Type Description Default
el1 Polygon2D

first element geometry

required
el2 Polygon2D

second element geometry

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

output 2D profile of intersection,

Polygon2D

output 2D profile of union,

Polygon2D

output 2D profile of subtraction element1 minus element2,

Polygon2D

output 2D profile of subtraction element2 minus element1)

MakeBoolean(el1, el2)

make boolean operation between two 3D bodies

As input arbitrary element which represents 3D is possible.

Throws exception when element is not suitable for booleans

Parameters:

Name Type Description Default
el1 Polyhedron3D

first element geometry

required
el2 Polyhedron3D

second element geometry

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of intersection,

Polyhedron3D

output 3D body of union,

Polyhedron3D

output 3D body of subtraction element1 minus element2,

Polyhedron3D

output 3D body of subtraction element2 minus element1)

MakeIntersection overload

MakeIntersection(brep1, breps)

Compute intersection of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
breps BRep3DList

second brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(eOK if intersection was successful,

BRep3D

result brep of intersection)

MakeIntersection(brep1, brep2)

Deprecated: use Intersect(...)

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep

required

Returns:

Type Description
tuple

error code, eOK if intersection was successful,

tuple

result brep of intersection

MakeIntersection(brep, polyhedron)

Deprecated: use Intersect(...)

Parameters:

Name Type Description Default
brep BRep3D

first element - BRep3D

required
polyhedron Polyhedron3D

second element - Polyhedron3D

required

Returns:

Type Description
tuple

error code,

tuple

result BRep3D

MakeIntersection(el1, el2)

Deprecated: use Intersect(...)

Parameters:

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

Returns:

Type Description
tuple

error code, eOK if intersection was successful,

tuple

resulted polyhedron

MakeSectionWithSurfaces(brep1, brep2)

Compute section of brep and surface brep

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

section brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3DList

section resulting breps)

MakeSubtraction overload

MakeSubtraction(body_object, voidbodies_list)

make subtraction of 3D bodies from given body

Parameters:

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

input body

required
voidbodies_list PolyhedronTypesList

list of 3D bodies to subtract

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of subtraction)

MakeSubtraction(poly1, poly2)

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

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

output 2D polygon of subtraction,

Polygon2D

output 2D polygon of intersection)

MakeSubtraction(polyhed1, polyhed2)

make subtraction of polyhed1 - polyhed2

Parameters:

Name Type Description Default
polyhed1 Polyhedron3D

first polyhedron

required
polyhed2 Polyhedron3D

second polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

result 3D polyhedron of subtraction)

MakeSubtraction(brep1, brep2)

Compute subtraction of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep to be subtracted from the first brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of subtraction)

MakeSubtraction(brep1, breps)

Compute subtraction of brep and vector of breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
breps BRep3DList

vector of brep to be subtracted from the first brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of subtraction)

MakeSubtraction(poly1, poly2, intersection)

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

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

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required
intersection Polygon2D

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

required

Returns:

Type Description
tuple

GeoErrorCode,

tuple

output 2D polygon of subtraction

MakeUnion overload

MakeUnion(bodies_list, voidbodies_list)

make union of 3D bodies

As input arbitrary elements which represents 3D is possible.

Parameters:

Name Type Description Default
bodies_list PolyhedronTypesList

list of 3D bodies

required
voidbodies_list PolyhedronTypesList

list of 3D bodies to subtract

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

output 3D body of union)

MakeUnion(poly1, poly2)

make union of 2D polygons

Parameters:

Name Type Description Default
poly1 Polygon2D

first polygon

required
poly2 Polygon2D

second polygon

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polygon2D

result 2D polygon of union)

MakeUnion(polyhed1, polyhed2)

make union of 3D polyhedrons

Parameters:

Name Type Description Default
polyhed1 Polyhedron3D

first polyhedron

required
polyhed2 Polyhedron3D

second polyhedron

required

Returns:

Type Description
eGeometryErrorCode

tuple(GeoErrorCode,

Polyhedron3D

result 3D polyhedron of union)

MakeUnion(bodies)

Compute bulk union of more polyhedra at once

Parameters:

Name Type Description Default
bodies Polyhedron3DList

polyhedra to unite

required

Returns:

Type Description
tuple[bool, Polyhedron3D]

if success result polyhedron otherwise nullopt

MakeUnion(brep1, brep2)

Compute union of 2 breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
brep2 BRep3D

second brep

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of union)

MakeUnion(brep1, breps)

Compute union of brep and a list of breps

Parameters:

Name Type Description Default
brep1 BRep3D

first brep

required
breps BRep3DList

list of breps

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of union)

MakeUnion(breps)

Compute union of more breps at once (using paralelism if possible)

Parameters:

Name Type Description Default
breps BRep3DList

breps to unite

required

Returns:

Type Description
eGeometryErrorCode

tuple(error code,

BRep3D

result brep of union)

Mirror overload

Mirror(point, plane)

Mirror point 3D

Parameters:

Name Type Description Default
point Point3D

mirroring point

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Point3D

mirrored point

Mirror(point, axis)

2D Mirror of 3D point

Parameters:

Name Type Description Default
point Point3D

mirroring point

required
axis Axis2D

mirror plane

required

Returns:

Type Description
Point3D

mirrored point

Mirror(vec, plane)

Mirror vector 3D

Parameters:

Name Type Description Default
vec Vector3D

mirroring vector

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Vector3D

mirrored vector

Mirror(vec, axis)

2D mirror of 3D vector

Parameters:

Name Type Description Default
vec Vector3D

mirroring vector

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Vector3D

mirrored vector

Mirror(point, plane)

Mirror point 2D

Parameters:

Name Type Description Default
point Point2D

mirroring point 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Point2D

mirrored point

Mirror(point, axis)

2D Mirror of 3D point

Parameters:

Name Type Description Default
point Point2D

mirroring point 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Point2D

mirrored point

Mirror(vec, plane)

Mirror vector 2D

Parameters:

Name Type Description Default
vec Vector2D

mirroring point

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Vector2D

mirrored vector

Mirror(vec, axis)

2D mirror of 2D vector

Parameters:

Name Type Description Default
vec Vector2D

mirroring vector

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Vector2D

mirrored vector

Mirror(line, plane)

Mirror line 2D

Parameters:

Name Type Description Default
line Line2D

mirroring line 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Line2D

mirrored line

Mirror(line, axis)

Mirror line 2D

Parameters:

Name Type Description Default
line Line2D

mirroring line 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Line2D

mirrored line

Mirror(line, plane)

Mirror line 3D

Parameters:

Name Type Description Default
line Line3D

mirroring line 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Line3D

mirrored line

Mirror(line, axis)

2D mirror of 3D line

Parameters:

Name Type Description Default
line Line3D

mirroring line 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Line3D

mirrored line

Mirror(polyline, plane)

Mirror polyline 2D

Parameters:

Name Type Description Default
polyline Polyline2D

mirroring polyline 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Polyline2D

mirrored polyline

Mirror(polyline, axis)

2D mirror of 2D polyline

Parameters:

Name Type Description Default
polyline Polyline2D

mirroring polyline 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Polyline2D

mirrored polyline

Mirror(polygon, plane)

Mirror polygon 2d

Parameters:

Name Type Description Default
polygon Polygon2D

polygon to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Polygon2D

mirrored polygon

Mirror(polygon, axis)

Mirror polygon 2d

Parameters:

Name Type Description Default
polygon Polygon2D

polygon to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Polygon2D

mirrored polygon

Mirror(plane, axis)

Mirror plane

Parameters:

Name Type Description Default
plane Plane3D

plane to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Plane3D

mirrored polygonal area

Mirror(pla, plane)

Mirror plane

Parameters:

Name Type Description Default
pla Plane3D

plane to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Plane3D

mirrored polygonal area

Mirror(polygon, axis)

Mirror polygonal area 2D

Parameters:

Name Type Description Default
polygon PolygonalArea2D

polygon to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
PolygonalArea2D

mirrored polygonal area

Mirror(polygon, axis)

Mirror polygonal area 2D

Parameters:

Name Type Description Default
polygon PolygonalArea3D

polygon to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
PolygonalArea3D

mirrored polygonal area

Mirror(polygon, plane)

Mirror polygonal area 3D

Parameters:

Name Type Description Default
polygon PolygonalArea3D

polygon to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
PolygonalArea3D

mirrored polygonal area

Mirror(polyline, plane)

Mirror polyline 3D

Parameters:

Name Type Description Default
polyline Polyline3D

mirroring polyline 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Polyline3D

mirrored polyline

Mirror(polyline, axis)

Mirror polyline 3D

Parameters:

Name Type Description Default
polyline Polyline3D

mirroring polyline 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Polyline3D

mirrored polyline

Mirror(polygon, plane)

Mirror polygon 3D

Parameters:

Name Type Description Default
polygon Polygon3D

mirroring polygon 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Polygon3D

mirrored polygon

Mirror(polygon, axis)

Mirror polygon 3D

Parameters:

Name Type Description Default
polygon Polygon3D

mirroring polygon 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Polygon3D

mirrored polygon

Mirror(spline, plane)

Mirror spline 2D

Parameters:

Name Type Description Default
spline Spline2D

mirroring spline 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Spline2D

mirrored spline

Mirror(spline, axis)

Mirror spline 2D

Parameters:

Name Type Description Default
spline Spline2D

mirroring spline 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Spline2D

mirrored spline

Mirror(spline, plane)

Mirror spline 3D

Parameters:

Name Type Description Default
spline Spline3D

mirroring spline 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Spline3D

mirrored spline

Mirror(spline, axis)

Mirror spline 3D

Parameters:

Name Type Description Default
spline Spline3D

mirroring spline 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Spline3D

mirrored spline

Mirror(bSpline, plane)

Mirror BSpline 2D

Parameters:

Name Type Description Default
bSpline BSpline2D

mirroring bSpline 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
BSpline2D

mirrored spline

Mirror(bSpline, axis)

Mirror BSpline 2D

Parameters:

Name Type Description Default
bSpline BSpline2D

mirroring bSpline 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
BSpline2D

mirrored spline

Mirror(bSpline, plane)

Mirror BSpline 3D

Parameters:

Name Type Description Default
bSpline BSpline3D

mirroring bSpline 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
BSpline3D

mirrored spline

Mirror(bSpline, axis)

Mirror BSpline 3D

Parameters:

Name Type Description Default
bSpline BSpline3D

mirroring bSpline 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
BSpline3D

mirrored spline

Mirror(arc, plane)

Mirror arc 2D

Parameters:

Name Type Description Default
arc Arc2D

mirroring arc 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Arc2D

mirrored arc

Mirror(arc, axis)

Mirror arc 2D

Parameters:

Name Type Description Default
arc Arc2D

mirroring arc 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Arc2D

mirrored arc

Mirror(arc, plane)

Mirror arc 3D

Parameters:

Name Type Description Default
arc Arc3D

mirroring arc 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Arc3D

mirrored arc

Mirror(arc, axis)

Mirror arc 3D

Parameters:

Name Type Description Default
arc Arc3D

mirroring arc 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Arc3D

mirrored arc

Mirror(path, plane)

Mirror path 3D

Parameters:

Name Type Description Default
path Path3D

mirroring path 3D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Path3D

mirrored path

Mirror(path, axis)

Mirror path 3D

Parameters:

Name Type Description Default
path Path3D

mirroring path 3D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Path3D

mirrored path

Mirror(path, plane)

Mirror path 2D

Parameters:

Name Type Description Default
path Path2D

mirroring path 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Path2D

mirrored path

Mirror(path, axis)

Mirror path 2D

Parameters:

Name Type Description Default
path Path2D

mirroring path 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Path2D

mirrored path

Mirror(area, plane)

Mirror path bounded area 2D

Parameters:

Name Type Description Default
area ClosedArea2D

mirroring path bounded area 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
ClosedArea2D

mirrored path bounded area

Mirror(area, axis)

Mirror path bounded area 2D

Parameters:

Name Type Description Default
area ClosedArea2D

mirroring path bounded area 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
ClosedArea2D

mirrored path bounded area

Mirror(area, plane)

Mirror path bounded area composite 2D

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

mirroring path bounded area composite 2D

required
plane Plane3D

mirror plane

required

Returns:

Type Description
ClosedAreaComposite2D

mirrored path bounded area composite

Mirror(area, axis)

Mirror path bounded area composite 2D

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

mirroring path bounded area composite 2D

required
axis Axis2D

mirror axis

required

Returns:

Type Description
ClosedAreaComposite2D

mirrored path bounded area composite

Mirror(angle, plane)

Mirror angle

Parameters:

Name Type Description Default
angle Angle

mirroring angle

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Angle

mirrored angle

Mirror(angle, axis)

Mirror angle

Parameters:

Name Type Description Default
angle Angle

mirroring angle

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Angle

mirrored angle

Mirror(polyhedron, plane)

Mirror Polyhedron3D

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

mirroring polyhedron

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Polyhedron3D

mirrored polyhedron

Mirror(polyhedron, axis)

2D mirror of 3D Polyhedron

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

mirroring polyhedron

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Polyhedron3D

mirrored polyhedron

Mirror(solid, axis)

2D Mirror ClippedSweptSolid3D

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

solid to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
ClippedSweptSolid3D

mirrored solid

Mirror(solid, plane)

Mirror ExtrudedAreaSolid3D

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

solid to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
ExtrudedAreaSolid3D

mirrored solid

Mirror(solid, axis)

2D Mirror of ExtrudedAreaSolid3D

Parameters:

Name Type Description Default
solid ExtrudedAreaSolid3D

solid to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
ExtrudedAreaSolid3D

mirrored solid

Mirror(clothoid, plane)

Mirror of Clothoid2D

Parameters:

Name Type Description Default
clothoid Clothoid2D

clothoid to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Clothoid2D

mirrored solid

Mirror(clothoid, axis)

2D Mirror of Clothoid2D

Parameters:

Name Type Description Default
clothoid Clothoid2D

clothoid to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Clothoid2D

mirrored solid

Mirror(placement, axis)

2D Mirror AxisPlacement2D

Parameters:

Name Type Description Default
placement AxisPlacement2D

axis placement to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
AxisPlacement2D

mirrored placement

Mirror(placement, plane)

3D Mirror AxisPlacement2D

Parameters:

Name Type Description Default
placement AxisPlacement2D

axis placement to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
AxisPlacement2D

mirrored placement

Mirror(placement, axis)

2D Mirror AxisPlacement3D

Parameters:

Name Type Description Default
placement AxisPlacement3D

axis placement to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
AxisPlacement3D

mirrored placement

Mirror(placement, plane)

3D Mirror AxisPlacement3D

Parameters:

Name Type Description Default
placement AxisPlacement3D

axis placement to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
AxisPlacement3D

mirrored placement

Mirror(cylinder, plane)

Mirror Cylinder3D

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Cylinder3D

mirrored cylinder

Mirror(cylinder, axis)

Mirror Cylinder3D

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Cylinder3D

mirrored cylinder

Mirror(cone, plane)

Mirror Cone3D

Parameters:

Name Type Description Default
cone Cone3D

Cone to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Cone3D

mirrored Cone

Mirror(cone, axis)

Mirror Cone3D

Parameters:

Name Type Description Default
cone Cone3D

Cone to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Cone3D

mirrored Cone

Mirror(ellipsoid, plane)

Mirror Ellipsoid3D

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid to mirror

required
plane Plane3D

mirror plane

required

Returns:

Type Description
Ellipsoid3D

mirrored Ellipsoid

Mirror(ellipsoid, axis)

Mirror Ellipsoid3D

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid to mirror

required
axis Axis2D

mirror axis

required

Returns:

Type Description
Ellipsoid3D

mirrored Ellipsoid

Mirror(brep, plane)

3D Mirror brep3D

Parameters:

Name Type Description Default
brep BRep3D

brep

required
plane Plane3D

mirror plane

required

Returns:

Type Description
BRep3D

mirrored placement

Move overload

Move(box, translation)

Move bounding box

Parameters:

Name Type Description Default
box BoundingBox2D

Moving bounding box

required
translation Vector2D

Vector of translation

required

Returns:

Type Description
BoundingBox2D

Moved bounding box

Move(area, translation)

Move polygonal area

Parameters:

Name Type Description Default
area PolygonalArea2D

PolygonalArea2D to move

required
translation Vector2D

Vector of translation

required

Returns:

Type Description
PolygonalArea2D

PolygonalArea2D Moved area

Move(plane, translation)

Move plane

Parameters:

Name Type Description Default
plane Plane3D

Plane3D to move

required
translation Vector3D

Vector of translation

required

Returns:

Type Description
Plane3D

Plane3D Moved plane

Move(arc2D, moveVector)

Move Arc2D by given vector

Parameters:

Name Type Description Default
arc2D Arc2D

Arc2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Arc2D

Arc2D Moved arc

Move(arc3D, moveVector)

Move Arc3D by given vector

Parameters:

Name Type Description Default
arc3D Arc3D

Arc3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Arc3D

Arc3D Moved Arc

Move(axis2D, moveVector)

Move Axis2D by given vector

Parameters:

Name Type Description Default
axis2D Axis2D

Axis2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Axis2D

Axis2D Moved Axis

Move(axis3D, moveVector)

Move Axis3D by given vector

Parameters:

Name Type Description Default
axis3D Axis3D

Axis3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Axis3D

Axis3D Moved axis

Move(axisPlacement2D, moveVector)

Move AxisPlacement2D by given vector

Parameters:

Name Type Description Default
axisPlacement2D AxisPlacement2D

AxisPlacement2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
AxisPlacement2D

AxisPlacement2D Moved axis placement

Move(axisPlacement3D, moveVector)

Move AxisPlacement3D by given vector

Parameters:

Name Type Description Default
axisPlacement3D AxisPlacement3D

AxisPlacement3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
AxisPlacement3D

AxisPlacement3D Moved placement

Move(clippedSweptSolid3D, vec)

Move ClippedSweptSolid3D by given vector

Parameters:

Name Type Description Default
clippedSweptSolid3D ClippedSweptSolid3D

ClippedSweptSolid3D to move

required
vec Vector3D

Vector of translation

required

Returns:

Type Description
ClippedSweptSolid3D

ClippedSweptSolid3D Moved solid

Move(clothoid2D, moveVector)

Move Clothoid2D by given vector

Parameters:

Name Type Description Default
clothoid2D Clothoid2D

Clothoid2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Clothoid2D

Clothoid2D Moved clothoid

Move(cuboid3D, moveVector)

Move Cuboid3D by given vector

Parameters:

Name Type Description Default
cuboid3D Cuboid3D

Cuboid3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Cuboid3D

Cuboid3D Moved cuboid

Move(extrudedAreaSolid3D, moveVector)

Move ExtrudedAreaSolid3D by given vector

Parameters:

Name Type Description Default
extrudedAreaSolid3D ExtrudedAreaSolid3D

ExtrudedAreaSolid3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
ExtrudedAreaSolid3D

ExtrudedAreaSolid3D Moved solid

Move(line2D, moveVector)

Move Line2D by given vector

Parameters:

Name Type Description Default
line2D Line2D

Line2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Line2D

Line2D Moved line

Move(line3D, moveVector)

Move Line3D by given vector

Parameters:

Name Type Description Default
line3D Line3D

Line3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Line3D

Line3D Moved line

Move(path2D, moveVector)

Move Path2D by given vector

Parameters:

Name Type Description Default
path2D Path2D

Path2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Path2D

Path2D Moved path

Move(path3D, moveVector)

Move Path3D by given vector

Parameters:

Name Type Description Default
path3D Path3D

Path3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Path3D

Path3D Moved path

Move(point2D, moveVector)

Move Point2D by given vector

Parameters:

Name Type Description Default
point2D Point2D

Point2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Point2D

Point2D Moved point

Move(point3D, moveVector)

Move Point3D by given vector

Parameters:

Name Type Description Default
point3D Point3D

Point3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Point3D

Point3D Moved point

Move(polygon2D, moveVector)

Move Polygon2D by given vector

Parameters:

Name Type Description Default
polygon2D Polygon2D

Polygon2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Polygon2D

Polygon2D Moved polygon

Move(polygon3D, moveVector)

Move Polygon3D by given vector

Parameters:

Name Type Description Default
polygon3D Polygon3D

Polygon3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Polygon3D

Polygon3D Moved polygon

Move(polygonalArea3D, moveVector)

Move PolygonalArea3D by given vector

Parameters:

Name Type Description Default
polygonalArea3D PolygonalArea3D

PolygonalArea3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
PolygonalArea3D

PolygonalArea3D Moved polygonal area

Move(polyhedron3D, moveVector)

Move Polyhedron3D by given vector

Throw exception in case of error

Parameters:

Name Type Description Default
polyhedron3D Polyhedron3D

Polyhedron3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Polyhedron3D

Polyhedron3D Moved polyhedron

Move(polyline2D, moveVector)

Move Polyline2D by given vector

Parameters:

Name Type Description Default
polyline2D Polyline2D

Polyline2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Polyline2D

Polyline2D Moved polyline

Move(polyline3D, moveVector)

Move Polyline3D by given vector

Parameters:

Name Type Description Default
polyline3D Polyline3D

Polyline3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Polyline3D

Polyline3D Moved polyline

Move(area, moveVector)

Move ClosedArea2D by given vector

Parameters:

Name Type Description Default
area ClosedArea2D

ClosedArea2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
ClosedArea2D

ClosedArea2D Moved area

Move(area, moveVector)

Move ClosedAreaComposite2D by given vector

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

ClosedAreaComposite2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
ClosedAreaComposite2D

ClosedAreaComposite2D Moved area composite

Move(cylinder3D, moveVector)

Move Cylinder3D by given vector

Parameters:

Name Type Description Default
cylinder3D Cylinder3D

Cylinder3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Cylinder3D

Cylinder3D Moved Cylinder

Move(ellipsoid3D, moveVector)

Move Ellipsoid3D by given vector

Parameters:

Name Type Description Default
ellipsoid3D Ellipsoid3D

Ellipsoid3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Ellipsoid3D

Ellipsoid3D Moved Ellipsoid3D

Move(cone3D, moveVector)

Move Cone3D by given vector

Parameters:

Name Type Description Default
cone3D Cone3D

Cone3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Cone3D

Cone3D Moved Cone

Move(spline2D, moveVector)

Move Spline2D by given vector

Parameters:

Name Type Description Default
spline2D Spline2D

Spline2D to move

required
moveVector Vector2D

Vector of translation

required

Returns:

Type Description
Spline2D

Spline2D Moved spline

Move(spline3D, moveVector)

Move Spline3D by given vector

Parameters:

Name Type Description Default
spline3D Spline3D

Spline3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
Spline3D

Spline3D Moved spline

Move(bspline3D, moveVector)

Move BSpline3D by given vector

Parameters:

Name Type Description Default
bspline3D BSpline3D

BSpline3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
BSpline3D

BSpline3D Moved spline

Move(brep, moveVector)

Move BRep3D by given vector

Parameters:

Name Type Description Default
brep BRep3D

BRep3D to move

required
moveVector Vector3D

Vector of translation

required

Returns:

Type Description
BRep3D

BRep3D Moved spline

MoveArc3DToZ0Plane(arc3D)

Move the given 3D arc on the z = 0 plane and create a 2D fromn it

Parameters:

Name Type Description Default
arc3D Arc3D

Arc 3D

required

Returns:

Type Description
eServiceResult

tuple(NO_ERR or INVALID_GEOOBJECT,

Arc2D

Arc 2D)

MoveSpline3DToZ0Plane(spline3D)

Move the given 3D arc on the z = 0 plane and create a 2D from it

Parameters:

Name Type Description Default
spline3D Spline3D

Spline 3D

required

Returns:

Type Description
eServiceResult

tuple(NO_ERR or INVALID_GEOOBJECT,

Spline2D

Spline 2D)

Offset overload

Offset(dist, lineSrc)

Counts parallel to 2D-Line

Parameters:

Name Type Description Default
dist float

Distance from the source

required
lineSrc Line2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element to the source through the 'point'

Offset(point, lineSrc)

Counts parallel to 2D-Line

Parameters:

Name Type Description Default
point Point2D

Parallel to this point

required
lineSrc Line2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element to the source through the 'point'

Offset(point, pathSrc)

Calculate parallel to Path2D

Parameters:

Name Type Description Default
point Point2D

parallel defined by the point

required
pathSrc Path2D

source path

required

Returns:

Type Description
tuple

GeoErrorCode,

tuple

destination parallel path

Offset(dist, pathSrc, checkSegmentsOrientation)

Calculate parallel to Path2D

ote If checkSegmentsOrientation is true, new polyline must have same count of points as original

Parameters:

Name Type Description Default
dist float

parallel defined by distance

required
pathSrc Path2D

source path

required
checkSegmentsOrientation bool

check, if segments in parallel geometry has same orientation as in original

required

Returns:

Type Description
tuple

GeoErrorCode,

tuple

destination path

Offset(point, arc2DSrc)

Calculate parallel to Arc2D

Parameters:

Name Type Description Default
point Point2D

Parallel to this point

required
arc2DSrc Arc2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(dist, arc2DSrc)

Calculate parallel to Arc2D

Parameters:

Name Type Description Default
dist float

Distance from the source

required
arc2DSrc Arc2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(dist, spline2DSrc, checkSegmentsOrientation)

Calculate parallel to Spline2D

ote If checkSegmentsOrientation is true, new parallel must have same count of points as original

Parameters:

Name Type Description Default
dist float

Distance from the source

required
spline2DSrc Spline2D

Source element

required
checkSegmentsOrientation bool

check, if segments in parallel geometry has same orientation as in original

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(point, spline2DSrc)

Calculate parallel to Spline2D

Parameters:

Name Type Description Default
point Point2D

Parallel to this point

required
spline2DSrc Spline2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(rDistance, polyline2D, checkSegmentsOrientation)

Calculate parallel to Polyline2D

ote If checkSegmentsOrientation is true, new polyline must have same count of points as original

Parameters:

Name Type Description Default
rDistance float

Distance from the source

required
polyline2D Polyline2D

Source element

required
checkSegmentsOrientation bool

check, if segments in parallel geometry has same orientation as in original

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(point, polyline2DSrc)

Calculate parallel to Polyline2D

Parameters:

Name Type Description Default
point Point2D

Parallel to this point

required
polyline2DSrc Polyline2D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(point, dist, lineSrc, offsetPlane)

Counts parallel to 3D-Line

ote If the 'dist' value is zero, the 'point' arg is used as a base to parallel. In other case, the 'dist' would be the distance from the source and the point represents the orientation.

Parameters:

Name Type Description Default
point Point3D

Parallel to this point

required
dist float

Distance from the source

required
lineSrc Line3D

Source element

required
offsetPlane Offset3DPlane

Plane on which parallel line will be calculated

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(dist, offsetPlane, parallelsCount, polySrc)

Counts parallels to 3D Polyline

Parameters:

Name Type Description Default
dist float

Distance from the source

required
offsetPlane Plane3D

Plane on which offsets will be calculated

required
parallelsCount int

Count of parallels to calculate

required
polySrc Polyline3D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel elements

Offset(point, offsetPlane, parallelsCount, polySrc)

Counts parallels to 3D Polyline

Parameters:

Name Type Description Default
point Point3D

Parallel to this point

required
offsetPlane Plane3D

Plane on which offsets will be calculated

required
parallelsCount int

Count of parallels to calculate

required
polySrc Polyline3D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel elements

Offset(point, arc3DSrc)

Calculates parallel to Arc3D

Parameters:

Name Type Description Default
point Point3D

Parallel to this point

required
arc3DSrc Arc3D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(dist, arc3DSrc)

Calculates parallel to Arc3D

Parameters:

Name Type Description Default
dist float

Distance from the source

required
arc3DSrc Arc3D

Source element

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(dist, spline3DSrc, plane, checkSegmentsOrientation)

Calculates parallel to Spline3D - only for planar 3D splines !!!

ote If checkSegmentsOrientation is true, new spline must have same count of points as original

Parameters:

Name Type Description Default
dist float

Distance from the source

required
spline3DSrc Spline3D

Source element

required
plane Plane3D

plane to offset in

required
checkSegmentsOrientation bool

check, if segments in parallel geometry has same orientation as in original

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(point, spline3DSrc, plane)

Calculates parallel to Spline3D - only for planar 3D splines !!!

Parameters:

Name Type Description Default
point Point3D

Parallel to this point

required
spline3DSrc Spline3D

Source element

required
plane Plane3D

plane to offset in

required

Returns:

Type Description
tuple

eOK if successful,

tuple

Parallel element

Offset(inputPath, normVector, offsetDistance)

Create offset of Path3D

Parameters:

Name Type Description Default
inputPath Path3D

input path

required
normVector Vector3D

normal vector of plane in that the offset will be calculated

required
offsetDistance float

offset distance

required

Returns:

Type Description
tuple

error code,

tuple

result offset curve

Offset(inputPath, inputPoint, rayVector, plane)

Offset Path3D in distance given with cursor point

Parameters:

Name Type Description Default
inputPath Path3D

input path

required
inputPoint Point3D

cursor point (ray point)

required
rayVector Vector3D

ray vector

required
plane Plane3D

plane of the planar face (of given boundary curves)

required

Returns:

Type Description
tuple

error code,

tuple

result path

OffsetCurve(inputCurves, normVector, offsetDistance, sortEdges)

Offset 3D curves with given distance

Parameters:

Name Type Description Default
inputCurves list

input curves

required
normVector Vector3D

normal vector of plane in that the offset will be calculated

required
offsetDistance float

offset distance

required
sortEdges bool

flag if to sort edges to original order

required

Returns:

Type Description
tuple

error code,

tuple

result offset curves

Polygonize overload

Polygonize(geometry_object, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize whole curve

Parameters:

Name Type Description Default
geometry_object object

Geometry object which will be polygonized

required
arcSegmentation int

segment number

required
useArcSegmentation int

if use segment polygonization, set to 0

required
armLength float

max length of calculated segment, for rise value polygonization only

required
riseValue float

rise value

required

Returns:

Type Description
bool

tuple(bool true = success,

Polyline3D

result polyline)

Polygonize(geometry_object, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
geometry_object object

Geometry object which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

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
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(path, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonizes multiple geometry objects, if they if they follow directly one another

emark The objects in the path must follow directly one another. This means, the start- or endpoint of one object has to be the start- or endpoint of the next object in the path and the other point of the object has to be the start- or endpoint of the previous object in the path. eg.: Start1-End1, End2-Start2, End3-Start3, Start4-End4 and so on. where, End1 == End2, Start2 == End3, Start3 == Start4

        If they don't follow one another, it's unknown how the calculated polyline will look.

        The parameters: arcSegmentation, useArcSegmentation, armLength, riseValue are not relevant for lines and polylines.
        eps is only relevant if, there is a spline or clothoid in the vector.
        See class-description for more information about these parameters.

Args:
    path:                The vector with the objects, which will be polygonized
    fromPoint:           where to begin the polygonization; The point has to be on one of the Objects
    toPoint:             where to end the polygonization; The point has to be on one of the Objects
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline
    eps:                 stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(line, fromPoint, toPoint, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
line Line2D

Line which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

required
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(polyline, fromPoint, toPoint, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
polyline Polyline2D

Polyline which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

required
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(polygon, fromPoint, toPoint, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
polygon Polygon2D

Polygon which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

required
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(arc, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize a single geometry object

Parameters:

Name Type Description Default
arc Arc2D

Arc which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

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
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(arc, fromPoint, toPoint, count, bInscribed)

Polygonize Arc2D with given division

Parameters:

Name Type Description Default
arc Arc2D

Arc2D

required
fromPoint Point2D

Start point for polygonization

required
toPoint Point2D

End point for polygonization

required
count int

Count of segments

required
bInscribed bool

in case of inscribed circle there is additional segment (one segment divided to 2 parts)

required

Returns:

Type Description
bool

tuple(bool (true = polygonization possible),

Polyline2D

PolyLine2D)

Polygonize(arc, countOfSegments)

Polygonize a Arc2D geometry object

Parameters:

Name Type Description Default
arc Arc2D

Arc2D which will be polygonized

required
countOfSegments int

Count of segments

required

Returns:

Type Description
Polyline2D

Polyline2D The polyline will be filled with the points of the polygonization

Polygonize(spline, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
spline Spline2D

Spline which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

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
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(bspline, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize a BSpline2D geometry object

Parameters:

Name Type Description Default
bspline BSpline2D

BSpline2D which will be polygonized

required
fromPoint Point3D

where to begin the polygonization

required
toPoint Point3D

where to end the polygonization

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
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(clothoid, fromPoint, toPoint, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

Parameters:

Name Type Description Default
clothoid Clothoid2D

Clothoid which will be polygonized

required
fromPoint Point3D

where to begin the polygonization; The point has to be on one of the Objects

required
toPoint Point3D

where to end the polygonization; The point has to be on one of the Objects

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
eps float

stw[295-1]

required

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polyline2D

the polyline will be filled with the points of the polygonization)

Polygonize(arc, countOfSegments)

Polygonize a Arc3D geometry object

Parameters:

Name Type Description Default
arc Arc3D

Arc3D which will be polygonized

required
countOfSegments int

Count of segments

required

Returns:

Type Description
Polyline3D

Polyline3D the polyline will be filled with the points of the polygonization

Polygonize(arc, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize a Arc3D geometry object

Parameters:

Name Type Description Default
arc Arc3D

Arc3D which will be polygonized

required
arcSegmentation int

Count of segments

required
useArcSegmentation int

if use segment polygonization, set to 0

required
armLength float

max length of calculated segment, for rise value polygonization only

required
riseValue float

rise value

required

Returns:

Type Description
bool

tuple(bool true = success,

Polyline3D

result polyline)

Polygonize(path, countOfSegments)

Polygonize a Path3D geometry object

Parameters:

Name Type Description Default
path Path3D

Path3D which will be polygonized

required
countOfSegments int

Count of segments

required

Returns:

Type Description
Polyline3D

Polyline3D the polyline will be filled with non repeated points of the polygonization

Polygonize(path, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize a Arc3D geometry object

Parameters:

Name Type Description Default
path Path3D

Path3D which will be polygonized

required
arcSegmentation int

Count of segments

required
useArcSegmentation int

if use segment polygonization, set to 0

required
armLength float

max length of calculated segment, for rise value polygonization only

required
riseValue float

rise value

required

Returns:

Type Description
Polyline3D

the result polyline

Polygonize(spline, linesPerSegment)

Polygonize a Spline3D geometry object

Parameters:

Name Type Description Default
spline Spline3D

Spline3D which will be polygonized

required
linesPerSegment int

Count of lines per segment

required

Returns:

Type Description
Polyline3D

Polyline3D the polyline will be filled with the points of the polygonization

Polygonize(spline, minmaxRadius, pixelSize)

Polygonize Spline3D

Parameters:

Name Type Description Default
spline Spline3D

Spline3D

required
minmaxRadius float

radius of minmax

required
pixelSize float

size of pixel

required

Returns:

Type Description
bool

tuple(bool (true = polygonization possible),

Polyline3D

polygonized spline)

Polygonize(spline, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize B-spline curve

Parameters:

Name Type Description Default
spline BSpline3D

spline to tesselate

required
arcSegmentation int

segment number

required
useArcSegmentation int

if use segment polygonization, set to 0

required
armLength float

max length of calculated segment, for rise value polygonization only

required
riseValue float

rise value

required

Returns:

Type Description
bool

tuple(bool true = success,

Polyline3D

result polyline)

Polygonize(spline, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize whole spline curve

Parameters:

Name Type Description Default
spline Spline3D

spline to tesselate

required
arcSegmentation int

segment number

required
useArcSegmentation int

if use segment polygonization, set to 0

required
armLength float

max length of calculated segment, for rise value polygonization only

required
riseValue float

rise value

required

Returns:

Type Description
bool

tuple(bool true = success,

Polyline3D

result polyline)

Polygonize(line)

Create polyline from line

Parameters:

Name Type Description Default
line Line3D

Line to polygonize

required

Returns:

Type Description
bool

tuple(bool true = success,

Polyline3D

Result polyline)

Polygonize(line, fromOffset, toOffset)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    line:        Line which will be polygonized
    fromOffset:  the offset from the elements start point, where polygonization will begin
    toOffset:    the offset from the elements start point, where polygonization will end

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(clothoid, fromOffset, toOffset, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    clothoid:            Clothoid which will be polygonized
    fromOffset:          the offset from the elements start point, where polygonization will begin
    toOffset:            the offset from the elements start point, where polygonization will end
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline
    eps:                 stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(polyline, fromOffset, toOffset, eps)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    polyline:    Polyline which will be polygonized
    fromOffset:  the offset from the elements start point, where polygonization will begin
    toOffset:    the offset from the elements start point, where polygonization will end
    eps:         stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(polygon, fromOffset, toOffset, eps)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    polygon:     Polygon which will be polygonized
    fromOffset:  the offset from the elements start point, where polygonization will begin
    toOffset:    the offset from the elements start point, where polygonization will end
    eps:         stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(arc, fromOffset, toOffset, arcSegmentation, useArcSegmentation, armLength, riseValue)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    arc:                 Arc which will be polygonized
    fromOffset:          the offset from the elements start point, where polygonization will begin
    toOffset:            the offset from the elements start point, where polygonization will end
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(arc, fromOffset, toOffset, count, bInscribed)

Polygonize Arc2D with given division

Parameters:

Name Type Description Default
arc Arc2D

Arc2D

required
fromOffset float

the offset from the elements start point, where polygonization will begin

required
toOffset float

the offset from the elements start point, where polygonization will end

required
count int

Count of segments

required
bInscribed bool

in case of inscribed circle there is additional segment (one segment divided to 2 parts)

required

Returns:

Type Description
bool

tuple(bool (true = polygonization possible),

Polyline2D

PolyLine2D)

Polygonize(spline, fromOffset, toOffset, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    spline:              Spline which will be polygonized
    fromOffset:          the offset from the elements start point, where polygonization will begin
    toOffset:            the offset from the elements start point, where polygonization will end
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline
    eps:                 stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(path, fromOffset, toOffset, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonizes multiple geometry objects, if they if they follow directly one another

emark The objects in the path must follow directly one another. This means, the start- or endpoint of one object has to be the start- or endpoint of the next object in the path and the other point of the object has to be the start- or endpoint of the previous object in the path. eg.: Start1-End1, End2-Start2, End3-Start3, Start4-End4 and so on. where, End1 == End2, Start2 == End3, Start3 == Start4

        If they don't follow one another, it's unknown how the calculated polyline will look.

        The parameters: arcSegmentation, useArcSegmentation, armLength, riseValue are not relevant for lines and polylines.
        eps is only relevant if, there is a spline or clothoid in the vector.
        See class-description for more information about these parameters.

Args:
    path:                The vector with the objects, which will be polygonized
    fromOffset:          the offset from the elements start point, where polygonization will begin
    toOffset:            the offset from the elements start point, where polygonization will end
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline
    eps:                 stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)
Polygonize(area, eps, arcSegmentation=360, useArcSegmentation=0, armLength=0.0, riseValue=0.0)

Polygonizes path bounded area

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

path bounded area to be polygonized

required
eps float

Number of segments the arc will be divided

required
arcSegmentation int

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

360
useArcSegmentation int

maximum length of a segment for polygonized arc

0
armLength float

is the maximum distance from the actual arc and the polyline

0.0
riseValue float

stw[295-1]

0.0

Returns:

Type Description
bool

tuple(true, if calculation completes, false: if something went wrong during the calculation,

Polygon2D

the resulting polygon)

Polygonize(geometry_object, fromOffset, toOffset, arcSegmentation, useArcSegmentation, armLength, riseValue, eps)

Polygonize a single geometry object

emark The polygonization is always done in the direction of the element and therefor for non-cyclic elements the fromOffset must be smaller than the toOffset

Args:
    geometry_object:     Geometry object which will be polygonized
    fromOffset:          the offset from the elements start point, where polygonization will begin
    toOffset:            the offset from the elements start point, where polygonization will end
    arcSegmentation:     Number of segments the arc will be divided
    useArcSegmentation:  type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
    armLength:           maximum length of a segment for polygonized arc
    riseValue:           is the maximum distance from the actual arc and the polyline
    eps:                 stw[295-1]

Returns:
    tuple(true, if calculation completes, false: if something went wrong during the calculation,
    the polyline will be filled with the points of the polygonization)

PolygonizeEqually(arc, fromPoint, toPoint, count)

Polygonize given arc always equally

Parameters:

Name Type Description Default
arc Arc2D

Source arc

required
fromPoint Point2D

Start point for polygonization

required
toPoint Point2D

End point for polygonization

required
count int

Count of segments

required

Returns:

Type Description
bool

tuple(bool (true = polygonization possible),

Polyline2D

Output polyline)

Rotate overload

Rotate(point, angle)

Rotate a point around zero point by an angle.

Parameters:

Name Type Description Default
point Point2D

2D Point

required
angle Angle

Angle

required

Returns:

Type Description
Point2D

Resulting 2D Point

Rotate(point, zeroPoint, angle)

Rotate a point around given point by an angle.

Parameters:

Name Type Description Default
point Point2D

2D Point

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Point2D

Resulting 2D point

Rotate(line, angle)

Rotate a line around zero point by an angle.

Parameters:

Name Type Description Default
line Line2D

2D line

required
angle Angle

Angle

required

Returns:

Type Description
Line2D

Resulting 2D line

Rotate(line, zeroPoint, angle)

Rotate a line around given point by an angle.

Parameters:

Name Type Description Default
line Line2D

2D line

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Line2D

Resulting 2D line

Rotate(arc, angle)

Rotate a arc around zero point by an angle.

This function rotate center point and start and end angles.

Parameters:

Name Type Description Default
arc Arc2D

2D arc

required
angle Angle

Angle

required

Returns:

Type Description
Arc2D

Resulting 2D arc

Rotate(arc, zeroPoint, angle)

Rotate a arc around given point by an angle.

This function rotate center point start and end angles.

Parameters:

Name Type Description Default
arc Arc2D

2D arc

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Arc2D

Resulting 2D arc

Rotate(vec, angle)

Rotate a vector by an angle.

Parameters:

Name Type Description Default
vec Vector2D

2D vector

required
angle Angle

Angle

required

Returns:

Type Description
Vector2D

Resulting 2D vector

Rotate(vec, axis, angle)

Rotate a vector by an angle.

Parameters:

Name Type Description Default
vec Vector3D

3D vector

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Vector3D

Resulting 3D vector

Rotate(polyline, zeroPoint, angle)

Rotate a polyline around given point by an angle.

Parameters:

Name Type Description Default
polyline Polyline2D

2D polyline

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Polyline2D

Resulting 2D polyline

Rotate(polyline, angle)

Rotate a polyline around origin by an angle.

Parameters:

Name Type Description Default
polyline Polyline2D

2D polyline

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Polyline2D

Resulting 2D polyline

Rotate(axis, angle)

Rotate a axis around origin by an angle.

Parameters:

Name Type Description Default
axis Axis2D

2D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Axis2D

Resulting 2D axis

Rotate(axis, zeroPoint, angle)

Rotate a axis around given point by an angle.

Parameters:

Name Type Description Default
axis Axis2D

2D axis

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Axis2D

Resulting 2D axis

Rotate(axis, angle)

Rotate a axis placement around origin by an angle.

Parameters:

Name Type Description Default
placement

2D axis placement

required
angle Angle

Angle of rotation

required

Returns:

Type Description
AxisPlacement2D

Resulting 2D axis placement

Rotate(axis, zeroPoint, angle)

Rotate a axis placement around given point by an angle.

Parameters:

Name Type Description Default
placement

2D axis placement

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
AxisPlacement2D

Resulting 2D axis placement

Rotate(placement, angle)

Rotate a axis placement3D around origin(z-axis) by an angle.

Parameters:

Name Type Description Default
placement AxisPlacement3D

3D axis placement

required
angle Angle

Angle of rotation

required

Returns:

Type Description
AxisPlacement3D

Resulting 3D axis placement

Rotate(placement, rotAxis, angle)

Rotate a axis placement 3D around origin(z-axis) by an angle.

Parameters:

Name Type Description Default
placement AxisPlacement3D

3D axis placement

required
rotAxis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
AxisPlacement3D

Resulting 3D Axis placement

Rotate(placement, zeroPoint, angle)

Rotate a axis placement around given point (z-axis) by an angle.

Parameters:

Name Type Description Default
placement AxisPlacement3D

3D axis placement

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
AxisPlacement3D

Resulting 3D axis placement

Rotate(clothoid, angle)

Rotate a clothoid around origin by an angle.

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Clothoid2D

Resulting 2D clothoid

Rotate(clothoid, zeroPoint, angle)

Rotate a clothoid around given point by an angle.

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Clothoid2D

Resulting 2D clothoid

Rotate(polygon, angle)

Rotate a polygon around origin by an angle.

Parameters:

Name Type Description Default
polygon Polygon2D

2D polygon

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Polygon2D

Resulting 2D polygon

Rotate(polygon, zeroPoint, angle)

Rotate a polygon around given point by an angle.

Parameters:

Name Type Description Default
polygon Polygon2D

2D polygon

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Polygon2D

Resulting 2D polygon

Rotate(area, angle)

Rotate a polygonal area around origin by an angle.

Parameters:

Name Type Description Default
area PolygonalArea2D

2D polygonal area

required
angle Angle

Angle of rotation

required

Returns:

Type Description
PolygonalArea2D

Resulting 2D polygonal area

Rotate(area, zeroPoint, angle)

Rotate a polygonal area around given point by an angle.

Parameters:

Name Type Description Default
area PolygonalArea2D

2D polygonal area

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
PolygonalArea2D

Resulting 2D polygonal area

Rotate(spline, angle)

Rotate a spline around origin by an angle.

Parameters:

Name Type Description Default
spline Spline2D

2D spline

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Spline2D

Resulting 2D spline

Rotate(spline, zeroPoint, angle)

Rotate a spline around given point by an angle.

Parameters:

Name Type Description Default
spline Spline2D

2D spline

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Spline2D

Resulting 2D spline

Rotate(point, angle)

Rotate a 3D point around origin by an angle.

Parameters:

Name Type Description Default
point Point3D

3D point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Point3D

Resulting 3D point

Rotate(point, zeroPoint, angle)

Rotate a 3D point around given 2D point by an angle.

Parameters:

Name Type Description Default
point Point3D

3D point

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Point3D

Resulting 3D point

Rotate(point, axis, angle)

Rotate a 3D point around given 3D axis by an angle.

Parameters:

Name Type Description Default
point Point3D

3D point

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Point3D

Resulting 3D point

Rotate(line, zeroPoint, angle)

Rotate a 3D line around given 2D point by an angle.

Parameters:

Name Type Description Default
line Line3D

3D line

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Line3D

Resulting 3D line

Rotate(cylinder, angle)

Rotate a 3D Cylinder around origin by an angle.

Parameters:

Name Type Description Default
cylinder Cylinder3D

3D Cylinder

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cylinder3D

Resulting 3D Cylinder

Rotate(cylinder, zeroPoint, angle)

Rotate a 3D Cylinder around given 2D point by an angle.

Parameters:

Name Type Description Default
cylinder Cylinder3D

3D Cylinder

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cylinder3D

Resulting 3D Cylinder

Rotate(cylinder, axis, angle)

Rotate a 3D Cylinder around given 3D axis by an angle.

Parameters:

Name Type Description Default
cylinder Cylinder3D

3D Cylinder

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cylinder3D

Resulting 3D Cylinder

Rotate(ellipsoid, angle)

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

3D Ellipsoid

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Ellipsoid3D

Resulting 3D Ellipsoid

Rotate(ellipsoid, zeroPoint, angle)

Rotate a 3D Ellipsoid around given 2D point by an angle.

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

3D Ellipsoid

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Ellipsoid3D

Resulting 3D Ellipsoid

Rotate(ellipsoid, axis, angle)

Rotate a 3D Ellipsoid around given 3D axis by an angle.

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

3D Ellipsoid

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Ellipsoid3D

Resulting 3D Ellipsoid

Rotate(cone, angle)

Rotate a 3D Cone around origin by an angle.

Parameters:

Name Type Description Default
cone Cone3D

3D Cone

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cone3D

Resulting 3D Cone

Rotate(cone, zeroPoint, angle)

Rotate a 3D Cone around given 2D point by an angle.

Parameters:

Name Type Description Default
cone Cone3D

3D Cone

required
zeroPoint Point2D

2D zero point

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cone3D

Resulting 3D Cone

Rotate(cone, axis, angle)

Rotate a 3D Cone around given 3D axis by an angle.

Parameters:

Name Type Description Default
cone Cone3D

3D Cone

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Cone3D

Resulting 3D Cone

Rotate(minmax, angle)

Rotate a MinMax2D by an angle.

Parameters:

Name Type Description Default
minmax MinMax2D

2D MinMax

required
angle Angle

Angle of rotation

required

Returns:

Type Description
MinMax2D

Resulting 2D MinMax

Rotate(brep, axis, angle)

Rotate a brep around given 3D axis by an angle.

Parameters:

Name Type Description Default
brep BRep3D

brep

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
BRep3D

brep

Rotate(polyhedron, axis, angle)

Rotate a polyhedron around given 3D axis by an angle.

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

polyhedron

required
axis Axis3D

3D axis

required
angle Angle

Angle of rotation

required

Returns:

Type Description
Polyhedron3D

polyhedron

SetAbsoluteTolerance(value)

set absolute tolerance

Parameters:

Name Type Description Default
value float

new value

required

SetAngleTolerance(value)

Set angle tolerance

This tolerance is using for angle comparison.

Parameters:

Name Type Description Default
value Angle

New tolerance using for angle comparison [rad]

required

SetCurvatureTolerance(value)

Set curvature tolerance

This tolerance is using for curvature comparison.

Parameters:

Name Type Description Default
value float

New tolerance using for curvature comparison

required

SetCurveLengthTolerance(value)

Set curve length tolerance

This tolerance is using for length of curve comparison.

Parameters:

Name Type Description Default
value float

New tolerance using for length of curve comparison [mm]

required

SetRelativeTolerance(value)

set relative tolerance

Parameters:

Name Type Description Default
value float

new value

required

SetZValue(zValue, line)

Set the the z value of a line

Parameters:

Name Type Description Default
zValue float

zValue

required
line Line3D

line

required

Returns:

Type Description

true, if the calculation was correct

Split overload

Split(line2D, splitPoints, posTol)

Split a Line2D into multiple Line2D geometries by given split points

Parameters:

Name Type Description Default
line2D Line2D

The line to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the line)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split lines

Split(line3D, splitPoints, posTol)

Split a Line3D into multiple Line3D geometries by given split points

Parameters:

Name Type Description Default
line3D Line3D

The line to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the line)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split lines

Split(polyline2D, splitPoints, posTol)

Split a Polyline2D into multiple Polyline2D geometries by given split points

Parameters:

Name Type Description Default
polyline2D Polyline2D

The polyline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the polyline)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split polylines

Split(polyline3D, splitPoints, posTol)

Split a Polyline3D into multiple Polyline3D geometries by given split points

Parameters:

Name Type Description Default
polyline3D Polyline3D

The polyline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the line)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split polylines

Split(arc2D, splitPoints, posTol)

Split a Arc2D into multiple Arc2D geometries by given split points

Parameters:

Name Type Description Default
arc2D Arc2D

The arc to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the arc)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split arcs

Split(arc3D, splitPoints, posTol)

Split a Arc3D into multiple Arc3D geometries by given split points

Parameters:

Name Type Description Default
arc3D Arc3D

The arc to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the line)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split arcs

Split(spline2D, splitPoints, posTol)

Split a Spline2D into multiple Spline2D geometries by given split points

Parameters:

Name Type Description Default
spline2D Spline2D

The spline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the spline)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split splines

Split(spline3D, splitPoints, posTol)

Split a Spline3D into multiple Spline3D geometries by given split points

Parameters:

Name Type Description Default
spline3D Spline3D

The spline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the spline)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split splines

Split(bspline2D, splitPoints, posTol)

Split a BSpline2D into multiple BSpline2D geometries by given split points

Parameters:

Name Type Description Default
bspline2D BSpline2D

The spline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the spline)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split splines

Split(bspline3D, splitPoints, posTol)

Split a BSpline3D into multiple BSpline3D geometries by given split points

Parameters:

Name Type Description Default
bspline3D BSpline3D

The spline to split

required
splitPoints Point3DList

The given split points (e.g. intersection points onto the spline)

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split splines

Split(polyline2D, polygon2D, posTol)

Split a Polyline2D into multiple Polyline2D geometries by given split polygon

Parameters:

Name Type Description Default
polyline2D Polyline2D

The polyline to split

required
polygon2D Polygon2D

The given polygon

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Vector of split polylines inside polygon,

tuple

Vector of split polylines outside polygon

Split(polygon, polyline, posTol, divideComponents)

Split Polygon2D into 3 polygons by given Polyline2D

Parameters:

Name Type Description Default
polygon Polygon2D

The polygon to split

required
polyline Polyline2D

The given polyline

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required
divideComponents bool

If true, polygon will be split by intersection points of polyline and connection lines between components

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Polygon, which consist of not split components,

tuple

Polygon, which consist of components on left side of polyline,

tuple

Polygon, which consist of components on right side of polyline

Split(polygon, axis, posTol, divideComponents)

Split Polygon2D into 3 polygons by given Axis2D

Parameters:

Name Type Description Default
polygon Polygon2D

The polygon to split

required
axis Axis2D

The given axis

required
posTol float

Tolerance being used to determine the position of split points on the input curve

required
divideComponents bool

If true, polygon will be split by intersection points of polyline and connection lines between components

required

Returns:

Type Description
tuple

eSplitResult, SPLIT_OK on success,

tuple

Polygon, which consist of not split components,

tuple

Polygon, which consist of components on left side of polyline,

tuple

Polygon, which consist of components on right side of polyline

SplitPolygon3DToParts(polygon)

Splits normalized Polygon3D into parts

Parameters:

Name Type Description Default
polygon Polygon3D

Normalized 3D polygon

required

Returns:

Type Description
tuple

eOK if converted successful, else eError,

tuple

Vector of parts (loops)

Tesselate overload

Tesselate(brep, density, maxAngle, minEdge, maxEdge)

Tesselate b-rep with mesh triangles

Parameters:

Name Type Description Default
brep BRep3D

brep to be tesselated

required
density float

density of resulting mesh (when 0, not used)

required
maxAngle float

maximal angle between neighbor triangles in degrees (when 0, not used)

required
minEdge float

minimal edge length (when 0, not used)

required
maxEdge float

maximal edge length (when 0, not used)

required

Returns:

Type Description
tuple

error code,

tuple

resulting tesselated polyhedron

Tesselate(brep, density, chord, maxAngle, minEdge, maxEdge)

Tesselate b-rep with mesh triangles

Parameters:

Name Type Description Default
brep BRep3D

brep to be tesselated

required
density float

density of resulting mesh (when 0, not used)

required
chord float

curve/surface chord tolerance (when 0, not used)

required
maxAngle float

maximal angle between neighbor triangles in degrees (when 0, not used)

required
minEdge float

minimal edge length (when 0, not used)

required
maxEdge float

maximal edge length (when 0, not used)

required

Returns:

Type Description
tuple

error code,

tuple

resulting tesselated polyhedron

Touching overload

Touching(line1, line2)

Test for collision between 2 line2D objects

Parameters:

Name Type Description Default
line1 Line2D

the first geometry object

required
line2 Line2D

the second geometry object

required

Returns:

Type Description
bool

true when in touch, otherwise false.

Touching(polygon1, polygon2)

Test for collision between 2 polygon2D objects

Parameters:

Name Type Description Default
polygon1 Polygon2D

the first geometry object

required
polygon2 Polygon2D

the second geometry object

required

Returns:

Type Description
bool

true when 1 or more lines in touch, otherwise false.

Touching(polygon, polyline)

Test for collision between polygon2D and polyline2D

Parameters:

Name Type Description Default
polygon Polygon2D

the first geometry object

required
polyline Polyline2D

the second geometry object

required

Returns:

Type Description
bool

true when 1 or more lines in touch, otherwise false.

Transform overload

Transform(point, matrix)

Point2D matrix transformation.

Parameters:

Name Type Description Default
point Point2D

2D point to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(line, matrix)

Line2D matrix transformation.

Parameters:

Name Type Description Default
line Line2D

2D line to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(vec, matrix)

Vector2D matrix transformation.

Parameters:

Name Type Description Default
vec Vector2D

2D vector to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(arc, matrix)

Arc2D matrix transformation.

Parameters:

Name Type Description Default
arc Arc2D

2D arc to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(clothoid, matrix)

Clothoid2D matrix transformation.

Parameters:

Name Type Description Default
clothoid Clothoid2D

2D clothoid to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(spline, matrix)

Spline2D matrix transformation.

Parameters:

Name Type Description Default
spline Spline2D

2D spline to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(axis, matrix)

Axis2D matrix transformation.

Parameters:

Name Type Description Default
axis Axis2D

2D axis to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(polyline, matrix)

Polyline2D matrix transformation.

Parameters:

Name Type Description Default
polyline Polyline2D

2D polyline to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(path, matrix)

Path2D matrix transformation.

Parameters:

Name Type Description Default
path Path2D

2D path to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(area, matrix)

PolygonalArea2D matrix transformation.

Parameters:

Name Type Description Default
area PolygonalArea2D

2D polygonal area which will be transformed

required
matrix Matrix2D

Transformation Matrix.

required
Transform(area, matrix)

ClosedArea2D matrix transformation.

Parameters:

Name Type Description Default
area ClosedArea2D

2D path bounded area which will be transformed

required
matrix Matrix2D

Transformation Matrix.

required
Transform(area, matrix)

ClosedAreaComposite2D matrix transformation.

Parameters:

Name Type Description Default
area ClosedAreaComposite2D

2D path bounded area composite which will be transformed

required
matrix Matrix2D

Transformation Matrix.

required
Transform(point, matrix)

Point3D matrix3D transformation.

Parameters:

Name Type Description Default
point Point3D

3D point to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(point, matrix)

Point3D matrix2D transformation.

Parameters:

Name Type Description Default
point Point3D

3D point to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(el, matrix)

Line3D matrix3D transformation.

Parameters:

Name Type Description Default
el Line3D

3D line to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(el, matrix)

Line3D matrix2D transformation.

Parameters:

Name Type Description Default
el Line3D

3D line to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(vec, matrix)

Vector3D matrix3D transformation.

Parameters:

Name Type Description Default
vec Vector3D

3D vector to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(vec, matrix)

Vector3D matrix2D transformation.

Parameters:

Name Type Description Default
vec Vector3D

3D vector to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(arc, matrix)

Arc3D matrix3D transformation.

Parameters:

Name Type Description Default
arc Arc3D

3D arc to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(arc, matrix)

Arc3D matrix2D transformation.

Parameters:

Name Type Description Default
arc Arc3D

3D arc to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(cuboid, matrix)

Cuboid3D matrix3D transformation.

Parameters:

Name Type Description Default
cuboid Cuboid3D

3D cuboid to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(cuboid, matrix)

Cuboid3D matrix2D transformation.

Parameters:

Name Type Description Default
cuboid Cuboid3D

3D cuboid to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(plane, matrix)

Plane3D matrix3D transformation.

Parameters:

Name Type Description Default
plane Plane3D

3D plane to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(plane, matrix)

Plane3D matrix2D transformation.

Parameters:

Name Type Description Default
plane Plane3D

2D plane to transform.

required
matrix Matrix2D

Transformation 3D Matrix.

required
Transform(polygon, matrix)

Polyline2D matrix transformation.

Parameters:

Name Type Description Default
polygon Polygon2D

2D polygon to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(polygon, matrix)

Polygon3D matrix transformation.

Parameters:

Name Type Description Default
polygon Polygon3D

3D polygon to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(polygon, matrix)

Polygon3D matrix transformation.

Parameters:

Name Type Description Default
polygon Polygon3D

3D polygon to transform.

required
matrix Matrix3D

Transformation Matrix.

required
Transform(polyline, matrix)

Polyline3D matrix transformation.

Parameters:

Name Type Description Default
polyline Polyline3D

3D polyline to transform.

required
matrix Matrix2D

Transformation Matrix.

required
Transform(polyline, matrix)

Polyline3D matrix transformation.

Parameters:

Name Type Description Default
polyline Polyline3D

3D polyline to transform.

required
matrix Matrix3D

Transformation Matrix.

required
Transform(spline, matrix)

Spline3D matrix transformation.

Parameters:

Name Type Description Default
spline Spline3D

3D spline to transform.

required
matrix Matrix3D

Transformation Matrix.

required
Transform(polyhedron, matrix)

Polyhedron3D matrix3D transformation.

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

3D polyhedron to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(polyhedron, matrix)

Polyhedron3D matrix2D transformation.

Parameters:

Name Type Description Default
polyhedron Polyhedron3D

3D polyhedron to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(axis, matrix)

Axis3D matrix2D transformation.

Parameters:

Name Type Description Default
axis Axis3D

3D axis to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(axis, matrix)

Axis3D matrix3D transformation.

Parameters:

Name Type Description Default
axis Axis3D

3D axis to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(path, matrix)

Path3D matrix3D transformation.

Parameters:

Name Type Description Default
path Path3D

3D path to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(path, matrix)

Path3D matrix2D transformation.

Parameters:

Name Type Description Default
path Path3D

3D path to transform.

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(area, matrix)

PolygonalArea3D matrix2D transformation.

Parameters:

Name Type Description Default
area PolygonalArea3D

3D polygonal area which will be transformed

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(area, matrix)

PolygonalArea3D matrix3D transformation.

Parameters:

Name Type Description Default
area PolygonalArea3D

3D polygonal area which will be transformed

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(solid, matrix)

ClippedSweptSolid3D matrix2D transformation.

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

ClippedSweptSolid3D which will be transformed

required
matrix Matrix2D

Transformation 2D Matrix.

required
Transform(solid, matrix)

ClippedSweptSolid3D matrix3D transformation.

This body is transformed by 2D transformations only to keep vertical extrusion of the profile.

Parameters:

Name Type Description Default
solid ClippedSweptSolid3D

ClippedSweptSolid3D which will be transformed

required
matrix Matrix3D

Transformation 2D Matrix.

required
Transform(cylinder, matrix)

Cylinder3D matrix2D transformation.

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder3D which will be transformed

required
matrix Matrix2D

Transformation 2D Matrix.

required

Warning: Perspective transformation will not work correctly

Transform(cylinder, matrix)

Cylinder3D matrix3D transformation.

Parameters:

Name Type Description Default
cylinder Cylinder3D

Cylinder3D which will be transformed

required
matrix Matrix3D

Transformation 3D Matrix.

required

Warning: Perspective transformation will not work correctly

Transform(ellipsoid, matrix)

Ellipsoid3D matrix2D transformation.

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid3D which will be transformed

required
matrix Matrix2D

Transformation 2D Matrix.

required

Warning: Perspective transformation will not work correctly

Transform(ellipsoid, matrix)

Ellipsoid3D matrix3D transformation.

Parameters:

Name Type Description Default
ellipsoid Ellipsoid3D

Ellipsoid3D which will be transformed

required
matrix Matrix3D

Transformation 3D Matrix.

required

Warning: Perspective transformation will not work correctly

Transform(brep, matrix)

BRep3D matrix3D transformation.

Parameters:

Name Type Description Default
brep BRep3D

Brep3D to transform.

required
matrix Matrix3D

Transformation 3D Matrix.

required
Transform(brep, matrix)

BRep3D matrix2D transformation.

Parameters:

Name Type Description Default
brep BRep3D

Brep3D to transform.

required
matrix Matrix2D

Transformation 3D Matrix.

required
Transform(spline, matrix)

BSpline3D matrix transformation

Parameters:

Name Type Description Default
spline BSpline3D

Bspline3D to transform

required
matrix Matrix3D

Transformation 3D matrix

required
Transform(spline, matrix)

BSpline3D matrix transformation

Parameters:

Name Type Description Default
spline BSpline3D

Bspline3D to transform

required
matrix Matrix2D

Transformation 2D matrix

required
Transform(cone, matrix)

Cone3D matrix transformation

Parameters:

Name Type Description Default
cone Cone3D

Cone3D to transform

required
matrix Matrix3D

Transformation 3D matrix

required
Transform(cone, matrix)

Cone3D matrix transformation

Parameters:

Name Type Description Default
cone Cone3D

Cone3D to transform

required
matrix Matrix2D

Transformation 2D matrix

required