NemAll_Python_Geometry
Exposed classes and functions from NemAll_Python_Geometry
AddToMinMax
overloaded
CalcAngle
overloaded
CalcArea
overloaded
Get the area of a 2D Polygon NEGATIVE_ORIENTATION for a CW orientated polygon, INVALID_POLYGON on error
If an instance denotes an incorrect polygon (e.g. not enough points), the method will return INVALID_POLYGON. us, one can distinguish between a collapsed polygon with area = 0.0 and a wrong shape. The polygon must not be self-intersecting. In case of self intersection the area result is currently defined and the return value indicates no error. interface: age
Parameters:
-
polygon
(Polygon2D
) –The polygon those area is requested
Returns:
CalcArea(polygonalArea: PolygonalArea3D) -> tuple
CalcArea(
areaGeo: ClosedArea2D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple
Get the area of a 2D path bounded closed area NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error
Parameters:
-
areaGeo
(ClosedArea2D
) –The path bounded closed area those area is requested
-
arcSegmentation
(int
) –Number of segments the arc will be divided
-
useArcSegmentation
(int
) –type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
-
armLength
(float
) –maximum length of a segment for polygonized arc
-
riseValue
(float
) –is the maximum distance from the actual arc and the polyline
Returns:
CalcArea(
areaGeo: ClosedAreaComposite2D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple
Get the area of a 2D path bounded closed area composite NEGATIVE_ORIENTATION for a CW orientated area boundary, INVALID_POLYGON on error
Parameters:
-
areaGeo
(ClosedAreaComposite2D
) –The path bounded closed area composite those area is requested
-
arcSegmentation
(int
) –Number of segments the arc will be divided
-
useArcSegmentation
(int
) –type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
-
armLength
(float
) –maximum length of a segment for polygonized arc
-
riseValue
(float
) –is the maximum distance from the actual arc and the polyline
Returns:
CalcLength
overloaded
CalcLength(el: Line2D) -> float
CalcLength(vec: Vector2D) -> float
calculate length of a 2D vector.
Parameters:
-
vec
(Vector2D
) –2D vector.
Returns:
-
float
–double result.
CalcLength(polyline: Polyline2D) -> float
Calculate the Length of a 2D Polyline.
Parameters:
-
polyline
(Polyline2D
) –2D Polyline
Returns:
-
float
–Length of the given polyline.
CalcLength(polygon: Polygon2D) -> float
Calculate the Length of a 2D Polygon.
Result is length from all components, doesn't matter if it's solid or hole.
Parameters:
-
polygon
(Polygon2D
) –2D Polygon
Returns:
-
float
–Length of the given polygon.
CalcLength(polygon: Polygon3D) -> float
Calculate the Length of a 3D Polygon.
Result is length from all components, doesn't matter if it's solid or hole.
Parameters:
-
polygon
(Polygon3D
) –3D Polygon
Returns:
-
float
–Length of the given polygon.
CalcLength(arc: Arc2D) -> float
Calculate the Length of a 2D arc.
Parameters:
-
arc
(Arc2D
) –2D Arc
Returns:
-
float
–Length of the given arc.
CalcLength(clothoid: Clothoid2D) -> float
Calculate the Length of a 2D clothoid.
Parameters:
-
clothoid
(Clothoid2D
) –2D Clothoid
Returns:
-
float
–Length of the given clothoid.
CalcLength(spline: Spline2D) -> float
Calculate the Length of a 2D spline.
Parameters:
-
spline
(Spline2D
) –2D Spline
Returns:
-
float
–Length of the given spline.
CalcLength(path: Path2D) -> float
Calculate the Length of a Path 2D.
Parameters:
-
path
(Path2D
) –Path2D
Returns:
-
float
–Length of the given Path2D
CalcLength(line: Line3D) -> float
CalcLength(vec: Vector3D) -> float
calculate length of a 3D vector.
Parameters:
-
vec
(Vector3D
) –3D vector.
Returns:
-
float
–double result.
CalcLength(polyline: Polyline3D) -> float
calculate length of a 3D polyline.
Parameters:
-
polyline
(Polyline3D
) –3D polyline.
Returns:
-
float
–double result.
CalcLength(arc: Arc3D) -> float
CalcLength(path: Path3D) -> float
CalcLength(poly: Polyhedron3D) -> float
calculate length of a polyhedron of edge type.
Parameters:
-
poly
(Polyhedron3D
) –Polyhedron3D.
Returns:
-
float
–double result.
CalcLength(spline: Spline3D) -> float
Calculate the Length of a 3D spline.
Parameters:
-
spline
(Spline3D
) –3D Spline
Returns:
-
float
–Length of the given spline.
CalcLength(spline: Spline3D) -> float
Calculate the Length of a 3D spline.
Parameters:
-
spline
(Spline3D
) –3D Spline
Returns:
-
float
–Length of the given spline.
CalcLength(spline: BSpline3D) -> float
Calculate the Length of a 3D bspline.
Parameters:
-
spline
(BSpline3D
) –3D BSpline
Returns:
-
float
–Length of the given spline.
CalcMass
overloaded
CalcMass(elem: Polyhedron3D) -> tuple
Calculate mass values
Parameters:
-
elem
(Polyhedron3D
) –Polyhedron3D
Returns:
-
tuple
–error code,
calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Cylinder3D) -> tuple
Calculate mass values
Parameters:
-
elem
(Cylinder3D
) –Cylinder3D
Returns:
-
tuple
–error code,
calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: Ellipsoid3D) -> tuple
Calculate mass values
Parameters:
-
elem
(Ellipsoid3D
) –Ellipsoid3D
Returns:
-
tuple
–error code,
calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: ClippedSweptSolid3D) -> tuple
Calculate mass values
Parameters:
-
elem
(ClippedSweptSolid3D
) –ClippedSweptSolid3D
Returns:
-
tuple
–error code,
calculated volume,
calculated surface,
calculated gravity point
CalcMass(elem: ExtrudedAreaSolid3D) -> tuple
Calculate mass values
Parameters:
-
elem
(ExtrudedAreaSolid3D
) –ExtrudedAreaSolid3D
Returns:
-
tuple
–error code,
calculated volume,
calculated surface,
calculated gravity point
CalcMinMax
overloaded
CalcMinMax(point: Point2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Point2D given in parameter point
Parameters:
-
point
(Point2D
) –Point2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(line: Line2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Line2D given in parameter line.
Parameters:
-
line
(Line2D
) –Line2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(polyline: Polyline2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Polyline2D given in parameter polyline.
Parameters:
-
polyline
(Polyline2D
) –Polyline2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR, INVALID_POLYLINE)
CalcMinMax(polygon: Polygon2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Polygon2D given in parameter polygon.
Parameters:
-
polygon
(Polygon2D
) –Polygon2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR, INVALID_POLYGON)
CalcMinMax(arc: Arc2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Arc2D given in parameter arc.
Parameters:
-
arc
(Arc2D
) –Arc2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(spline: Spline2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Spline2D given in parameter spline.
Parameters:
-
spline
(Spline2D
) –Spline2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(spline: Spline3D) -> tuple[MinMax3D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax3D box of the Spline3D given in parameter spline.
Parameters:
-
spline
(Spline3D
) –Spline3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR)
CalcMinMax(spline: BSpline3D) -> tuple[MinMax3D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax3D box of the BSpline3D given in parameter spline.
Parameters:
-
spline
(BSpline3D
) –BSpline3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR)
CalcMinMax(spline: BSpline2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box of the BSpline2D given in parameter spline.
Parameters:
-
spline
(BSpline2D
) –BSpline2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(clothoid: Clothoid2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box by the Clothoid2D given in parameter clothoid.
Parameters:
-
clothoid
(Clothoid2D
) –Clothoid to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(path: Path2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box of the Path2D.
Parameters:
-
path
(Path2D
) –Path2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(area: ClosedArea2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box of the ClosedArea2D.
Parameters:
-
area
(ClosedArea2D
) –ClosedArea2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(area: ClosedAreaComposite2D) -> tuple[MinMax2D, eServiceResult]
Calculate Min- and Max Point of an element.
Calculates the MinMax2D box of the ClosedAreaComposite2D.
Parameters:
-
area
(ClosedAreaComposite2D
) –ClosedAreaComposite2D to be calculated
Returns:
-
tuple[MinMax2D, eServiceResult]
–tuple(MinMax2D, NO_ERR)
CalcMinMax(point: Point3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Point3D given in parameter point.
Parameters:
-
point
(Point3D
) –Point3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR)
CalcMinMax(line: Line3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Line3D given in parameter line.
Parameters:
-
line
(Line3D
) –Line3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR)
CalcMinMax(polyline: Polyline3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Polyline3D given in parameter polyline.
Parameters:
-
polyline
(Polyline3D
) –Polyline3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYLINE)
CalcMinMax(pointCloud: object) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the PointCloud3D given in parameter point cloud.
Parameters:
-
pointCloud
(object
) –PointCloud3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYLINE)
CalcMinMax(polygon: Polygon3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Polygon3D given in parameter polygon.
Parameters:
-
polygon
(Polygon3D
) –Polygon3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYGON)
CalcMinMax(arc: Arc3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Arc3D given in parameter arc.
Parameters:
-
arc
(Arc3D
) –Arc3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYGON)
CalcMinMax(polyhedron: Polyhedron3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Polyhedron3D given in parameter polyhedron.
Parameters:
-
polyhedron
(Polyhedron3D
) –Polyhedron3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYGON)
CalcMinMax(cuboid: Cuboid3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Cuboid3D given in parameter cuboid.
Parameters:
-
cuboid
(Cuboid3D
) –Cuboid3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_CUBOID)
CalcMinMax(cylinder: Cylinder3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Cylinder3D given in parameter cylinder.
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_CYLINDER)
CalcMinMax(cone: Cone3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Cone3D given in parameter cylinder.
Parameters:
-
cone
(Cone3D
) –Cone3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_CONE)
CalcMinMax(ellipsoid: Ellipsoid3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the Ellipsoid3D given in parameter ellpsoid.
Parameters:
-
ellipsoid
(Ellipsoid3D
) –Ellipsoid3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_ELLIPSOID)
CalcMinMax(area: PolygonalArea3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the PolygonalArea3D given in parameter area.
Parameters:
-
area
(PolygonalArea3D
) –PolygonalArea3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYHEDRON)
CalcMinMax(solid: ExtrudedAreaSolid3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the ExtrudedAreaSolid3D given in parameter solid.
Parameters:
-
solid
(ExtrudedAreaSolid3D
) –ExtrudedAreaSolid3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYHEDRON)
CalcMinMax(solid: ClippedSweptSolid3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume by the ClippedSweptSolid3D given in parameter solid.
Parameters:
-
solid
(ClippedSweptSolid3D
) –ClippedSweptSolid3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_POLYHEDRON)
CalcMinMax(geo: Path3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D-Min- and Max Point of an element.
Calculates the MinMax3D volume for the Path3D element.
Parameters:
-
geo
(Path3D
) –Path3D to be calculated
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(MinMax3D, NO_ERR, INVALID_SURFACE)
CalcMinMax(geo: BRep3D) -> tuple[MinMax3D, eServiceResult]
Calculate 3D minmax of the B-rep body
Parameters:
-
geo
(BRep3D
) –BRep3D geometry
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(calculated MinMax3D, result code)
CalcProjectedMinMax
CalcProjectedMinMax(
geo: BRep3D, matrix: Matrix3D
) -> tuple[MinMax3D, eServiceResult]
Calculate minmax of brep in given projection
Parameters:
Returns:
-
tuple[MinMax3D, eServiceResult]
–tuple(minmax 3D, NO_ERR if successful)
CalcSurface
CalcVolume
CalculateNormal
CalculateSplineLengthToPoint
CalculateSplineLengthToPoint(spline: Spline2D, splinePointIndex: int) -> float
Calculate spline length from spline start to defined spline point.
This function returns correct result even if the various points of the spline
have the same coordinates ( PointLocal(.....) function fails in that case ).
Parameters:
-
spline
(Spline2D
) –2D Spline
-
splinePointIndex
(int
) –Spline point index
Returns:
-
float
–Length if everything is OK. -1.0 in case of error.
Clipping
Clipping(el1: Line2D, el2: MinMax2D) -> eBoolOpResult
test 2D line and minmax box for clipping
Parameters:
Returns:
-
eBoolOpResult
–eInside (line inside the box), eOutside (line outside the box), eClip
Colliding
overloaded
Convert3DRotation
Convert a 3D Rotation to series of 2D operations: scale, rotation, scale, rotation.
Parameters:
Returns:
ConvertTo2D
overloaded
ConvertTo2D(polyline3D: Polyline3D) -> tuple[bool, Polyline2D]
Converts Polyline3D to Polyline2D
Parameters:
-
polyline3D
(Polyline3D
) –Polyline3D to convert
Returns:
-
tuple[bool, Polyline2D]
–tuple(polyline2D is valid: true/false, Converted Polyline3D)
ConvertTo2D(points3D: Point3DList) -> tuple[bool, list[Point2D]]
Converts vector of Point3D to vector of Point2D
Parameters:
-
points3D
(Point3DList
) –points to convert
Returns:
Converts geometry to 2D geometry
Currently works on Line3D, Polyline3D, Axis3D, Arc3D, Point3D and Polygon3D. 2D geometries are cloned without modification.
Parameters:
-
geo_object
(object
) –geometry to convert
Returns:
-
object
–nullptr if conversion is not possible, otherwise converted geometry
ConvertTo3D
overloaded
ConvertTo3D(
polyline2D: Polyline2D, zPlane: float = 0
) -> tuple[bool, Polyline3D]
Converts Polyline2D to Polyline3D
Parameters:
-
polyline2D
(Polyline2D
) –Polyline2D to convert
-
zPlane
(float
, default:0
) –Z value
Returns:
-
tuple[bool, Polyline3D]
–tuple(polyline3D is valid: true/false, Converted Polyline2D)
ConvertTo3D(
points2D: Point2DList, zPlane: float = 0
) -> tuple[bool, list[Point3D]]
Convert vector of 2D points to a vector of 3D points
Parameters:
-
points2D
(Point2DList
) –vector of 2D points
-
zPlane
(float
, default:0
) –Z coordinate to be set by conversion
Returns:
ConvertTo3D(
clothoid2D: Clothoid2D, zPlane: float = 0
) -> tuple[bool, BSpline3D]
Convert 2D clothoid to a 3D bspline
Parameters:
-
clothoid2D
(Clothoid2D
) –2D clothoid
-
zPlane
(float
, default:0
) –Z coordinate to be set by conversion
Returns:
ConvertToBSpline2D
overloaded
CreateBRep3D
overloaded
CreateBRep3D(polyhedron: Polyhedron3D) -> tuple
Create BRep3D by converting a polyhedron
Parameters:
-
polyhedron
(Polyhedron3D
) –polyhedron to convert
Returns:
-
tuple
–error code,
BRep3D to create
CreateFrustumOfPyramid
CreateLoftedBRep3D
CreateLoftedBRep3D(
outerProfiles: Curve3DList,
innerProfiles: Curve3DList,
closecaps: bool,
createprofileedges: bool,
linear: bool,
periodic: bool,
) -> tuple
Create BRep3D by means of lofting through a set of profiles (incl. hole)
Parameters:
-
outerProfiles
(Curve3DList
) –outer profiles to loft
-
innerProfiles
(Curve3DList
) –inner profiles to loft (represents hole in outer profile)
-
closecaps
(bool
) –close brep if possible (all profiles are closed)
-
createprofileedges
(bool
) –create profile edges and more surfaces or just create one surface
-
linear
(bool
) –linear or cubic interpolation
-
periodic
(bool
) –if the start profile is also to be the end profile
Returns:
-
tuple
–tuple(error code, result BRep3D)
CreatePatchBRep3D
CreatePatchBRep3D(curves: list) -> tuple[eCreatePatchResult, BRep3DList]
Create breps as patch from given closed 3D-curves
Parameters:
-
curves
(list
) –list of 3D-curves
Returns:
-
tuple[eCreatePatchResult, BRep3DList]
–tuple(Result of patch creation, created BReps)
CreatePlanarBRep3D
overloaded
CreatePlanarBRep3D(
icurve: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
) -> tuple
CreatePlanarBRep3D(profiles: Curve3DList) -> tuple
Create brep as planar surface
Parameters:
-
profiles
(Curve3DList
) –border of planar surface ( must be closed )
Returns:
-
tuple
–tuple(error code, resulting BRep3D ( one planar face ))
CreatePlanarSurface
CreatePlanarSurface(geometries: list) -> tuple[ePlanarSurfaceError, BRep3DList]
create planar brep
Parameters:
-
geometries
(list
) –input geometries pointers
Returns:
-
tuple[ePlanarSurfaceError, BRep3DList]
–tuple(surface error code, planar surfaces)
CreatePolygon3D
overloaded
CreatePolygon3D(polyhedron: Polyhedron3D, faceIndex: int) -> tuple
Creates a Polygon3D element from a Polyhedron face
Parameters:
-
polyhedron
(Polyhedron3D
) –Polyhedron to get face from
-
faceIndex
(int
) –Index of the face in polyhedron
Returns:
CreatePolygon3D(polyline: Polyline3D) -> tuple
CreatePolygon3DFromIndex
Create a 3D polygon from a start and end polygon, an index and a division count
CreatePolyhedron
overloaded
CreatePolyhedron(
polyhedronType: PolyhedronType,
verticesCount: int,
edgeCount: int,
faceCount: int,
negativeOrientation: bool,
) -> tuple
Create and initialize new Polyhedron3D
Parameters:
-
polyhedronType
(PolyhedronType
) –Polyhedron type - edges, faces or volume.
-
verticesCount
(int
) –Count of expected vertices.
-
edgeCount
(int
) –Count of expected edges.
-
faceCount
(int
) –Count of expected faces.
-
negativeOrientation
(bool
) –True for negative orientation.
Returns:
CreatePolyhedron(solid: ClippedSweptSolid3D) -> tuple
Create polyhedron from input parametric solid
Parameters:
-
solid
(ClippedSweptSolid3D
) –clipped swept solid
Returns:
CreatePolyhedron(solid: ExtrudedAreaSolid3D) -> tuple
Create polyhedron from input parametric solid
Parameters:
-
solid
(ExtrudedAreaSolid3D
) –extruded area solid
Returns:
CreatePolyhedron(cylinder: Cylinder3D, countOfSegments: int) -> tuple
Create polyhedron from input Cylinder
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder to convert
-
countOfSegments
(int
) –Count of segments
Returns:
CreatePolyhedron(igeo: object, options: ApproximationSettings) -> tuple
Create polyhedron from arbitrary solid
Parameters:
-
geoObject
–Geometry object
-
options
(ApproximationSettings
) –ApproximationSettings structure holding options for approximation
Returns:
CreatePolyhedron(brep: BRep3D, options: ApproximationSettings) -> tuple
Create polyhedron as approximation of arbitrary BRep3D
Parameters:
-
brep
(BRep3D
) –arbitrary BRep3D
-
options
(ApproximationSettings
) –approximation settings
Returns:
CreatePolyhedron(lines: Line3DList) -> tuple
CreatePolyhedron(polyline: Polyline3D) -> tuple
Create polyhedron from Polyline3D
Parameters:
-
polyline
(Polyline3D
) –Reference to Polyline3D
Returns:
CreatePolyhedron(base: Polygon3D, path: Polyline3D) -> tuple
Create translation polyhedron from base polygon and path
Parameters:
-
base
(Polygon3D
) –base polygon
-
path
(Polyline3D
) –translation path
Returns:
CreatePolyhedron(base: Polygon2D, refPoint: Point2D, path: Polyline3D) -> tuple
Create translation polyhedron from base polygon and path
Parameters:
-
base
(Polygon2D
) –base polygon 2D
-
refPoint
(Point2D
) –reference point used for transformation
-
path
(Polyline3D
) –translation path
Returns:
CreatePolyhedron(
baseOutline: Polygon2D,
leftOffset: float,
rightOffset: float,
frontOffset: float,
backOffset: float,
bottomPlane: Plane3D,
topPlane: Plane3D,
) -> tuple
Create conical polyhedron from 2D polygon, given offsets, bottom and top plane
Parameters:
-
baseOutline
(Polygon2D
) –base outline polygon 2D (rectangle of 4 points)
-
leftOffset
(float
) –offset from base outline on the left side
-
rightOffset
(float
) –offset from base outline on the right side
-
frontOffset
(float
) –offset from base outline on the front side
-
backOffset
(float
) –offset from base outline on the back side
-
bottomPlane
(Plane3D
) –element's bottom plane
-
topPlane
(Plane3D
) –element's top plane
Returns:
CreatePolyline3D
overloaded
CreatePolyline3D(polyhedron: Polyhedron3D) -> tuple
Creates a Polyline3D element from a Polyhedron
Parameters:
-
polyhedron
(Polyhedron3D
) –Polyhedron to create line from
Returns:
-
tuple
–eOK if converted successful, else eError,
Created Polyline
CreatePolyline3D(polyline2D: Polyline2D) -> tuple
Create Polyline3D from Polyline2D
Parameters:
-
polyline2D
(Polyline2D
) –Reference to Polyline2D
Returns:
-
tuple
–eOK if created successful, else eError,
Reference to empty Polyline3D
CreatePolyline3DFromIndex
CreatePolyline3DFromIndex(
startPol: Polyline3D, endPol: Polyline3D, index: int, count: int
) -> Polyline3D
Create a 3D polyline from a start and end polyline, an index and a division count Args: startPol: Start polyline endPol: End polyline index: Division index count: Division count
Returns:
-
Polyline3D
–eOK if converted successful, else eError,
Created Polyline
CreateRailSweptBRep3D
overloaded
CreateRailSweptBRep3D(
profiles: Curve3DList,
rails: Curve3DList,
closecaps: bool,
uniformScaling: bool,
railrotation: bool,
) -> tuple
Create BRep3D by rail sweeping of profiles. Rails must start/ends on profiles start/end points
Parameters:
-
profiles
(Curve3DList
) –profiles to sweep
-
rails
(Curve3DList
) –rails to control sweeping
-
closecaps
(bool
) –if true, create closed solid if possible, if false just surface(s) will be created
-
uniformScaling
(bool
) –use uniform scaling for profiles along the rails
-
railrotation
(bool
) –use rotation the shape to maintain a constant angle with the rail
Returns:
-
tuple
–tuple(error code, result BRep3D (1 swept face))
CreateRailSweptBRep3D(
profiles: Curve3DList,
rails: Curve3DList,
path: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
closecaps: bool,
uniformScaling: bool,
railrotation: bool,
proportionalVertexMatch: bool,
) -> tuple
Create BRep3D by rail sweeping of profiles. Rails must start/ends on profiles start/end points
Parameters:
-
profiles
(Curve3DList
) –profiles to sweep
-
rails
(Curve3DList
) –rails to control sweeping
-
path
(Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
) –user defined path
-
closecaps
(bool
) –if true, create closed solid if possible, if false just surface(s) will be created
-
uniformScaling
(bool
) –use uniform scaling for profiles along the rails
-
railrotation
(bool
) –use rotation the shape to maintain a constant angle with the rail
-
proportionalVertexMatch
(bool
) –Flag whether to use proportional vertex matching
Returns:
-
tuple
–tuple(error code, result BRep3D (1 swept face), path for body creation)
CreateRevolvedBRep3D
CreateRevolvedBRep3D(
profiles: Curve3DList,
axis: Axis3D,
rotationAngle: Angle,
closecaps: bool,
numprofiles: int,
) -> tuple
Create brep as revolved body.
Parameters:
-
profiles
(Curve3DList
) –list of profile curves
-
axis
(Axis3D
) –axis of rotation
-
rotationAngle
(Angle
) –angle of rotation
-
closecaps
(bool
) –if true, create closed solid if possible, if false just surface(s) will be created
-
numprofiles
(int
) –number of control profiles created along the created surfaces (division of surface parameter)
Returns:
-
tuple
–tuple(error code, created brep)
CreateSweptBRep3D
overloaded
CreateSweptBRep3D(
profile: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
path: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
railrotation: bool,
rotAxis: Vector3D | None = None,
) -> tuple
Create BRep3D by means of a profile extrusion along a path
Parameters:
-
profile
(Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
) –profile to extrude, if closed solid will be created, otherwise a surface only
-
path
(Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
) –path to extrude along
-
railrotation
(bool
) –if true, rotate profile along the path
-
rotAxis
(Vector3D | None
, default:None
) –if set, profile will be rotated along this axis along the path
Returns:
-
tuple
–tuple(error code, result BRep3D)
CreateSweptBRep3D(
profiles: Curve3DList,
path: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
closecaps: bool,
railrotation: SweepRotationType,
rotAxis: Vector3D | None = None,
numprofiles: int = 0,
) -> tuple
Create BRep3D by means of a vector of profiles extrusion along a path
Parameters:
-
profiles
(Curve3DList
) –profiles to extrude, if closed solid will be created, otherwise a surface only
-
path
(Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
) –path to extrude along
-
closecaps
(bool
) –if true, create closed solid if possible, if false just surface(s) will be created
-
railrotation
(SweepRotationType
) –if true, rotate profile along the path
-
rotAxis
(Vector3D | None
, default:None
) –if set, profile will be rotated along this axis along the path
-
numprofiles
(int
, default:0
) –number of control profiles created along the created surfaces (divisionn of surface parameter)
Returns:
-
tuple
–tuple(error code, result BRep3D)
CreateSweptBRep3D(
profiles: list,
path_object: object,
closecaps: bool,
railrotation: bool,
rotAxis: Vector3D | None = None,
numprofiles: int = 0,
) -> tuple[eGeometryErrorCode, BRep3D]
Create BRep3D by means of a vector of profiles extrusion along a path
Parameters:
-
profiles
(list
) –profiles to extrude, if closed solid will be created, otherwise a surface only
-
path_object
(object
) –path to extrude along
-
closecaps
(bool
) –if true, create closed solid if possible, if false just surface(s) will be created
-
railrotation
(bool
) –if true, rotate profile along the path
-
rotAxis
(Vector3D | None
, default:None
) –if set, profile will be rotated along this axis along the path
-
numprofiles
(int
, default:0
) –number of control profiles created along the created surfaces (divisionn of surface parameter)
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result BRep3D)
CreateSweptPolyhedron3D
CreateSweptPolyhedron3D(
profiles: Polyline3DList,
path: Polyline3D,
closecaps: bool,
railrotation: bool,
rotAxis: Vector3D,
) -> tuple
Create translation polyhedron from base polygon and path
Parameters:
-
profiles
(Polyline3DList
) –profiles to sweep
-
path
(Polyline3D
) –translation path
-
closecaps
(bool
) –create closed volume (in case of closed profiles) or open shell only
-
railrotation
(bool
) –rotate profiles along path - standard rotation = true (keep angle between profile and a path), rotation along z-axis vector = false
-
rotAxis
(Vector3D
) –if set, profile will be rotated along this axis along the path
Returns:
CutBrepWithPlane
Cut Brep with plane - create two independent BReps
Parameters:
Returns:
CutPolyhedronWithPlane
CutPolyhedronWithPlane(
original: Polyhedron3D, plane: Plane3D
) -> tuple[bool, Polyhedron3D, Polyhedron3D]
Cut polyhedron with plane - create two independent polyhedra
Parameters:
-
original
(Polyhedron3D
) –original polyhedron
-
plane
(Plane3D
) –cutting plane
Returns:
-
tuple[bool, Polyhedron3D, Polyhedron3D]
–tuple(true if there is a cut, otherwise false, one of polyhedron above/below is filled when whole body is above/below the plane, result polyhedron above the plane, result polyhedron below the plane)
DeletePolyhedronLastFace
DeletePolyhedronLastFace(polyhedron: Polyhedron3D) -> eGeometryErrorCode
Delete the last face of given polyhedron
Parameters:
-
polyhedron
(Polyhedron3D
) –Polyhedron3D
Returns:
-
eGeometryErrorCode
–Error code
FaceShell
FaceShell(
inputBrep: BRep3D,
distance: float,
direction: int,
faceIndices: VecSizeTList,
useOffsetStepPierce: bool,
useOrthoVXSplit: bool,
punchDirection: Vector3D,
) -> tuple[eGeometryErrorCode, BRep3D]
Execute face shell
Parameters:
-
inputBrep
(BRep3D
) –inputBrep
-
distance
(float
) –distance for offset
-
direction
(int
) –offset direction 0 - in face normal direction, 1 - in both directions, 2 - opposite to face normal
-
faceIndices
(VecSizeTList
) –face indexes
-
useOffsetStepPierce
(bool
) –if to use offset step pierce
-
useOrthoVXSplit
(bool
) –if to use OrthoVXSplit option
-
punchDirection
(Vector3D
) –defined direction for shell (optional)
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(eOK if success, resulting shell BRep)
FindMinDistancePoint
overloaded
GetAbsoluteTolerance
get absolute tolerance
Returns:
-
float
–absolute tolerance
GetAllIntersections
GetAllIntersections(
geoObject1: object, geoObject2: object, eps: float, maxSolutions: int
) -> tuple
Calculate all intersections of two geometry objects Intersection point must not be located on the elements, it can be outside
Parameters:
-
geoObject1
(object
) –First object
-
geoObject2
(object
) –Second object
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
GetAngleTolerance
GetAngleTolerance() -> Angle
Get angle tolerance
This tolerance is using for angle comparison. Use it with Comparison::Equal(value, value, GetAngleTolerance())
Returns:
-
Angle
–Tolerance using for angle comparison [rad]
GetClosestIntersection
GetClosestIntersection(
geometrie1: object,
geometrie2: object,
inputPoint: Point3D,
eps: float,
bOnlyInsidePoints: bool,
) -> tuple
Function to calculate the nearest intersection between two geometries to a reference point Intersection point must not be located on the elements, it can be outside
Parameters:
-
geometrie1
(object
) –First object
-
geometrie2
(object
) –Second object
-
inputPoint
(Point3D
) –Reference Point / Cursor point
-
eps
(float
) –Tolerance
-
bOnlyInsidePoints
(bool
) –Return point must be on both objects
Returns:
GetCurvatureTolerance
Get curvature tolerance
This tolerance is using for curvature comparison. Use it with Comparison::Equal(value, value, GetCurvatureTolerance())
Returns:
-
float
–Tolerance using for curvature comparison
GetCurveLengthTolerance
Get tolerance for curve length comparison
This tolerance is using for length of curve comparison. Use it with Comparison::Equal(value, value, GetCurveLengthTolerance())
Returns:
-
float
–Tolerance using for length of curve comparison [mm]
GetIntersectionPoints
GetIntersectionPoints(
geoObject1: object, geoObject2: object, eps: float
) -> tuple
Function to calculate the nearest intersection between two geometries to a reference point Intersection point must not be located on the elements, it can be outside
Parameters:
-
geoObject1
(object
) –First object
-
geoObject2
(object
) –Second object
-
eps
(float
) –Tolerance (optional)
Returns:
GetRelativeTolerance
get relative tolerance
Returns:
-
float
–relative tolerance
GetRotationMatrix
overloaded
GroundViewHiddenCalculation
overloaded
GroundViewHiddenCalculation(
brep: BRep3D,
) -> tuple[eGeometryErrorCode, list[typingAny], list[typingAny]]
Hidden calculation with ground view of BRep
Parameters:
-
brep
(BRep3D
) –BRep
Returns:
-
tuple[eGeometryErrorCode, list[typingAny], list[typingAny]]
–tuple(Error code, Vector of visible edges, Vector of hidden edges)
GroundViewHiddenCalculation(
poly: Polyhedron3D,
) -> tuple[eGeometryErrorCode, list[Line3D], list[Line3D]]
Hidden calculation with ground view of polyhedron.
Parameters:
-
poly
(Polyhedron3D
) –polyhedron
Returns:
-
tuple[eGeometryErrorCode, list[Line3D], list[Line3D]]
–tuple(Error code, Vector of visible edges, Vector of hidden edges)
ImprintProfileOnFaces
ImprintProfileOnFaces(
brep: BRep3D,
targetFaces: list[int] | VecUIntList,
profile: (
Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
),
) -> tuple
Imprint edges on brep
Parameters:
-
brep
(BRep3D
) –Brep
-
targetFaces
(list[int] | VecUIntList
) –faces where to imprint edges
-
profile
(Arc3D | BSpline3D | Line3D | Path3D | Polyline3D | Polygon3D | Spline3D
) –imprinted profile
Returns:
-
tuple
–tuple(eOK if successful otherwise eError, Brep, new faces after imprint)
Intersect
overloaded
Intersect(bodies1: PolyhedronTypesList, bodies2: PolyhedronTypesList) -> tuple
compute intersection of set of bodies
Parameters:
-
bodies1
(PolyhedronTypesList
) –list of bodies
-
bodies2
(PolyhedronTypesList
) –list of bodies
Returns:
-
tuple
–tuple(true when intersecting, otherwise false., resulted polyhedron)
Intersect(el1: Polyhedron3D, el2: Polyhedron3D) -> tuple[bool, Polyhedron3D]
compute intersection of 2 3D polyhedron
Parameters:
-
el1
(Polyhedron3D
) –- element
-
el2
(Polyhedron3D
) –- element
Returns:
-
tuple[bool, Polyhedron3D]
–tuple(true when intersecting, otherwise false., resulted polyhedron)
Intersect(brep1: BRep3D, brep2: BRep3D) -> tuple[eGeometryErrorCode, BRep3D]
Compute intersection of 2 breps
Parameters:
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(true when intersecting, otherwise false., result brep of intersection)
Intersect(
brep: BRep3D, polyhedron: Polyhedron3D
) -> tuple[eGeometryErrorCode, BRep3D]
Compute intersection of 2 bodies
Parameters:
-
brep
(BRep3D
) –first element - BRep3D
-
polyhedron
(Polyhedron3D
) –second element - Polyhedron3D
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result BRep3D)
IntersectRayBRep
IntersectRayBRep(
rayPoint: Point3D, rayVector: Vector3D, brep: BRep3D, bNegativPrefered: bool
) -> tuple[int, IntersectionRayBRep]
Intersection of Ray and BRep
Parameters:
-
rayPoint
(Point3D
) –ray Point
-
rayVector
(Vector3D
) –direction vector of ray
-
brep
(BRep3D
) –BRep
-
bNegativPrefered
(bool
) –if true -> return first solution when ray point is out of object
Returns:
-
tuple[int, IntersectionRayBRep]
–tuple(0 if no error occurs, structure with result of intersection)
IntersectRayPolyhedron
IntersectRayPolyhedron(
rayPoint: Point3D,
rayVector: Vector3D,
polyhedron: Polyhedron3D,
flag: IntersectRayPolyhedronFlag,
selFaces: list[int] | VecIntList | None = None,
searchDistance: float = 0.0,
pixelSize: float = 0,
) -> tuple[int, IntersectionRayPolyhedron]
Intersection of Ray and Polyhedron
Parameters:
-
rayPoint
(Point3D
) –ray Point
-
rayVector
(Vector3D
) –direction vector of ray
-
polyhedron
(Polyhedron3D
) –polyhedron
-
flag
(IntersectRayPolyhedronFlag
) –flag for determining the "best" intersection
-
selFaces
(list[int] | VecIntList | None
, default:None
) –optional list of faces used for intersection, if default value is used, all faces are checked
-
searchDistance
(float
, default:0.0
) –used for eNegativeVerticalPreferred to find vertical faces near point found on not-vertical face
-
pixelSize
(float
, default:0
) –in mm used for eNegativeVerticalPreferred to find vertical faces
Returns:
-
tuple[int, IntersectionRayPolyhedron]
–tuple(0 if no error occurred, structure with result of intersection)
Intersecting
overloaded
Intersecting(el1: BRep3D, el2: Polyhedron3D) -> bool
test brep and polyhedron for intersection
Parameters:
-
el1
(BRep3D
) –brep to check
-
el2
(Polyhedron3D
) –polyhedron to check
Returns:
-
bool
–bool true when intersecting
Intersecting(el1: Arc3D, el2: Polyhedron3D) -> bool
test 3D arc and polyhedron for intersection
Parameters:
-
el1
(Arc3D
) –arc to check
-
el2
(Polyhedron3D
) –polyhedron to check
Returns:
-
bool
–bool true when intersecting
Intersecting(el1: Spline3D, el2: Polyhedron3D) -> bool
test 3D spline and polyhedron for intersection
Parameters:
-
el1
(Spline3D
) –spline to check
-
el2
(Polyhedron3D
) –polyhedron to check
Returns:
-
bool
–bool true when intersecting
Intersecting(el1: BSpline3D, el2: Polyhedron3D) -> bool
test 3D bspline and polyhedron for intersection
Parameters:
-
el1
(BSpline3D
) –bspline to check
-
el2
(Polyhedron3D
) –polyhedron to check
Returns:
-
bool
–bool true when intersecting
IntersectingRel
overloaded
IntersectionCalculus
overloaded
Calculate the intersection between a 2D axis and a 2D arc
emarks There are known precision issues with the background function lksplk
Args:
axis2D: 2D Axis
arc2D: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(axis2D: Axis2D, polyline: Polyline2D) -> tuple
Calculate the intersection between a 2D axis and a 2D polyline
Parameters:
-
axis2D
(Axis2D
) –2D Axis
-
polyline
(Polyline2D
) –2D Polyline
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D axis and a 2D spline
Parameters:
-
axis2D
(Axis2D
) –2D Axis
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D axis and a 2D bspline
Parameters:
-
axis2D
(Axis2D
) –2D Axis
-
bspline
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D axis and a 2D arc
emarks There are known precision issues with the background function lksplk
Args:
axis: 3D Axis
arc: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(axis: Axis3D, polyline: Polyline2D) -> tuple
Calculate the intersection between a 3D axis and a 2D polyline
Parameters:
-
axis
(Axis3D
) –3D Axis
-
polyline
(Polyline2D
) –2D Polyline
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D axis and a 2D spline
Parameters:
-
axis
(Axis3D
) –3D Axis
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D axis and a 3D spline
Parameters:
-
axis
(Axis3D
) –3D Axis
-
spline
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D axis and a 3D B-spline
Parameters:
-
axis
(Axis3D
) –3D Axis
-
spline
(BSpline3D
) –3D B-Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D line and a 2D arc
emarks There are known precision issues with the background function lksplk
Args:
line2D: 2D Line
arc2D: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(line2D: Line2D, polyline: Polyline2D) -> tuple
Calculate the intersection between a 2D line and a 2D polyline
Parameters:
-
line2D
(Line2D
) –2D Line
-
polyline
(Polyline2D
) –2D Polyline
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D line and a 2D bspline
Parameters:
-
line
(Line2D
) –2D Line
-
bspline
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D line and a 2D spline
Parameters:
-
line2D
(Line2D
) –2D Line
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D line and a 2D arc
emarks There are known precision issues with the background function lksplk
Args:
line: 3D Line
arc: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(line: Line3D, polyline: Polyline2D) -> tuple
Calculate the intersection between a 3D line and a 2D polyline
Parameters:
-
line
(Line3D
) –3D Line
-
polyline
(Polyline2D
) –2D Polyline
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D line and a 2D spline
Parameters:
-
line
(Line3D
) –3D Line
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D line and a 3D spline
Parameters:
-
line
(Line3D
) –3D Line
-
spline
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D line and a 3D bspline
Parameters:
-
line
(Line3D
) –3D Line
-
bspline
(BSpline3D
) –3D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(arc: Arc2D, polyline: Polyline2D, eps: float) -> tuple
Calculate the intersection between a 2D arc and a 2D polyline
emarks There are known precision issues with the background function lksplk
Args:
arc: 2D Arc
polyline: 2D Polyline
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
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
Calculate the intersection between a 2D arc and a 2D spline
Parameters:
-
arc
(Arc2D
) –2D Arc
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 2D arc and a 2D spline
Parameters:
-
arc
(Arc2D
) –2D Arc
-
bspline
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D arc and a 3D B-spline
Parameters:
-
arc
(Arc3D
) –First 3D Arc
-
arc2
(Arc3D
) –Second 3D Arc
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D arc and a 3D spline
Parameters:
-
arc
(Arc3D
) –3D Arc
-
spline
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between a 3D arc and a 3D B-spline
Parameters:
-
arc
(Arc3D
) –3D Arc
-
bspline
(BSpline3D
) –3D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(polyline1: Polyline2D, polyline2: Polyline2D) -> tuple
Calculate the intersection between two polylines
Parameters:
-
polyline1
(Polyline2D
) –2D polyline
-
polyline2
(Polyline2D
) –2D polyline
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(polyline: Polyline2D, polygon: Polygon2D) -> tuple
Calculate the intersection between polyline and polygon
Parameters:
-
polyline
(Polyline2D
) –2D polyline
-
polygon
(Polygon2D
) –2D polygon
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
polyline: Polyline2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D polyline and a 2D spline
Parameters:
-
polyline
(Polyline2D
) –First 2D polyline
-
spline
(Spline2D
) –Second 2D spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
polyline: Polyline2D, spline: BSpline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D polyline and a 2D bspline
Parameters:
-
polyline
(Polyline2D
) –2D Polyline
-
spline
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
polyline: Polyline3D, spline: BSpline3D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 3D polyline and a 3D bspline
Parameters:
-
polyline
(Polyline3D
) –3D Polyline
-
spline
(BSpline3D
) –3D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
polygon: Polygon2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D polygon and a 2D spline
Parameters:
-
polygon
(Polygon2D
) –First 2D polygon
-
spline
(Spline2D
) –Second 2D spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(plane: Plane3D, line: Polyline3D, eps: float) -> tuple
Calculate the intersection between 3D plane and 3D polyline
Parameters:
-
plane
(Plane3D
) –3D plane
-
line
(Polyline3D
) –3D polyline
-
eps
(float
) –Tolerance
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
Calculate the intersection between 3D plane and 3D arc
Parameters:
-
plane
(Plane3D
) –3D plane
-
spline
(Spline3D
) –3D spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: Spline2D, spline2: Spline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between two 2D splines
Parameters:
-
spline1
(Spline2D
) –First 2D spline
-
spline2
(Spline2D
) –Second 2D spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: Spline2D, spline2: Spline3D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between 2D spline and 3D spline
ote 2D spline is converted to 3D spline and calculation between 3D splines is called
Parameters:
-
spline1
(Spline2D
) –First 2D spline
-
spline2
(Spline3D
) –Second 3D spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: Spline3D, spline2: Spline3D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 3D Spline and a 3D Spline
Parameters:
-
spline1
(Spline3D
) –3D Spline
-
spline2
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: Spline2D, spline2: BSpline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D Spline and a 2D BSpline
Parameters:
-
spline1
(Spline2D
) –2D Spline
-
spline2
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: Spline3D, spline2: BSpline3D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 3D BSpline and a 3D Spline
Parameters:
-
spline1
(Spline3D
) –3D Spline
-
spline2
(BSpline3D
) –3D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: BSpline2D, spline2: BSpline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D BSpline and a 2D BSpline
Parameters:
-
spline1
(BSpline2D
) –2D BSpline
-
spline2
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
spline1: BSpline3D, spline2: BSpline3D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 3D BSpline and a 3D BSpline
Parameters:
-
spline1
(BSpline3D
) –3D BSpline
-
spline2
(BSpline3D
) –3D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
-
tuple
–true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculus(
ele1: object, ele2: object, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 3D axis and a 3D spline
Parameters:
-
ele1
(object
) –First element
-
ele2
(object
) –Second element
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution
Returns:
IntersectionCalculusEx
overloaded
Calculate the intersection between a 2D axis and a 2D arc Intersection point must not be located on the elements, it can be outside
emarks There are known precision issues with the background function lksplk
Args:
axis2D: 2D Axis
arc2D: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculusEx(axis2D: Axis2D, polyline: Polyline2D) -> tuple
Calculate the intersection between a 2D axis and a 2D polyline Intersection point must not be located on the elements, it can be outside
Parameters:
-
axis2D
(Axis2D
) –2D Axis
-
polyline
(Polyline2D
) –2D Polyline
Returns:
Calculate the intersection between a 2D axis and a 2D polygon Intersection point must not be located on the elements, it can be outside
Parameters:
Returns:
IntersectionCalculusEx(
axis2D: Axis2D, clothoid2D: Clothoid2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a 2D axis and a 2D clothoid Intersection point must not be located on the elements, it can be outside
Parameters:
-
axis2D
(Axis2D
) –2D axis
-
clothoid2D
(Clothoid2D
) –2D Clothoid
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
Calculate the intersection between a 3D axis and a 2D arc Intersection point must not be located on the elements, it can be outside
emarks There are known precision issues with the background function lksplk
Args:
axis: 3D Axis
arc: 2D Arc
eps: precision
Returns:
true, if an intersection was found, otherwise false,
Vector which includes all resulting intersection points
IntersectionCalculusEx(axis: Axis3D, polyline