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: Polyline2D) -> tuple
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:
-
axis
(Axis3D
) –3D Axis
-
polyline
(Polyline2D
) –2D Polyline
Returns:
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:
Returns:
Calculate the intersection between two 2D lines. Intersection point must not be located on the elements, it can be outside
Parameters:
Returns:
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: Line2D, clothoid2D: Clothoid2D, eps: float, maxSolutions: int
) -> tuple
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:
-
line2D
(Line2D
) –2D Line
-
clothoid2D
(Clothoid2D
) –2D Clothoid
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
IntersectionCalculusEx(line2D: Line2D, polyline: Polyline2D) -> tuple
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:
-
line2D
(Line2D
) –2D Line
-
polyline
(Polyline2D
) –2D Polyline
Returns:
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:
Returns:
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:
-
line2D
(Line2D
) –2D Line
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
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:
-
line2D
(Line2D
) –2D Line
-
spline
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
IntersectionCalculusEx(
line2D: Line2D, bspline: BSpline2D, eps: float, maxSolutions: int
) -> tuple
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:
-
line2D
(Line2D
) –2D Line
-
bspline
(BSpline2D
) –2D BSpline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
Calculate the intersection between two 3D line Intersection point must not be located on the elements, it can be outside
Parameters:
Returns:
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
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:
Returns:
IntersectionCalculusEx(
line: Line3D, clothoid: Clothoid2D, eps: float, maxSolutions: int
) -> tuple
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:
-
line
(Line3D
) –3D Line
-
clothoid
(Clothoid2D
) –2D Clothoid
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solutions (Defines the maximum size of the solution vector)
Returns:
IntersectionCalculusEx(line: Line3D, polyline: Polyline2D) -> tuple
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:
-
line
(Line3D
) –3D Line
-
polyline
(Polyline2D
) –2D Polyline
Returns:
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:
Returns:
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:
-
line
(Line3D
) –3D Line
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
Calculate the intersection between two arcs Intersection point must not be located on the elements, it can be outside
Parameters:
Returns:
IntersectionCalculusEx(
arc: Arc2D, clothoid: Clothoid2D, eps: float, maxSolutions: int
) -> tuple
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: Arc2D, polyline: Polyline2D, eps: float) -> tuple
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
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
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:
-
arc
(Arc2D
) –2D Arc
-
spline
(Spline2D
) –2D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
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:
-
arc
(Arc2D
) –2D Arc
-
spline
(Spline3D
) –3D Spline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
IntersectionCalculusEx(
clothoid: Clothoid2D, polyline: Polyline2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a clothoid and a polyline Intersection point must not be located on the elements, it can be outside
Parameters:
-
clothoid
(Clothoid2D
) –2D clothoid
-
polyline
(Polyline2D
) –2D polyline
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
IntersectionCalculusEx(
clothoid: Clothoid2D, polygon: Polygon2D, eps: float, maxSolutions: int
) -> tuple
Calculate the intersection between a clothoid and a 2D polygon Intersection point must not be located on the elements, it can be outside
Parameters:
-
clothoid
(Clothoid2D
) –2D clothoid
-
polygon
(Polygon2D
) –2D polygon
-
eps
(float
) –Tolerance
-
maxSolutions
(int
) –Maximum number of solution (especially for splines and clothoids)
Returns:
IntersectionCalculusEx(polyline1: Polyline2D, polyline2: Polyline2D) -> tuple
Calculate the intersection between two 2D polylines Intersection point must not be located on the elements, it can be outside
Parameters:
-
polyline1
(Polyline2D
) –2D polyline
-
polyline2
(Polyline2D
) –2D polyline
Returns:
Calculate the intersection between two 2D polygons Intersection point must not be located on the elements, it can be outside
Parameters:
Returns:
IntersectionCalculusEx(
polyline: Polyline2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple
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:
-
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:
IntersectionCalculusEx(
polygon: Polygon2D, spline: Spline2D, eps: float, maxSolutions: int
) -> tuple
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:
-
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:
IntersectionCalculusEx(
geoObject1: object,
geoObject2: object,
eps: float,
maxSolutions: int,
bOnlyInsidePoints: bool,
) -> tuple
Calculate intersections between two geometry objects Intersection points 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)
-
bOnlyInsidePoints
(bool
) –Intersection points must be on both objects
Returns:
IsCoplanar
overloaded
Check if two 3D curved geometry objects are coplanar and calculate plane
Parameters:
-
igeo1_object
(object
) –first object geometry
-
igeo2_object
(object
) –second object geometry
Returns:
IsCoplanar(plane: Plane3D, geo_object: object) -> bool
Find out if plane and geometry are coplanar
Parameters:
-
plane
(Plane3D
) –Plane3D
-
geo_object
(object
) –objects geometry
Returns:
-
bool
–True, if geometry is lying in the plane otherwise return false.
MakeBoolean
overloaded
MakeBoolean(
el1: Line2D, el2: Polygon2D
) -> tuple[eGeometryErrorCode, Line2DList, Line2DList]
make boolean operation between line and polygon
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Line2DList, Line2DList]
–tuple(GeoErrorCode, set of line segments which are inside input polygon, NULL if not desired, set of line segments which are outside input polygon, NULL if not desired)
MakeBoolean(
el1: Polygon2D, el2: Polygon2D
) -> tuple[eGeometryErrorCode, Polygon2D, Polygon2D, Polygon2D, Polygon2D]
make boolean operation between two 2D profile elements
Now it is done for Polygon2D, later with new Profile element.
Parameters:
Returns:
MakeBoolean(
el1: Polyhedron3D, el2: Polyhedron3D
) -> tuple[
eGeometryErrorCode, Polyhedron3D, Polyhedron3D, Polyhedron3D, Polyhedron3D
]
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:
-
el1
(Polyhedron3D
) –first element geometry
-
el2
(Polyhedron3D
) –second element geometry
Returns:
-
tuple[eGeometryErrorCode, Polyhedron3D, Polyhedron3D, Polyhedron3D, Polyhedron3D]
–tuple(GeoErrorCode, output 3D body of intersection, output 3D body of union, output 3D body of subtraction element1 minus element2, output 3D body of subtraction element2 minus element1)
MakeIntersection
overloaded
MakeIntersection(
brep1: BRep3D, breps: BRep3DList
) -> tuple[eGeometryErrorCode, BRep3D]
Compute intersection of 2 breps
Parameters:
-
brep1
(BRep3D
) –first brep
-
breps
(BRep3DList
) –second brep
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(eOK if intersection was successful, result brep of intersection)
MakeIntersection(brep: BRep3D, polyhedron: Polyhedron3D) -> tuple
Deprecated: use Intersect(...)
Parameters:
-
brep
(BRep3D
) –first element - BRep3D
-
polyhedron
(Polyhedron3D
) –second element - Polyhedron3D
Returns:
-
tuple
–error code,
result BRep3D
MakeIntersection(el1: Polyhedron3D, el2: Polyhedron3D) -> tuple
Deprecated: use Intersect(...)
Parameters:
-
el1
(Polyhedron3D
) –- element
-
el2
(Polyhedron3D
) –- element
Returns:
MakeSectionWithSurfaces
MakeSectionWithSurfaces(
brep1: BRep3D, brep2: BRep3D
) -> tuple[eGeometryErrorCode, BRep3DList]
Compute section of brep and surface brep
Parameters:
Returns:
-
tuple[eGeometryErrorCode, BRep3DList]
–tuple(error code, section resulting breps)
MakeSubtraction
overloaded
MakeSubtraction(
body: (
Polyhedron3D
| Cylinder3D
| ExtrudedAreaSolid3D
| Line3D
| Polyline3D
| Polygon3D
| ClippedSweptSolid3D
),
voidbodies: PolyhedronTypesList,
) -> tuple
make subtraction of 3D bodies from given body
Parameters:
-
body
(Polyhedron3D | Cylinder3D | ExtrudedAreaSolid3D | Line3D | Polyline3D | Polygon3D | ClippedSweptSolid3D
) –input body
-
voidbodies
(PolyhedronTypesList
) –list of 3D bodies to subtract
Returns:
-
tuple
–tuple(GeoErrorCode, output 3D body of subtraction)
MakeSubtraction(
poly1: Polygon2D, poly2: Polygon2D
) -> tuple[eGeometryErrorCode, Polygon2D, Polygon2D]
make subtraction of 2D polygons, if wished intersection is computed too.
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Polygon2D, Polygon2D]
–tuple(GeoErrorCode, output 2D polygon of subtraction, output 2D polygon of intersection)
MakeSubtraction(
polyhed1: Polyhedron3D, polyhed2: Polyhedron3D
) -> tuple[eGeometryErrorCode, Polyhedron3D]
make subtraction of polyhed1 - polyhed2
Parameters:
-
polyhed1
(Polyhedron3D
) –first polyhedron
-
polyhed2
(Polyhedron3D
) –second polyhedron
Returns:
-
tuple[eGeometryErrorCode, Polyhedron3D]
–tuple(GeoErrorCode, result 3D polyhedron of subtraction)
MakeSubtraction(
brep1: BRep3D, brep2: BRep3D
) -> tuple[eGeometryErrorCode, BRep3D]
Compute subtraction of 2 breps
Parameters:
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result brep of subtraction)
MakeSubtraction(
brep1: BRep3D, breps: BRep3DList
) -> tuple[eGeometryErrorCode, BRep3D]
Compute subtraction of brep and vector of breps
Parameters:
-
brep1
(BRep3D
) –first brep
-
breps
(BRep3DList
) –vector of brep to be subtracted from the first brep
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result brep of subtraction)
Deprecated: use MakeSubtraction(const Polygon2D& poly1, const Polygon2D& poly2)
make subtraction of 2D polygons, if wished intersection is computed too.
Parameters:
-
poly1
(Polygon2D
) –first polygon
-
poly2
(Polygon2D
) –second polygon
-
intersection
(Polygon2D
) –output 2D polygon of intersection, as input NULL if not required
Returns:
MakeUnion
overloaded
MakeUnion(
bodies: PolyhedronTypesList, voidbodies: PolyhedronTypesList
) -> tuple
make union of 3D bodies
As input arbitrary elements which represents 3D is possible.
Parameters:
-
bodies
(PolyhedronTypesList
) –list of 3D bodies
-
voidbodies
(PolyhedronTypesList
) –list of 3D bodies to subtract
Returns:
-
tuple
–tuple(GeoErrorCode, output 3D body of union)
MakeUnion(
poly1: Polygon2D, poly2: Polygon2D
) -> tuple[eGeometryErrorCode, Polygon2D]
make union of 2D polygons
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Polygon2D]
–tuple(GeoErrorCode, result 2D polygon of union)
MakeUnion(
polyhed1: Polyhedron3D, polyhed2: Polyhedron3D
) -> tuple[eGeometryErrorCode, Polyhedron3D]
make union of 3D polyhedrons
Parameters:
-
polyhed1
(Polyhedron3D
) –first polyhedron
-
polyhed2
(Polyhedron3D
) –second polyhedron
Returns:
-
tuple[eGeometryErrorCode, Polyhedron3D]
–tuple(GeoErrorCode, result 3D polyhedron of union)
MakeUnion(bodies: Polyhedron3DList) -> tuple[bool, Polyhedron3D]
Compute bulk union of more polyhedra at once
Parameters:
-
bodies
(Polyhedron3DList
) –polyhedra to unite
Returns:
-
tuple[bool, Polyhedron3D]
–if success result polyhedron otherwise nullopt
MakeUnion(brep1: BRep3D, brep2: BRep3D) -> tuple[eGeometryErrorCode, BRep3D]
Compute union of 2 breps
Parameters:
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result brep of union)
MakeUnion(
brep1: BRep3D, breps: BRep3DList
) -> tuple[eGeometryErrorCode, BRep3D]
Compute union of brep and a list of breps
Parameters:
-
brep1
(BRep3D
) –first brep
-
breps
(BRep3DList
) –list of breps
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result brep of union)
MakeUnion(breps: BRep3DList) -> tuple[eGeometryErrorCode, BRep3D]
Compute union of more breps at once (using paralelism if possible)
Parameters:
-
breps
(BRep3DList
) –breps to unite
Returns:
-
tuple[eGeometryErrorCode, BRep3D]
–tuple(error code, result brep of union)
Mirror
overloaded
Mirror(polyline: Polyline2D, plane: Plane3D) -> Polyline2D
Mirror polyline 2D
Parameters:
-
polyline
(Polyline2D
) –mirroring polyline 2D
-
plane
(Plane3D
) –mirror plane
Returns:
-
Polyline2D
–mirrored polyline
Mirror(polyline: Polyline2D, axis: Axis2D) -> Polyline2D
2D mirror of 2D polyline
Parameters:
-
polyline
(Polyline2D
) –mirroring polyline 2D
-
axis
(Axis2D
) –mirror axis
Returns:
-
Polyline2D
–mirrored polyline
Mirror(polygon: PolygonalArea2D, axis: Axis2D) -> PolygonalArea2D
Mirror polygonal area 2D
Parameters:
-
polygon
(PolygonalArea2D
) –polygon to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
PolygonalArea2D
–mirrored polygonal area
Mirror(polygon: PolygonalArea3D, axis: Axis2D) -> PolygonalArea3D
Mirror polygonal area 2D
Parameters:
-
polygon
(PolygonalArea3D
) –polygon to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
PolygonalArea3D
–mirrored polygonal area
Mirror(polygon: PolygonalArea3D, plane: Plane3D) -> PolygonalArea3D
Mirror polygonal area 3D
Parameters:
-
polygon
(PolygonalArea3D
) –polygon to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
PolygonalArea3D
–mirrored polygonal area
Mirror(polyline: Polyline3D, plane: Plane3D) -> Polyline3D
Mirror polyline 3D
Parameters:
-
polyline
(Polyline3D
) –mirroring polyline 3D
-
plane
(Plane3D
) –mirror plane
Returns:
-
Polyline3D
–mirrored polyline
Mirror(polyline: Polyline3D, axis: Axis2D) -> Polyline3D
Mirror polyline 3D
Parameters:
-
polyline
(Polyline3D
) –mirroring polyline 3D
-
axis
(Axis2D
) –mirror axis
Returns:
-
Polyline3D
–mirrored polyline
Mirror(area: ClosedArea2D, plane: Plane3D) -> ClosedArea2D
Mirror path bounded area 2D
Parameters:
-
area
(ClosedArea2D
) –mirroring path bounded area 2D
-
plane
(Plane3D
) –mirror plane
Returns:
-
ClosedArea2D
–mirrored path bounded area
Mirror(area: ClosedArea2D, axis: Axis2D) -> ClosedArea2D
Mirror path bounded area 2D
Parameters:
-
area
(ClosedArea2D
) –mirroring path bounded area 2D
-
axis
(Axis2D
) –mirror axis
Returns:
-
ClosedArea2D
–mirrored path bounded area
Mirror(area: ClosedAreaComposite2D, plane: Plane3D) -> ClosedAreaComposite2D
Mirror path bounded area composite 2D
Parameters:
-
area
(ClosedAreaComposite2D
) –mirroring path bounded area composite 2D
-
plane
(Plane3D
) –mirror plane
Returns:
-
ClosedAreaComposite2D
–mirrored path bounded area composite
Mirror(area: ClosedAreaComposite2D, axis: Axis2D) -> ClosedAreaComposite2D
Mirror path bounded area composite 2D
Parameters:
-
area
(ClosedAreaComposite2D
) –mirroring path bounded area composite 2D
-
axis
(Axis2D
) –mirror axis
Returns:
-
ClosedAreaComposite2D
–mirrored path bounded area composite
Mirror(polyhedron: Polyhedron3D, plane: Plane3D) -> Polyhedron3D
Mirror Polyhedron3D
Parameters:
-
polyhedron
(Polyhedron3D
) –mirroring polyhedron
-
plane
(Plane3D
) –mirror plane
Returns:
-
Polyhedron3D
–mirrored polyhedron
Mirror(polyhedron: Polyhedron3D, axis: Axis2D) -> Polyhedron3D
2D mirror of 3D Polyhedron
Parameters:
-
polyhedron
(Polyhedron3D
) –mirroring polyhedron
-
axis
(Axis2D
) –mirror axis
Returns:
-
Polyhedron3D
–mirrored polyhedron
Mirror(solid: ClippedSweptSolid3D, axis: Axis2D) -> ClippedSweptSolid3D
2D Mirror ClippedSweptSolid3D
Parameters:
-
solid
(ClippedSweptSolid3D
) –solid to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
ClippedSweptSolid3D
–mirrored solid
Mirror(solid: ExtrudedAreaSolid3D, plane: Plane3D) -> ExtrudedAreaSolid3D
Mirror ExtrudedAreaSolid3D
Parameters:
-
solid
(ExtrudedAreaSolid3D
) –solid to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
ExtrudedAreaSolid3D
–mirrored solid
Mirror(solid: ExtrudedAreaSolid3D, axis: Axis2D) -> ExtrudedAreaSolid3D
2D Mirror of ExtrudedAreaSolid3D
Parameters:
-
solid
(ExtrudedAreaSolid3D
) –solid to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
ExtrudedAreaSolid3D
–mirrored solid
Mirror(clothoid: Clothoid2D, plane: Plane3D) -> Clothoid2D
Mirror of Clothoid2D
Parameters:
-
clothoid
(Clothoid2D
) –clothoid to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
Clothoid2D
–mirrored solid
Mirror(clothoid: Clothoid2D, axis: Axis2D) -> Clothoid2D
2D Mirror of Clothoid2D
Parameters:
-
clothoid
(Clothoid2D
) –clothoid to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
Clothoid2D
–mirrored solid
Mirror(placement: AxisPlacement2D, axis: Axis2D) -> AxisPlacement2D
2D Mirror AxisPlacement2D
Parameters:
-
placement
(AxisPlacement2D
) –axis placement to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
AxisPlacement2D
–mirrored placement
Mirror(placement: AxisPlacement2D, plane: Plane3D) -> AxisPlacement2D
3D Mirror AxisPlacement2D
Parameters:
-
placement
(AxisPlacement2D
) –axis placement to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
AxisPlacement2D
–mirrored placement
Mirror(placement: AxisPlacement3D, axis: Axis2D) -> AxisPlacement3D
2D Mirror AxisPlacement3D
Parameters:
-
placement
(AxisPlacement3D
) –axis placement to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
AxisPlacement3D
–mirrored placement
Mirror(placement: AxisPlacement3D, plane: Plane3D) -> AxisPlacement3D
3D Mirror AxisPlacement3D
Parameters:
-
placement
(AxisPlacement3D
) –axis placement to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
AxisPlacement3D
–mirrored placement
Mirror(cylinder: Cylinder3D, plane: Plane3D) -> Cylinder3D
Mirror Cylinder3D
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
Cylinder3D
–mirrored cylinder
Mirror(cylinder: Cylinder3D, axis: Axis2D) -> Cylinder3D
Mirror Cylinder3D
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
Cylinder3D
–mirrored cylinder
Mirror(ellipsoid: Ellipsoid3D, plane: Plane3D) -> Ellipsoid3D
Mirror Ellipsoid3D
Parameters:
-
ellipsoid
(Ellipsoid3D
) –Ellipsoid to mirror
-
plane
(Plane3D
) –mirror plane
Returns:
-
Ellipsoid3D
–mirrored Ellipsoid
Mirror(ellipsoid: Ellipsoid3D, axis: Axis2D) -> Ellipsoid3D
Mirror Ellipsoid3D
Parameters:
-
ellipsoid
(Ellipsoid3D
) –Ellipsoid to mirror
-
axis
(Axis2D
) –mirror axis
Returns:
-
Ellipsoid3D
–mirrored Ellipsoid
Move
overloaded
Move(box: BoundingBox2D, translation: Vector2D) -> BoundingBox2D
Move bounding box
Parameters:
-
box
(BoundingBox2D
) –Moving bounding box
-
translation
(Vector2D
) –Vector of translation
Returns:
-
BoundingBox2D
–Moved bounding box
Move(area: PolygonalArea2D, translation: Vector2D) -> PolygonalArea2D
Move polygonal area
Parameters:
-
area
(PolygonalArea2D
) –PolygonalArea2D to move
-
translation
(Vector2D
) –Vector of translation
Returns:
-
PolygonalArea2D
–PolygonalArea2D Moved area
Move(axisPlacement2D: AxisPlacement2D, moveVector: Vector2D) -> AxisPlacement2D
Move AxisPlacement2D by given vector
Parameters:
-
axisPlacement2D
(AxisPlacement2D
) –AxisPlacement2D to move
-
moveVector
(Vector2D
) –Vector of translation
Returns:
-
AxisPlacement2D
–AxisPlacement2D Moved axis placement
Move(axisPlacement3D: AxisPlacement3D, moveVector: Vector3D) -> AxisPlacement3D
Move AxisPlacement3D by given vector
Parameters:
-
axisPlacement3D
(AxisPlacement3D
) –AxisPlacement3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
AxisPlacement3D
–AxisPlacement3D Moved placement
Move(
clippedSweptSolid3D: ClippedSweptSolid3D, vec: Vector3D
) -> ClippedSweptSolid3D
Move ClippedSweptSolid3D by given vector
Parameters:
-
clippedSweptSolid3D
(ClippedSweptSolid3D
) –ClippedSweptSolid3D to move
-
vec
(Vector3D
) –Vector of translation
Returns:
-
ClippedSweptSolid3D
–ClippedSweptSolid3D Moved solid
Move(clothoid2D: Clothoid2D, moveVector: Vector2D) -> Clothoid2D
Move Clothoid2D by given vector
Parameters:
-
clothoid2D
(Clothoid2D
) –Clothoid2D to move
-
moveVector
(Vector2D
) –Vector of translation
Returns:
-
Clothoid2D
–Clothoid2D Moved clothoid
Move(
extrudedAreaSolid3D: ExtrudedAreaSolid3D, moveVector: Vector3D
) -> ExtrudedAreaSolid3D
Move ExtrudedAreaSolid3D by given vector
Parameters:
-
extrudedAreaSolid3D
(ExtrudedAreaSolid3D
) –ExtrudedAreaSolid3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
ExtrudedAreaSolid3D
–ExtrudedAreaSolid3D Moved solid
Move(polygonalArea3D: PolygonalArea3D, moveVector: Vector3D) -> PolygonalArea3D
Move PolygonalArea3D by given vector
Parameters:
-
polygonalArea3D
(PolygonalArea3D
) –PolygonalArea3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
PolygonalArea3D
–PolygonalArea3D Moved polygonal area
Move(polyhedron3D: Polyhedron3D, moveVector: Vector3D) -> Polyhedron3D
Move Polyhedron3D by given vector
Throw exception in case of error
Parameters:
-
polyhedron3D
(Polyhedron3D
) –Polyhedron3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
Polyhedron3D
–Polyhedron3D Moved polyhedron
Move(polyline2D: Polyline2D, moveVector: Vector2D) -> Polyline2D
Move Polyline2D by given vector
Parameters:
-
polyline2D
(Polyline2D
) –Polyline2D to move
-
moveVector
(Vector2D
) –Vector of translation
Returns:
-
Polyline2D
–Polyline2D Moved polyline
Move(polyline3D: Polyline3D, moveVector: Vector3D) -> Polyline3D
Move Polyline3D by given vector
Parameters:
-
polyline3D
(Polyline3D
) –Polyline3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
Polyline3D
–Polyline3D Moved polyline
Move(area: ClosedArea2D, moveVector: Vector2D) -> ClosedArea2D
Move ClosedArea2D by given vector
Parameters:
-
area
(ClosedArea2D
) –ClosedArea2D to move
-
moveVector
(Vector2D
) –Vector of translation
Returns:
-
ClosedArea2D
–ClosedArea2D Moved area
Move(
area: ClosedAreaComposite2D, moveVector: Vector2D
) -> ClosedAreaComposite2D
Move ClosedAreaComposite2D by given vector
Parameters:
-
area
(ClosedAreaComposite2D
) –ClosedAreaComposite2D to move
-
moveVector
(Vector2D
) –Vector of translation
Returns:
-
ClosedAreaComposite2D
–ClosedAreaComposite2D Moved area composite
Move(cylinder3D: Cylinder3D, moveVector: Vector3D) -> Cylinder3D
Move Cylinder3D by given vector
Parameters:
-
cylinder3D
(Cylinder3D
) –Cylinder3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
Cylinder3D
–Cylinder3D Moved Cylinder
Move(ellipsoid3D: Ellipsoid3D, moveVector: Vector3D) -> Ellipsoid3D
Move Ellipsoid3D by given vector
Parameters:
-
ellipsoid3D
(Ellipsoid3D
) –Ellipsoid3D to move
-
moveVector
(Vector3D
) –Vector of translation
Returns:
-
Ellipsoid3D
–Ellipsoid3D Moved Ellipsoid3D
MoveArc3DToZ0Plane
MoveSpline3DToZ0Plane
Offset
overloaded
Offset(
rDistance: float, geoObjects: list, checkSegmentsOrientation: bool
) -> eGeometryErrorCode
Counts parallel for Chain
If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
rDistance
(float
) –Distances for the Chain
-
geoObjects
(list
) –Source elements and destination elements
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
eGeometryErrorCode
–eGeometryErrorCode
Offset(
srcElement: object, distance: float
) -> tuple[eGeometryErrorCode, typingAny]
Create a parallel element from the given distance
Parameters:
-
srcElement
(object
) –Source element
-
distance
(float
) –Distances for the points
Returns:
-
tuple[eGeometryErrorCode, typingAny]
–tuple(A parallel element, Parallel element)
Offset(point: Point2D, lineSrc: Line2D) -> tuple[eGeometryErrorCode, Line2D]
Counts parallel to 2D-Line
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Line2D]
–tuple(eOK if successful, Parallel element to the source through the "point")
Offset(dist: float, lineSrc: Line2D) -> tuple[eGeometryErrorCode, Line2D]
Counts parallel to 2D-Line
Parameters:
-
dist
(float
) –Distance from the source
-
lineSrc
(Line2D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Line2D]
–tuple(eOK if successful, Parallel element to the source through the "point")
Offset(point: Point2D, pathSrc: Path2D) -> tuple[eGeometryErrorCode, Path2D]
Calculate parallel to Path2D
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Path2D]
–tuple(GeoErrorCode, destination parallel path)
Offset(
dist: float, pathSrc: Path2D, checkSegmentsOrientation: bool
) -> tuple[eGeometryErrorCode, Path2D]
Calculate parallel to Path2D If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
dist
(float
) –parallel defined by distance
-
pathSrc
(Path2D
) –source path
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Path2D]
–tuple(GeoErrorCode, destination path)
Offset(
point: Point3D, dist: float, lineSrc: Line3D, offsetPlane: Offset3DPlane
) -> tuple[eGeometryErrorCode, Line3D]
Counts parallel to 3D-Line
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:
-
point
(Point3D
) –Parallel to this point
-
dist
(float
) –Distance from the source
-
lineSrc
(Line3D
) –Source element
-
offsetPlane
(Offset3DPlane
) –Plane on which parallel line will be calculated
Returns:
-
tuple[eGeometryErrorCode, Line3D]
–tuple(eOK if successful, Parallel element)
Offset(
dist: float, offsetPlane: Plane3D, parallelsCount: int, polySrc: Polyline3D
) -> tuple[eGeometryErrorCode, Polyline3DList]
Counts parallels to 3D Polyline
Parameters:
-
dist
(float
) –Distance from the source
-
offsetPlane
(Plane3D
) –Plane on which offsets will be calculated
-
parallelsCount
(int
) –Count of parallels to calculate
-
polySrc
(Polyline3D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Polyline3DList]
–tuple(eOK if successful, Parallel elements)
Offset(
point: Point3D,
offsetPlane: Plane3D,
parallelsCount: int,
polySrc: Polyline3D,
) -> tuple[eGeometryErrorCode, Polyline3DList]
Counts parallels to 3D Polyline
Parameters:
-
point
(Point3D
) –Parallel to this point
-
offsetPlane
(Plane3D
) –Plane on which offsets will be calculated
-
parallelsCount
(int
) –Count of parallels to calculate
-
polySrc
(Polyline3D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Polyline3DList]
–tuple(eOK if successful, Parallel elements)
Offset(point: Point3D, arc3DSrc: Arc3D) -> tuple[eGeometryErrorCode, Arc3D]
Counts parallel to Arc3D
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Arc3D]
–tuple(eOK if successful, Parallel element)
Offset(dist: float, arc3DSrc: Arc3D) -> tuple[eGeometryErrorCode, Arc3D]
Counts parallel to Arc3D
Parameters:
-
dist
(float
) –Distance from the source
-
arc3DSrc
(Arc3D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Arc3D]
–tuple(eOK if successful, Parallel element)
Offset(point: Point2D, arc2DSrc: Arc2D) -> tuple[eGeometryErrorCode, Arc2D]
Counts parallel to Arc2D
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Arc2D]
–tuple(eOK if successful, Parallel element)
Offset(dist: float, arc2DSrc: Arc2D) -> tuple[eGeometryErrorCode, Arc2D]
Counts parallel to Arc2D
Parameters:
-
dist
(float
) –Distance from the source
-
arc2DSrc
(Arc2D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Arc2D]
–tuple(eOK if successful, Parallel element)
Offset(
dist: float, spline2DSrc: Spline2D, checkSegmentsOrientation: bool
) -> tuple[eGeometryErrorCode, Spline2D]
Counts parallel to Spline2D
If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
dist
(float
) –Distance from the source
-
spline2DSrc
(Spline2D
) –Source element
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Spline2D]
–tuple(eOK if successful, Parallel element)
Offset(
dist: float,
spline3DSrc: Spline3D,
plane: Plane3D,
checkSegmentsOrientation: bool,
) -> tuple[eGeometryErrorCode, Spline3D]
Calculates parallel to Spline3D - only for planar 3D splines !!!
If checkSegmentsOrientation is true, new spline must have same count of points as original
Parameters:
-
dist
(float
) –Distance from the source
-
spline3DSrc
(Spline3D
) –Source element
-
plane
(Plane3D
) –plane to offset in
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Spline3D]
–tuple(eOK if successful, Parallel element)
Offset(
point: Point2D, spline2DSrc: Spline2D
) -> tuple[eGeometryErrorCode, Spline2D]
Counts parallel to Spline2D
Parameters:
Returns:
-
tuple[eGeometryErrorCode, Spline2D]
–tuple(eOK if successful, Parallel element)
Offset(
point: Point3D, spline3DSrc: Spline3D, plane: Plane3D
) -> tuple[eGeometryErrorCode, Spline3D]
Offset(
dist: float, spline2DSrc: Spline2D, checkSegmentsOrientation: bool
) -> tuple[eGeometryErrorCode, Polyline2D]
Counts parallel to Spline2D
If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
dist
(float
) –Distance from the source
-
spline2DSrc
(Spline2D
) –Source element
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Polyline2D]
–tuple(eOK if successful, Parallel element as a Polyline2D)
Offset(
dist: float, clothoid2DSrc: Clothoid2D
) -> tuple[eGeometryErrorCode, Clothoid2D]
Count parallel to Clothoid2D
Parameters:
-
dist
(float
) –Distance from the source
-
clothoid2DSrc
(Clothoid2D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Clothoid2D]
–tuple(Return eOK if successful, otherwise return error code, Parallel element to source)
Offset(
point: Point2D, clothoid2DSrc: Clothoid2D
) -> tuple[eGeometryErrorCode, Clothoid2D]
Count parallel to Clothoid2D
Parameters:
-
point
(Point2D
) –Parallel to this point
-
clothoid2DSrc
(Clothoid2D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Clothoid2D]
–tuple(Return eOK if successful, otherwise return error code, Parallel element to source)
Offset(
rDistance: float, polyline2D: Polyline2D, checkSegmentsOrientation: bool
) -> tuple[eGeometryErrorCode, Polyline2D]
Counts parallel to Polyline2D
If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
rDistance
(float
) –Distance from the source
-
polyline2D
(Polyline2D
) –Source element
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Polyline2D]
–tuple(eOK if successful, Parallel element)
Offset(
point: Point2D, polyline2DSrc: Polyline2D
) -> tuple[eGeometryErrorCode, Polyline2D]
Counts parallel to Polyline2D
Parameters:
-
point
(Point2D
) –Parallel to this point
-
polyline2DSrc
(Polyline2D
) –Source element
Returns:
-
tuple[eGeometryErrorCode, Polyline2D]
–tuple(eOK if successful, Parallel element)
Offset(
rDistance: float, polygon: Polygon2D, checkSegmentsOrientation: bool
) -> tuple[eGeometryErrorCode, Polygon2D]
Calculate parallel polygon If checkSegmentsOrientation is true, new polyline must have same count of points as original
Parameters:
-
rDistance
(float
) –input polygon
-
polygon
(Polygon2D
) –offset value
-
checkSegmentsOrientation
(bool
) –check, if segments in parallel geometry has same orientation as in original
Returns:
-
tuple[eGeometryErrorCode, Polygon2D]
–tuple(eOK if successful, result polygon)
Offset(distances: VecDoubleList, polyline: Polyline2D) -> Polyline2D
Create a parallel line from distances
Parameters:
-
distances
(VecDoubleList
) –Distances for the points
-
polyline
(Polyline2D
) –Source element
Returns:
-
Polyline2D
–A parallel polyline
Offset(
inputPath: Path3D, normVector: Vector3D, offsetDistance: float
) -> tuple[eGeometryErrorCode, Path3D]
Create offset of Path3D
Parameters:
-
inputPath
(Path3D
) –input path
-
normVector
(Vector3D
) –normal vector of plane in that the offset will be calculated
-
offsetDistance
(float
) –offset distance
Returns:
-
tuple[eGeometryErrorCode, Path3D]
–tuple(error code, result offset curve)
Offset(
inputPath: Path3D, inputPoint: Point3D, rayVector: Vector3D, plane: Plane3D
) -> tuple[eGeometryErrorCode, Path3D]
Offset Path3D in distance given with cursor point
Parameters:
-
inputPath
(Path3D
) –input path
-
inputPoint
(Point3D
) –cursor point (ray point)
-
rayVector
(Vector3D
) –ray vector
-
plane
(Plane3D
) –plane of the planar face (of given boundary curves)
Returns:
-
tuple[eGeometryErrorCode, Path3D]
–tuple(error code, result path)
OffsetCurve
OffsetCurve(
inputCurves: Curve3DList,
normVector: Vector3D,
offsetDistance: float,
sortEdges: bool = False,
) -> tuple
Offset 3D curves with given distance
Parameters:
-
inputCurves
(Curve3DList
) –input curves
-
normVector
(Vector3D
) –normal vector of plane in that the offset will be calculated
-
offsetDistance
(float
) –offset distance
-
sortEdges
(bool
, default:False
) –flag if to sort edges to original order
Returns:
-
tuple
–tuple(error code, result offset curves)
Polygonize
overloaded
Polygonize(
geometry_object: object,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline3D]
Polygonize whole curve
Parameters:
-
geometry_object
(object
) –Geometry object which will be polygonized
-
arcSegmentation
(int
) –segment number
-
useArcSegmentation
(int
) –if use segment polygonization, set to 0
-
armLength
(float
) –max length of calculated segment, for rise value polygonization only
-
riseValue
(float
) –rise value
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool true = success, result polyline)
Polygonize(
geometry_object: object,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
geometry_object
(object
) –Geometry object which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
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
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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: Path2D,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
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: Line2D, fromPoint: Point3D, toPoint: Point3D, eps: float
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
line
(Line2D
) –Line which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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: Polyline2D, fromPoint: Point3D, toPoint: Point3D, eps: float
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
polyline
(Polyline2D
) –Polyline which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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: Polygon2D, fromPoint: Point3D, toPoint: Point3D, eps: float
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
polygon
(Polygon2D
) –Polygon which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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: Arc2D,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
arc
(Arc2D
) –Arc which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
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:
-
tuple[bool, Polyline2D]
–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: Arc2D,
fromPoint: Point2D,
toPoint: Point2D,
count: int,
bInscribed: bool,
) -> tuple[bool, Polyline2D]
Polygonize Arc2D with given division
Parameters:
-
arc
(Arc2D
) –Arc2D
-
fromPoint
(Point2D
) –Start point for polygonization
-
toPoint
(Point2D
) –End point for polygonization
-
count
(int
) –Count of segments
-
bInscribed
(bool
) –in case of inscribed circle there is additional segment (one segment divided to 2 parts)
Returns:
-
tuple[bool, Polyline2D]
–tuple(bool (true = polygonization possible), PolyLine2D)
Polygonize(arc: Arc2D, countOfSegments: int) -> Polyline2D
Polygonize a Arc2D geometry object
Parameters:
-
arc
(Arc2D
) –Arc2D which will be polygonized
-
countOfSegments
(int
) –Count of segments
Returns:
-
Polyline2D
–Polyline2D The polyline will be filled with the points of the polygonization
Polygonize(
spline: Spline2D,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
spline
(Spline2D
) –Spline which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
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
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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(
bspline: BSpline2D,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline2D]
Polygonize a BSpline2D geometry object
Parameters:
-
bspline
(BSpline2D
) –BSpline2D which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization
-
toPoint
(Point3D
) –where to end the polygonization
-
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:
-
tuple[bool, Polyline2D]
–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: Clothoid2D,
fromPoint: Point3D,
toPoint: Point3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
Polygonize a single geometry object
Parameters:
-
clothoid
(Clothoid2D
) –Clothoid which will be polygonized
-
fromPoint
(Point3D
) –where to begin the polygonization; The point has to be on one of the Objects
-
toPoint
(Point3D
) –where to end the polygonization; The point has to be on one of the Objects
-
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
-
eps
(float
) –stw[295-1]
Returns:
-
tuple[bool, Polyline2D]
–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: Arc3D, countOfSegments: int) -> Polyline3D
Polygonize a Arc3D geometry object
Parameters:
-
arc
(Arc3D
) –Arc3D which will be polygonized
-
countOfSegments
(int
) –Count of segments
Returns:
-
Polyline3D
–Polyline3D the polyline will be filled with the points of the polygonization
Polygonize(
arc: Arc3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline3D]
Polygonize a Arc3D geometry object
Parameters:
-
arc
(Arc3D
) –Arc3D which will be polygonized
-
arcSegmentation
(int
) –Count of segments
-
useArcSegmentation
(int
) –if use segment polygonization, set to 0
-
armLength
(float
) –max length of calculated segment, for rise value polygonization only
-
riseValue
(float
) –rise value
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool true = success, result polyline)
Polygonize(path: Path3D, countOfSegments: int) -> Polyline3D
Polygonize a Path3D geometry object
Parameters:
-
path
(Path3D
) –Path3D which will be polygonized
-
countOfSegments
(int
) –Count of segments
Returns:
-
Polyline3D
–Polyline3D the polyline will be filled with non repeated points of the polygonization
Polygonize(
path: Path3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> Polyline3D
Polygonize a Arc3D geometry object
Parameters:
-
path
(Path3D
) –Path3D which will be polygonized
-
arcSegmentation
(int
) –Count of segments
-
useArcSegmentation
(int
) –if use segment polygonization, set to 0
-
armLength
(float
) –max length of calculated segment, for rise value polygonization only
-
riseValue
(float
) –rise value
Returns:
-
Polyline3D
–the result polyline
Polygonize(spline: Spline3D, linesPerSegment: int) -> Polyline3D
Polygonize a Spline3D geometry object
Parameters:
-
spline
(Spline3D
) –Spline3D which will be polygonized
-
linesPerSegment
(int
) –Count of lines per segment
Returns:
-
Polyline3D
–Polyline3D the polyline will be filled with the points of the polygonization
Polygonize(
spline: Spline3D, minmaxRadius: float, pixelSize: float
) -> tuple[bool, Polyline3D]
Polygonize Spline3D
Parameters:
-
spline
(Spline3D
) –Spline3D
-
minmaxRadius
(float
) –radius of minmax
-
pixelSize
(float
) –size of pixel
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool (true = polygonization possible), polygonized spline)
Polygonize(
spline: BSpline3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline3D]
Polygonize B-spline curve
Parameters:
-
spline
(BSpline3D
) –spline to tesselate
-
arcSegmentation
(int
) –segment number
-
useArcSegmentation
(int
) –if use segment polygonization, set to 0
-
armLength
(float
) –max length of calculated segment, for rise value polygonization only
-
riseValue
(float
) –rise value
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool true = success, result polyline)
Polygonize(
spline: Spline3D,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline3D]
Polygonize whole spline curve
Parameters:
-
spline
(Spline3D
) –spline to tesselate
-
arcSegmentation
(int
) –segment number
-
useArcSegmentation
(int
) –if use segment polygonization, set to 0
-
armLength
(float
) –max length of calculated segment, for rise value polygonization only
-
riseValue
(float
) –rise value
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool true = success, result polyline)
Polygonize(line: Line3D) -> tuple[bool, Polyline3D]
Create polyline from line
Parameters:
-
line
(Line3D
) –Line to polygonize
Returns:
-
tuple[bool, Polyline3D]
–tuple(bool true = success, Result polyline)
Polygonize(
line: Line2D, fromOffset: float, toOffset: float
) -> tuple[bool, Polyline2D]
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: Clothoid2D,
fromOffset: float,
toOffset: float,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
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: Polyline2D, fromOffset: float, toOffset: float, eps: float
) -> tuple[bool, Polyline2D]
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: Polygon2D, fromOffset: float, toOffset: float, eps: float
) -> tuple[bool, Polyline2D]
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: Arc2D,
fromOffset: float,
toOffset: float,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
) -> tuple[bool, Polyline2D]
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: Arc2D, fromOffset: float, toOffset: float, count: int, bInscribed: bool
) -> tuple[bool, Polyline2D]
Polygonize Arc2D with given division
Parameters:
-
arc
(Arc2D
) –Arc2D
-
fromOffset
(float
) –the offset from the elements start point, where polygonization will begin
-
toOffset
(float
) –the offset from the elements start point, where polygonization will end
-
count
(int
) –Count of segments
-
bInscribed
(bool
) –in case of inscribed circle there is additional segment (one segment divided to 2 parts)
Returns:
-
tuple[bool, Polyline2D]
–tuple(bool (true = polygonization possible), PolyLine2D)
Polygonize(
spline: Spline2D,
fromOffset: float,
toOffset: float,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
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: Path2D,
fromOffset: float,
toOffset: float,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
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: ClosedAreaComposite2D,
eps: float,
arcSegmentation: int = 360,
useArcSegmentation: int = 0,
armLength: float = 0.0,
riseValue: float = 0.0,
) -> tuple[bool, Polygon2D]
Polygonizes path bounded area
Parameters:
-
area
(ClosedAreaComposite2D
) –path bounded area to be polygonized
-
eps
(float
) –Number of segments the arc will be divided
-
arcSegmentation
(int
, default:360
) –type of the polygonization (if 0 use the arcSegmentation otherwise use the riseValue)
-
useArcSegmentation
(int
, default:0
) –maximum length of a segment for polygonized arc
-
armLength
(float
, default:0.0
) –is the maximum distance from the actual arc and the polyline
-
riseValue
(float
, default:0.0
) –stw[295-1]
Returns:
Polygonize(
geometry_object: object,
fromOffset: float,
toOffset: float,
arcSegmentation: int,
useArcSegmentation: int,
armLength: float,
riseValue: float,
eps: float,
) -> tuple[bool, Polyline2D]
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
PolygonizeEqually(
arc: Arc2D, fromPoint: Point2D, toPoint: Point2D, count: int
) -> tuple[bool, Polyline2D]
Polygonize given arc always equally
Parameters:
-
arc
(Arc2D
) –Source arc
-
fromPoint
(Point2D
) –Start point for polygonization
-
toPoint
(Point2D
) –End point for polygonization
-
count
(int
) –Count of segments
Returns:
-
tuple[bool, Polyline2D]
–tuple(bool (true = polygonization possible), Output polyline)
Rotate
overloaded
Rotate(polyline: Polyline2D, zeroPoint: Point2D, angle: Angle) -> Polyline2D
Rotate a polyline around given point by an angle.
Parameters:
-
polyline
(Polyline2D
) –2D polyline
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
Polyline2D
–Resulting 2D polyline
Rotate(polyline: Polyline2D, angle: Angle) -> Polyline2D
Rotate a polyline around origin by an angle.
Parameters:
-
polyline
(Polyline2D
) –2D polyline
-
angle
(Angle
) –Angle of rotation
Returns:
-
Polyline2D
–Resulting 2D polyline
Rotate(axis: AxisPlacement2D, angle: Angle) -> AxisPlacement2D
Rotate a axis placement around origin by an angle.
Parameters:
-
placement
–2D axis placement
-
angle
(Angle
) –Angle of rotation
Returns:
-
AxisPlacement2D
–Resulting 2D axis placement
Rotate(
axis: AxisPlacement2D, zeroPoint: Point2D, angle: Angle
) -> AxisPlacement2D
Rotate a axis placement around given point by an angle.
Parameters:
Returns:
-
AxisPlacement2D
–Resulting 2D axis placement
Rotate(placement: AxisPlacement3D, angle: Angle) -> AxisPlacement3D
Rotate a axis placement3D around origin(z-axis) by an angle.
Parameters:
-
placement
(AxisPlacement3D
) –3D axis placement
-
angle
(Angle
) –Angle of rotation
Returns:
-
AxisPlacement3D
–Resulting 3D axis placement
Rotate(
placement: AxisPlacement3D, rotAxis: Axis3D, angle: Angle
) -> AxisPlacement3D
Rotate a axis placement 3D around origin(z-axis) by an angle.
Parameters:
-
placement
(AxisPlacement3D
) –3D axis placement
-
rotAxis
(Axis3D
) –3D axis
-
angle
(Angle
) –Angle of rotation
Returns:
-
AxisPlacement3D
–Resulting 3D Axis placement
Rotate(
placement: AxisPlacement3D, zeroPoint: Point2D, angle: Angle
) -> AxisPlacement3D
Rotate a axis placement around given point (z-axis) by an angle.
Parameters:
-
placement
(AxisPlacement3D
) –3D axis placement
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
AxisPlacement3D
–Resulting 3D axis placement
Rotate(clothoid: Clothoid2D, angle: Angle) -> Clothoid2D
Rotate a clothoid around origin by an angle.
Parameters:
-
clothoid
(Clothoid2D
) –2D clothoid
-
angle
(Angle
) –Angle of rotation
Returns:
-
Clothoid2D
–Resulting 2D clothoid
Rotate(clothoid: Clothoid2D, zeroPoint: Point2D, angle: Angle) -> Clothoid2D
Rotate a clothoid around given point by an angle.
Parameters:
-
clothoid
(Clothoid2D
) –2D clothoid
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
Clothoid2D
–Resulting 2D clothoid
Rotate(area: PolygonalArea2D, angle: Angle) -> PolygonalArea2D
Rotate a polygonal area around origin by an angle.
Parameters:
-
area
(PolygonalArea2D
) –2D polygonal area
-
angle
(Angle
) –Angle of rotation
Returns:
-
PolygonalArea2D
–Resulting 2D polygonal area
Rotate(
area: PolygonalArea2D, zeroPoint: Point2D, angle: Angle
) -> PolygonalArea2D
Rotate a polygonal area around given point by an angle.
Parameters:
-
area
(PolygonalArea2D
) –2D polygonal area
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
PolygonalArea2D
–Resulting 2D polygonal area
Rotate(cylinder: Cylinder3D, angle: Angle) -> Cylinder3D
Rotate a 3D Cylinder around origin by an angle.
Parameters:
-
cylinder
(Cylinder3D
) –3D Cylinder
-
angle
(Angle
) –Angle of rotation
Returns:
-
Cylinder3D
–Resulting 3D Cylinder
Rotate(cylinder: Cylinder3D, zeroPoint: Point2D, angle: Angle) -> Cylinder3D
Rotate a 3D Cylinder around given 2D point by an angle.
Parameters:
-
cylinder
(Cylinder3D
) –3D Cylinder
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
Cylinder3D
–Resulting 3D Cylinder
Rotate(cylinder: Cylinder3D, axis: Axis3D, angle: Angle) -> Cylinder3D
Rotate a 3D Cylinder around given 3D axis by an angle.
Parameters:
-
cylinder
(Cylinder3D
) –3D Cylinder
-
axis
(Axis3D
) –3D axis
-
angle
(Angle
) –Angle of rotation
Returns:
-
Cylinder3D
–Resulting 3D Cylinder
Rotate(ellipsoid: Ellipsoid3D, angle: Angle) -> Ellipsoid3D
Parameters:
-
ellipsoid
(Ellipsoid3D
) –3D Ellipsoid
-
angle
(Angle
) –Angle of rotation
Returns:
-
Ellipsoid3D
–Resulting 3D Ellipsoid
Rotate(ellipsoid: Ellipsoid3D, zeroPoint: Point2D, angle: Angle) -> Ellipsoid3D
Rotate a 3D Ellipsoid around given 2D point by an angle.
Parameters:
-
ellipsoid
(Ellipsoid3D
) –3D Ellipsoid
-
zeroPoint
(Point2D
) –2D zero point
-
angle
(Angle
) –Angle of rotation
Returns:
-
Ellipsoid3D
–Resulting 3D Ellipsoid
Rotate(ellipsoid: Ellipsoid3D, axis: Axis3D, angle: Angle) -> Ellipsoid3D
Rotate a 3D Ellipsoid around given 3D axis by an angle.
Parameters:
-
ellipsoid
(Ellipsoid3D
) –3D Ellipsoid
-
axis
(Axis3D
) –3D axis
-
angle
(Angle
) –Angle of rotation
Returns:
-
Ellipsoid3D
–Resulting 3D Ellipsoid
Rotate(polyhedron: Polyhedron3D, axis: Axis3D, angle: Angle) -> Polyhedron3D
Rotate a polyhedron around given 3D axis by an angle.
Parameters:
-
polyhedron
(Polyhedron3D
) –polyhedron
-
axis
(Axis3D
) –3D axis
-
angle
(Angle
) –Angle of rotation
Returns:
-
Polyhedron3D
–polyhedron
SetAbsoluteTolerance
set absolute tolerance
Parameters:
-
value
(float
) –new value
SetAngleTolerance
SetAngleTolerance(value: Angle)
Set angle tolerance
This tolerance is using for angle comparison.
Parameters:
-
value
(Angle
) –New tolerance using for angle comparison [rad]
SetCurvatureTolerance
Set curvature tolerance
This tolerance is using for curvature comparison.
Parameters:
-
value
(float
) –New tolerance using for curvature comparison
SetCurveLengthTolerance
Set curve length tolerance
This tolerance is using for length of curve comparison.
Parameters:
-
value
(float
) –New tolerance using for length of curve comparison [mm]
SetRelativeTolerance
set relative tolerance
Parameters:
-
value
(float
) –new value
SetZValue
SetZValue(zValue: float, line: Line3D)
Set the the z value of a line
Parameters:
-
zValue
(float
) –zValue
-
line
(Line3D
) –line
Returns:
-
–
true, if the calculation was correct
Split
overloaded
Split(
polygon2D: Polygon2D,
splitPoints: Point3DList,
pSplitGeometry: object,
posTol: float,
) -> tuple[eSplitResult, list[Polygon2D]]
Split a Polygon2D into multiple Polygon2D geometries by given split points
Parameters:
-
polygon2D
(Polygon2D
) –The polygon to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points between polygon2D and splitGeometry)
-
pSplitGeometry
(object
) –Can be NULL. The Geometry who splits the element. If available it maybe used as alternative for splitPoints
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Polygon2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split polygons. Usually this vector has cardinality of two. First polygon is BoolOp of 'given polygon - splitPolygon'. Second polygon is BoolOp of 'given polygon& splitPolygon'. The splitPolygon is created from splitPoints)
Split(
line2D: Line2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Line2D]]
Split a Line2D into multiple Line2D geometries by given split points
Parameters:
-
line2D
(Line2D
) –The line to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the line)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Line2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split lines)
Split(
polyline2D: Polyline2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Polyline2D]]
Split a Polyline2D into multiple Polyline2D geometries by given split points
Parameters:
-
polyline2D
(Polyline2D
) –The polyline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the polyline)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Polyline2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split polylines)
Split(
spline2D: Spline2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Spline2D]]
Split a Spline2D into multiple Spline2D geometries by given split points
Parameters:
-
spline2D
(Spline2D
) –The spline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the spline)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Spline2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split splines)
Split(
spline3D: Spline3D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Spline3D]]
Split a Spline3D into multiple Spline3D geometries by given split points
Parameters:
-
spline3D
(Spline3D
) –The spline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the spline)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Spline3D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split splines)
Split(
polyline2D: Polyline2D, polygon2D: Polygon2D, posTol: float
) -> tuple[eSplitResult, list[Polyline2D], list[Polyline2D]]
Split a Polyline2D into multiple Polyline2D geometries by given split polygon
Parameters:
-
polyline2D
(Polyline2D
) –The polyline to split
-
polygon2D
(Polygon2D
) –The given polygon
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Polyline2D], list[Polyline2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split polylines inside polygon, Vector of split polylines outside polygon)
Split(
polygon: Polygon2D,
polyline: Polyline2D,
posTol: float,
divideComponents: bool,
) -> tuple[eSplitResult, Polygon2D, Polygon2D, Polygon2D]
Split Polygon2D into 3 polygons by given Polyline2D
Parameters:
-
polygon
(Polygon2D
) –The polygon to split
-
polyline
(Polyline2D
) –The given polyline
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
-
divideComponents
(bool
) –If true, polygon will be split by intersection points of polyline and connection lines between components
Returns:
-
tuple[eSplitResult, Polygon2D, Polygon2D, Polygon2D]
–tuple(eSplitResult, SPLIT_OK on success, Polygon, which consist of not split components, Polygon, which consist of components on left side of polyline, Polygon, which consist of components on right side of polyline)
Split(
polygon: Polygon2D, axis: Axis2D, posTol: float, divideComponents: bool
) -> tuple[eSplitResult, Polygon2D, Polygon2D, Polygon2D]
Split Polygon2D into 3 polygons by given Axis2D
Parameters:
-
polygon
(Polygon2D
) –The polygon to split
-
axis
(Axis2D
) –The given axis
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
-
divideComponents
(bool
) –If true, polygon will be split by intersection points of polyline and connection lines between components
Returns:
-
tuple[eSplitResult, Polygon2D, Polygon2D, Polygon2D]
–tuple(eSplitResult, SPLIT_OK on success, Polygon, which consist of not split components, Polygon, which consist of components on left side of polyline, Polygon, which consist of components on right side of polyline)
Split(
line3D: Line3D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Line3D]]
Split a Line3D into multiple Line3D geometries by given split points
Parameters:
-
line3D
(Line3D
) –The line to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the line)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Line3D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split lines)
Split(
polyline3D: Polyline3D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Polyline3D]]
Split a Polyline3D into multiple Polyline3D geometries by given split points
Parameters:
-
polyline3D
(Polyline3D
) –The polyline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the line)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Polyline3D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split polylines)
Split(
arc3D: Arc3D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Arc3D]]
Split a Arc3D into multiple Arc3D geometries by given split points
Parameters:
-
arc3D
(Arc3D
) –The arc to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the line)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Arc3D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split arcs)
Split(
arc2D: Arc2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Arc2D]]
Split a Arc2D into multiple Arc2D geometries by given split points
Parameters:
-
arc2D
(Arc2D
) –The arc to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the arc)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Arc2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split arcs)
Split(
clothoid2D: Clothoid2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[Clothoid2D]]
Split a Clothoid2D into multiple Clothoid2D geometries by given split points
Parameters:
-
clothoid2D
(Clothoid2D
) –The clothoid to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the clothoid)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[Clothoid2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split clothoids)
Split(
bspline2D: BSpline2D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[BSpline2D]]
Split a BSpline2D into multiple BSpline2D geometries by given split points
Parameters:
-
bspline2D
(BSpline2D
) –The spline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the spline)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[BSpline2D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split splines)
Split(
bspline3D: BSpline3D, splitPoints: Point3DList, posTol: float
) -> tuple[eSplitResult, list[BSpline3D]]
Split a BSpline3D into multiple BSpline3D geometries by given split points
Parameters:
-
bspline3D
(BSpline3D
) –The spline to split
-
splitPoints
(Point3DList
) –The given split points (e.g. intersection points onto the spline)
-
posTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, list[BSpline3D]]
–tuple(eSplitResult, SPLIT_OK on success, Vector of split splines)
Split(
baseGeometry: object, point: Point3D, bGetFirstHalf: bool, eps: float
) -> object
Split the element in two and return one half
Parameters:
-
baseGeometry
(object
) –Geometry will be split
-
point
(Point3D
) –Split point
-
bGetFirstHalf
(bool
) –True, if the given point should be
-
eps
(float
) –Tolerance
Returns:
-
object
–first or second half or nullptr
SplitPolygon3DToParts
Tesselate
overloaded
Tesselate(
brep: BRep3D,
density: float,
maxAngle: float,
minEdge: float,
maxEdge: float,
) -> tuple
Tesselate b-rep with mesh triangles
Parameters:
-
brep
(BRep3D
) –brep to be tesselated
-
density
(float
) –density of resulting mesh (when 0, not used)
-
maxAngle
(float
) –maximal angle between neighbor triangles in degrees (when 0, not used)
-
minEdge
(float
) –minimal edge length (when 0, not used)
-
maxEdge
(float
) –maximal edge length (when 0, not used)
Returns:
Tesselate(
brep: BRep3D,
density: float,
chord: float,
maxAngle: float,
minEdge: float,
maxEdge: float,
) -> tuple
Tesselate b-rep with mesh triangles
Parameters:
-
brep
(BRep3D
) –brep to be tesselated
-
density
(float
) –density of resulting mesh (when 0, not used)
-
chord
(float
) –curve/surface chord tolerance (when 0, not used)
-
maxAngle
(float
) –maximal angle between neighbor triangles in degrees (when 0, not used)
-
minEdge
(float
) –minimal edge length (when 0, not used)
-
maxEdge
(float
) –maximal edge length (when 0, not used)
Returns:
Touching
overloaded
Touching(polygon: Polygon2D, polyline: Polyline2D) -> bool
Test for collision between polygon2D and polyline2D
Parameters:
-
polygon
(Polygon2D
) –the first geometry object
-
polyline
(Polyline2D
) –the second geometry object
Returns:
-
bool
–true when 1 or more lines in touch, otherwise false.
Transform
overloaded
Transform(clothoid: Clothoid2D, matrix: Matrix2D) -> Clothoid2D
Clothoid2D matrix transformation.
Parameters:
-
clothoid
(Clothoid2D
) –2D clothoid to transform.
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(polyline: Polyline2D, matrix: Matrix2D) -> Polyline2D
Polyline2D matrix transformation.
Parameters:
-
polyline
(Polyline2D
) –2D polyline to transform.
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(area: PolygonalArea2D, matrix: Matrix2D) -> PolygonalArea2D
PolygonalArea2D matrix transformation.
Parameters:
-
area
(PolygonalArea2D
) –2D polygonal area which will be transformed
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(area: ClosedArea2D, matrix: Matrix2D) -> ClosedArea2D
ClosedArea2D matrix transformation.
Parameters:
-
area
(ClosedArea2D
) –2D path bounded area which will be transformed
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(
area: ClosedAreaComposite2D, matrix: Matrix2D
) -> ClosedAreaComposite2D
ClosedAreaComposite2D matrix transformation.
Parameters:
-
area
(ClosedAreaComposite2D
) –2D path bounded area composite which will be transformed
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(polyline: Polyline3D, matrix: Matrix2D) -> Polyline3D
Polyline3D matrix transformation.
Parameters:
-
polyline
(Polyline3D
) –3D polyline to transform.
-
matrix
(Matrix2D
) –Transformation Matrix.
Transform(polyline: Polyline3D, matrix: Matrix3D) -> Polyline3D
Polyline3D matrix transformation.
Parameters:
-
polyline
(Polyline3D
) –3D polyline to transform.
-
matrix
(Matrix3D
) –Transformation Matrix.
Transform(polyhedron: Polyhedron3D, matrix: Matrix3D) -> Polyhedron3D
Polyhedron3D matrix3D transformation.
Parameters:
-
polyhedron
(Polyhedron3D
) –3D polyhedron to transform.
-
matrix
(Matrix3D
) –Transformation 3D Matrix.
Transform(polyhedron: Polyhedron3D, matrix: Matrix2D) -> Polyhedron3D
Polyhedron3D matrix2D transformation.
Parameters:
-
polyhedron
(Polyhedron3D
) –3D polyhedron to transform.
-
matrix
(Matrix2D
) –Transformation 2D Matrix.
Transform(area: PolygonalArea3D, matrix: Matrix2D) -> PolygonalArea3D
PolygonalArea3D matrix2D transformation.
Parameters:
-
area
(PolygonalArea3D
) –3D polygonal area which will be transformed
-
matrix
(Matrix2D
) –Transformation 2D Matrix.
Transform(area: PolygonalArea3D, matrix: Matrix3D) -> PolygonalArea3D
PolygonalArea3D matrix3D transformation.
Parameters:
-
area
(PolygonalArea3D
) –3D polygonal area which will be transformed
-
matrix
(Matrix3D
) –Transformation 3D Matrix.
Transform(solid: ClippedSweptSolid3D, matrix: Matrix2D) -> ClippedSweptSolid3D
ClippedSweptSolid3D matrix2D transformation.
Parameters:
-
solid
(ClippedSweptSolid3D
) –ClippedSweptSolid3D which will be transformed
-
matrix
(Matrix2D
) –Transformation 2D Matrix.
Transform(solid: ClippedSweptSolid3D, matrix: Matrix3D) -> ClippedSweptSolid3D
ClippedSweptSolid3D matrix3D transformation.
This body is transformed by 2D transformations only to keep vertical extrusion of the profile.
Parameters:
-
solid
(ClippedSweptSolid3D
) –ClippedSweptSolid3D which will be transformed
-
matrix
(Matrix3D
) –Transformation 2D Matrix.
Transform(cylinder: Cylinder3D, matrix: Matrix2D) -> Cylinder3D
Cylinder3D matrix2D transformation.
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder3D which will be transformed
-
matrix
(Matrix2D
) –Transformation 2D Matrix.
Warning: Perspective transformation will not work correctly
Transform(cylinder: Cylinder3D, matrix: Matrix3D) -> Cylinder3D
Cylinder3D matrix3D transformation.
Parameters:
-
cylinder
(Cylinder3D
) –Cylinder3D which will be transformed
-
matrix
(Matrix3D
) –Transformation 3D Matrix.
Warning: Perspective transformation will not work correctly
Transform(ellipsoid: Ellipsoid3D, matrix: Matrix2D) -> Ellipsoid3D
Ellipsoid3D matrix2D transformation.
Parameters:
-
ellipsoid
(Ellipsoid3D
) –Ellipsoid3D which will be transformed
-
matrix
(Matrix2D
) –Transformation 2D Matrix.
Warning: Perspective transformation will not work correctly
Transform(ellipsoid: Ellipsoid3D, matrix: Matrix3D) -> Ellipsoid3D
Ellipsoid3D matrix3D transformation.
Parameters:
-
ellipsoid
(Ellipsoid3D
) –Ellipsoid3D which will be transformed
-
matrix
(Matrix3D
) –Transformation 3D Matrix.
Warning: Perspective transformation will not work correctly
Trim
overloaded
Trim(
spline: Spline2D,
useStartSpline: bool,
point1: Point2D,
useEndSpline: bool,
point2: Point2D,
splineTol: float,
) -> tuple[eSplitResult, Spline2D]
Trim a Spline2D by given trim points
Flags useStartSpline, useEndSpline are optional and can not be never used, but if these flags are used, then calculation is faster. point1 and point2 are ordered during trimming when flags for spline points are not using. If spline flags is used, then point1 is always start point and pont2 is always end point of trimming. In this case, Trim function return SPLIT_INVALID_ARGS when points are in reversed order.
Parameters:
-
spline
(Spline2D
) –The spline to split
-
useStartSpline
(bool
) –True when trimming is from beginning of spline, point1 is ignored
-
point1
(Point2D
) –The given trimming point1 (e.g. intersection points onto the spline)
-
useEndSpline
(bool
) –True when trimming is to end of spline, point2 is ignored
-
point2
(Point2D
) –The given trimming point2 (e.g. intersection points onto the spline)
-
splineTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, Spline2D]
–tuple(eSplitResult, SPLIT_OK on success, Trimmed spline)
Trim(
clothoid: Clothoid2D,
useStartClothoid: bool,
point1: Point2D,
useEndClothoid: bool,
point2: Point2D,
clothoidTol: float,
) -> tuple[eSplitResult, Clothoid2D]
Trim a Clothoid2D by given trim points
Flags useStartClothoid, useEndClothoid are optional and can not be never used, but if these flags are used, then calculation is faster. point1 and point2 are ordered during trimming when flags for clothoid points are not using. If clothoid flags is used, then point1 is always start point and pont2 is always end point of trimming. In this case, Trim function return SPLIT_INVALID_ARGS when points are in reversed order.
Parameters:
-
clothoid
(Clothoid2D
) –The clothoid to split
-
useStartClothoid
(bool
) –True when trimming is from beginning of clothoid, point1 is ignored
-
point1
(Point2D
) –The given trimming point1 (e.g. intersection points onto the clothoid)
-
useEndClothoid
(bool
) –True when trimming is to end of clothoid, point2 is ignored
-
point2
(Point2D
) –The given trimming point2 (e.g. intersection points onto the clothoid)
-
clothoidTol
(float
) –Tolerance being used to determine the position of split points on the input curve
Returns:
-
tuple[eSplitResult, Clothoid2D]
–tuple(eSplitResult, SPLIT_OK on success, Trimmed clothoid)