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	Point	required
p2	Point2D	Point	required
p3	Point2D	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	element	required
el2	Polyhedron3D	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	element	required
el2	MinMax2D	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	element	required
el2	Line2D	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	element	required
el2	Polygon2D	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	element	required
el2	BRep3D	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	element	required
el2	MinMax2D	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	element	required
el2	Line2D	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	element	required
el2	Axis2D	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	element	required
el2	Line2D	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	element	required
el2	Polyhedron3D	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