The CSOGeometry namespace offers some common methods for various geometric problems, e.g., determining whether a CSO lies in a plane, if a CSO is self-intersection, computing the center of gravity, thinning out path points or applying Boolean operations. More...

Classes
class	CSOPlaneGuard

class	PositionObj

Enumerations
enum	ReductionMode { REDUCTION_MODE_ANGLE = 0 , REDUCTION_MODE_LENGTH , REDUCTION_MODE_ANGLE_AND_LENGTH }

Functions
MLCSO_EXPORT bool	computeIsInPlane (const CSO *cso, Vector3 &planeNormal, double angleEpsilon=1e-3, double collinearEpsilon=1e-3)
	Returns whether all the path points lie in one plane, and fills the plane normal.

MLCSO_EXPORT bool	computeIsInPlane (const std::vector< Vector3 > &points, Vector3 &planeNormal, double angleEpsilon=1e-3, double collinearEpsilon=1e-3)
	Returns whether the given positions form a contour that is in-plane.

MLCSO_EXPORT Vector3	computeNewellsNormal (const std::vector< Vector3 > &points)
	Returns a normal for the given list of points using Newell's method.

MLCSO_EXPORT bool	arePointsCollinear (const std::vector< Vector3 > &points, double epsilon)
	Returns whether all points are collinear.

MLCSO_EXPORT bool	isSelfIntersecting (const std::vector< Vector3 > &positions, std::vector< Vector3 > &intersectPoints, bool isClosed)
	Returns whether the given list of points interpreted as a contour intersects itself.

MLCSO_EXPORT bool	isSelfIntersecting (const std::vector< Vector3 > &positions, bool isClosed)
	Returns whether the given list of points interpreted as a contour intersects itself.

MLCSO_EXPORT bool	isSelfIntersecting (const CSO *cso)
	Returns whether the given contour intersects itself.

MLCSO_EXPORT bool	isSelfIntersecting (const CSO *cso, std::vector< Vector3 > &intersectPositions)
	Returns whether the given contour intersects itself. Fills up the given `intersectPositions` vector.

MLCSO_EXPORT double	computeSegmentSegmentDistance (const Vector3 &start0, const Vector3 &end0, const Vector3 &start1, const Vector3 &end1, Vector3 &intersectionPoint, bool &isParallel)
	Returns the minimum distance between the two given segments. If this distance is 0, the intersectionPoint is valid.

MLCSO_EXPORT double	computeSegmentSegmentDistance (const Vector3 &start0, const Vector3 &end0, const Vector3 &start1, const Vector3 &end1, Vector3 &intersectionPoint)
	/deprecated

MLCSO_EXPORT int	intersect2DSegments (const Vector2 &start0, const Vector2 &end0, const Vector2 &start1, const Vector2 &end1, Vector2 &intersection0, Vector2 &intersection1)
	Computes whether the two given 2D segments intersect; if they intersect, the intersection point is valid.

bool	isInSegment (const Vector2 &point, const Vector2 &segmentStart, const Vector2 &segmentEnd)
	Helper function for intersect2DSegments.

MLdouble	perp (const Vector2 &v0, const Vector2 &v1)
	Helper function for intersect2DSegments.

MLCSO_EXPORT bool	areInSamePlane (const CSO cso0, const CSO cso1, MLdouble angleEpsilon=10e-5, MLdouble minPlaneDistanceInMM=10e-5)
	Returns whether the two given CSOs lie in the same plane.

MLCSO_EXPORT bool	areOverlapping (const CSO cso0, const CSO cso1, MLdouble epsilon=10e-5, MLdouble minPlaneDistanceInMM=10e-5)
	Returns whether any path point of cso0 is within cso1 or vice versa.

MLCSO_EXPORT void	rotateAndProject (Rotation &rot, Vector3 &voxelPos, bool shouldProject=true)
	Transforms and projects a voxelPos according to a rotation.

MLCSO_EXPORT void	level (CSO *cso)
	Determines the normal and the center of gravity of the given CSO.

MLCSO_EXPORT void	level (std::vector< Vector3 > &positions)
	Levels the given positions so that they all lie on the average plane of the input positions.

MLCSO_EXPORT void	levelToPlane (CSO &cso, const Vector3 &normal, const Vector3 &planeAnchorPoint)
	Projects all seed points and all path points to the plane that is defined by the given normal and plane anchor point.

MLCSO_EXPORT std::vector< Vector2 >	projectTo2D (const std::vector< Vector3 > &points, const Vector3 &normal, const Vector3 &planeAnchorPoint)
	Projects the 3D points to 2D by subtracting planeAnchorPoint, rotating from the normal vector to (0,0,1) and discarding the z positions.

MLCSO_EXPORT std::vector< Vector3 >	backprojectTo3D (const std::vector< Vector2 > &points, const Vector3 &normal, const Vector3 &planeAnchorPoint)
	Back-projects the 2D points to 3D by rotating from (0,0,1) to the normal vector and adding planeAnchorPoint.

MLCSO_EXPORT double	getLargestDistanceBetweenAllPathPoints (CSO &cso, Vector3 &point0, Vector3 &point1)
	Returns the largest distance between any of the path points of the CSO.

MLCSO_EXPORT void	translate (CSO *cso, const Vector3 &translation)
	Translates a CSO with all its seed- and path points by the given translation vector.

MLCSO_EXPORT bool	isPointInsidePolygon (const std::vector< Vector3 > &polygonPoints, const Vector3 &point)
	Returns whether a point is inside the polygon defined by the given list of positions.

MLCSO_EXPORT void	appendUniquePosition (std::vector< Vector3 > &positions, Vector3 pos)
	Appends a new point to the given vector without double insertions.

MLCSO_EXPORT Vector3	getCenterOfGravity (CSO *cso, bool considerSeedPointsExtra=false)
	Returns the center of gravity of a given CSO.

MLCSO_EXPORT Vector3	getCenterOfGravity (const std::vector< Vector3 > &positions)
	Returns the center of gravity of the given positions.

MLCSO_EXPORT double	distanceToLine (const Vector3 &point, const Vector3 &linePoint1, const Vector3 &linePoint2)
	Computes distance of point to (infinite) line given by two other points:

MLCSO_EXPORT double	squaredDistanceToLineSegment (const Vector3 &point, const Vector3 &linePoint1, const Vector3 &linePoint2)
	Computes the squared distance of point to line segment given by two other points.

MLCSO_EXPORT double	squaredDistanceToLineSegment (const Vector3 &point, const Vector3 &linePoint1, const Vector3 &linePoint2, Vector3 &resultPoint)
	Computes the squared distance of point to line segment given by two other points.

MLCSO_EXPORT double	squaredDistanceToLineSegment (const Vector2 &point, const Vector2 &linePoint1, const Vector2 &linePoint2)
	Computes the squared distance of point to line segment given by two other points.

MLCSO_EXPORT void	computeClosestSeedPoint (CSO *cso, const Vector3 &referencePoint, unsigned int &resultSeedPointIndex)
	Returns the closest point on a cso to the given reference point.

MLCSO_EXPORT void	computeClosestPathPoint (CSO *cso, const Vector3 &referencePoint, unsigned int &resultPathPointListIndex, unsigned int &resultPathPointIndex, Vector3 &resultPosition)
	Returns the closest path point of a cso to the given reference point without interpolation.

MLCSO_EXPORT void	computeClosestPoint (CSO *cso, const Vector3 &referencePoint, unsigned int &resultPathPointListIndex, unsigned int &resultPathPointIndex, Vector3 &resultPosition)
	Returns the closest point on a cso to the given reference point. Interpolates the closest point on the line segments.

MLCSO_EXPORT void	computeClosestPoint (const std::vector< Vector3 > &pointList, const Vector3 &referencePoint, unsigned int &resultPointIndex, Vector3 &resultPosition)
	Returns the closest point on the given list of positions.

MLCSO_EXPORT double	computeDistance (CSO *cso, const Vector3 &referencePoint)
	Returns the distance of the given point to the given CSO .

MLCSO_EXPORT double	computeLength (const CSOPathPointIterator &startIter, const CSOPathPointIterator &endIter)
	Computes the length of a CSO between two PathPointIterators.

MLCSO_EXPORT double	computeDiameter (const CSO *cso)
	Computes the maximum distance between any two path points in the given CSO.

MLCSO_EXPORT double	computeDiameter (const std::vector< Vector3 > &positions)
	Computes the maximum distance between any two points in the given vector.

MLCSO_EXPORT void	thinOutCSO (CSO *cso, float quality=0.5f, ReductionMode reductionMode=REDUCTION_MODE_ANGLE_AND_LENGTH, unsigned int minPoints=5, float maxAngleLimit=1.0)
	Thins out the given cso by removing all positions that do not contribute to the overall geometry (angle and length criterion).

MLCSO_EXPORT void	thinOutPointList (std::vector< Vector3 > &positionList, float quality=0.5f, ReductionMode reductionMode=REDUCTION_MODE_ANGLE_AND_LENGTH, unsigned int minPoints=5, float maxAngleLimit=1.0)
	Thins out the given list of positions by removing all positions that do not contribute to the overall geometry (angle and length criterion).

MLCSO_EXPORT bool	csoIsEnclosedByCSO (CSO toTestInnerCSO, CSO toTestOuterCSO)
	Returns whether the first given CSO lies fully within the second given CSO without crossing.

MLCSO_EXPORT size_t	getLevelOfEmbedding (const CSOListPtr &csoList, std::vector< size_t > &result)
	Writes the level of embedding of the CSOs in the given CSOList into the given vector of integers.

MLCSO_EXPORT size_t	getLevelOfEmbedding (const std::vector< CSO * > &csos, std::vector< size_t > &result, std::vector< std::vector< size_t > > &enclosedCSOIndices)
	Extension of getLevelOfEmbedding which also records the indices of the CSOs enclosed by each CSO.

MLCSO_EXPORT void	groupByLevelOfEmbedding (const std::vector< CSO * > &csos, std::vector< std::vector< CSO * > > &groupedCSOs)
	Arranges the given CSOs into a vector of vectors so that CSOs embedded into each other are grouped together with increasing level of embedding.

MLCSO_EXPORT double	computeSumOfAreas (const CSOListPtr &csoList)
	Returns the sum of areas of all CSOs in csoList. Area is counted negative if level of embedding is odd.

MLCSO_EXPORT double	computeVolume (const CSOListPtr &csoList, double sliceThickness)
	Returns the sum of areas of all CSOs in csoList, multiplied by the given sliceThickness, in ml.

MLCSO_EXPORT bool	isApproximatelyParallel (const CSO *cso, const Vector3 &normal, double epsilon=0.1)
	Returns whether the given CSO is approximately parallel to a plane given by the normal vector.

template<class T >
bool	isSamePosition (const T &pos1, const T &pos2)
	Returns true if the two positions are considered equal as points of a CSO.

Variables
const double	maxPointDiff = 10e-6
	Maximum distance of 2 points in each axis to be considered equal.

const unsigned int	INVALID_INDEX = static_cast<unsigned int>(-1)
	A symbolic value that indicates an invalid index (-1).

Detailed Description

The CSOGeometry namespace offers some common methods for various geometric problems, e.g., determining whether a CSO lies in a plane, if a CSO is self-intersection, computing the center of gravity, thinning out path points or applying Boolean operations.

Enumeration Type Documentation

◆ ReductionMode

enum ml::CSOGeometry::ReductionMode

Enumerator
REDUCTION_MODE_ANGLE
REDUCTION_MODE_LENGTH
REDUCTION_MODE_ANGLE_AND_LENGTH

Definition at line 52 of file CSOGeometry.h.

Function Documentation

◆ appendUniquePosition()

MLCSO_EXPORT void ml::CSOGeometry::appendUniquePosition	(	std::vector< Vector3 > &	positions,
		Vector3	pos )

Appends a new point to the given vector without double insertions.

References appendUniquePosition().

Referenced by appendUniquePosition().

◆ areInSamePlane()

MLCSO_EXPORT bool ml::CSOGeometry::areInSamePlane	(	const CSO *	cso0,
		const CSO *	cso1,
		MLdouble	angleEpsilon = 10e-5,
		MLdouble	minPlaneDistanceInMM = 10e-5 )

Returns whether the two given CSOs lie in the same plane.

References areInSamePlane().

Referenced by areInSamePlane().

◆ areOverlapping()

MLCSO_EXPORT bool ml::CSOGeometry::areOverlapping	(	const CSO *	cso0,
		const CSO *	cso1,
		MLdouble	epsilon = 10e-5,
		MLdouble	minPlaneDistanceInMM = 10e-5 )

Returns whether any path point of cso0 is within cso1 or vice versa.

References areOverlapping().

Referenced by areOverlapping().

◆ arePointsCollinear()

MLCSO_EXPORT bool ml::CSOGeometry::arePointsCollinear	(	const std::vector< Vector3 > &	points,
		double	epsilon )

Returns whether all points are collinear.

One point is assumed to be not collinear. The algorithm computes a line going through the first two points and then measures the distances of the remaining points to this line. If all distances are smaller than epsilon, the points are assumed to be collinear.

References arePointsCollinear().

Referenced by arePointsCollinear().

◆ backprojectTo3D()

MLCSO_EXPORT std::vector< Vector3 > ml::CSOGeometry::backprojectTo3D	(	const std::vector< Vector2 > &	points,
		const Vector3 &	normal,
		const Vector3 &	planeAnchorPoint )

Back-projects the 2D points to 3D by rotating from (0,0,1) to the normal vector and adding planeAnchorPoint.

References backprojectTo3D().

Referenced by backprojectTo3D().

◆ computeClosestPathPoint()

MLCSO_EXPORT void ml::CSOGeometry::computeClosestPathPoint	(	CSO *	cso,
		const Vector3 &	referencePoint,
		unsigned int &	resultPathPointListIndex,
		unsigned int &	resultPathPointIndex,
		Vector3 &	resultPosition )

Returns the closest path point of a cso to the given reference point without interpolation.

References computeClosestPathPoint().

Referenced by computeClosestPathPoint().

◆ computeClosestPoint() [1/2]

MLCSO_EXPORT void ml::CSOGeometry::computeClosestPoint	(	const std::vector< Vector3 > &	pointList,
		const Vector3 &	referencePoint,
		unsigned int &	resultPointIndex,
		Vector3 &	resultPosition )

Returns the closest point on the given list of positions.

References computeClosestPoint().

◆ computeClosestPoint() [2/2]

MLCSO_EXPORT void ml::CSOGeometry::computeClosestPoint	(	CSO *	cso,
		const Vector3 &	referencePoint,
		unsigned int &	resultPathPointListIndex,
		unsigned int &	resultPathPointIndex,
		Vector3 &	resultPosition )

Returns the closest point on a cso to the given reference point. Interpolates the closest point on the line segments.

References computeClosestPoint().

Referenced by computeClosestPoint(), and computeClosestPoint().

◆ computeClosestSeedPoint()

MLCSO_EXPORT void ml::CSOGeometry::computeClosestSeedPoint	(	CSO *	cso,
		const Vector3 &	referencePoint,
		unsigned int &	resultSeedPointIndex )

Returns the closest point on a cso to the given reference point.

References computeClosestSeedPoint().

Referenced by computeClosestSeedPoint().

◆ computeDiameter() [1/2]

MLCSO_EXPORT double ml::CSOGeometry::computeDiameter ( const CSO * cso )

Computes the maximum distance between any two path points in the given CSO.

References computeDiameter().

Referenced by computeDiameter(), and computeDiameter().

◆ computeDiameter() [2/2]

MLCSO_EXPORT double ml::CSOGeometry::computeDiameter ( const std::vector< Vector3 > & positions )

Computes the maximum distance between any two points in the given vector.

References computeDiameter().

◆ computeDistance()

MLCSO_EXPORT double ml::CSOGeometry::computeDistance	(	CSO *	cso,
		const Vector3 &	referencePoint )

Returns the distance of the given point to the given CSO .

References computeDistance().

Referenced by computeDistance().

◆ computeIsInPlane() [1/2]

MLCSO_EXPORT bool ml::CSOGeometry::computeIsInPlane	(	const CSO *	cso,
		Vector3 &	planeNormal,
		double	angleEpsilon = 1e-3,
		double	collinearEpsilon = 1e-3 )

Returns whether all the path points lie in one plane, and fills the plane normal.

Note that a CSO forming a straight line is not considered to be 'in plane' as it lies in an infinite number of planes. A collinearity check is performed by calling arePointsCollinear with epsilon2. The algorithm computes the plane normal using Newell's method and tests whether the vectors starting at the first path point and ending at the remaining path points are perpendicular to that plane. The vectors are perpendicular if their dot product is less than epsilon1.

References computeIsInPlane().

Referenced by computeIsInPlane(), and computeIsInPlane().

◆ computeIsInPlane() [2/2]

MLCSO_EXPORT bool ml::CSOGeometry::computeIsInPlane	(	const std::vector< Vector3 > &	points,
		Vector3 &	planeNormal,
		double	angleEpsilon = 1e-3,
		double	collinearEpsilon = 1e-3 )

Returns whether the given positions form a contour that is in-plane.

References computeIsInPlane().

◆ computeLength()

MLCSO_EXPORT double ml::CSOGeometry::computeLength	(	const CSOPathPointIterator &	startIter,
		const CSOPathPointIterator &	endIter )

Computes the length of a CSO between two PathPointIterators.

References computeLength().

Referenced by computeLength().

◆ computeNewellsNormal()

MLCSO_EXPORT Vector3 ml::CSOGeometry::computeNewellsNormal ( const std::vector< Vector3 > & points )

Returns a normal for the given list of points using Newell's method.

References computeNewellsNormal().

Referenced by computeNewellsNormal().

◆ computeSegmentSegmentDistance() [1/2]

MLCSO_EXPORT double ml::CSOGeometry::computeSegmentSegmentDistance	(	const Vector3 &	start0,
		const Vector3 &	end0,
		const Vector3 &	start1,
		const Vector3 &	end1,
		Vector3 &	intersectionPoint )

/deprecated

◆ computeSegmentSegmentDistance() [2/2]

MLCSO_EXPORT double ml::CSOGeometry::computeSegmentSegmentDistance	(	const Vector3 &	start0,
		const Vector3 &	end0,
		const Vector3 &	start1,
		const Vector3 &	end1,
		Vector3 &	intersectionPoint,
		bool &	isParallel )

Returns the minimum distance between the two given segments. If this distance is 0, the intersectionPoint is valid.

◆ computeSumOfAreas()

MLCSO_EXPORT double ml::CSOGeometry::computeSumOfAreas ( const CSOListPtr & csoList )

Returns the sum of areas of all CSOs in csoList. Area is counted negative if level of embedding is odd.

References computeSumOfAreas().

Referenced by computeSumOfAreas().

◆ computeVolume()

MLCSO_EXPORT double ml::CSOGeometry::computeVolume	(	const CSOListPtr &	csoList,
		double	sliceThickness )

Returns the sum of areas of all CSOs in csoList, multiplied by the given sliceThickness, in ml.

Raises error when CSOs are not parallel.

References computeVolume().

Referenced by computeVolume().

◆ csoIsEnclosedByCSO()

MLCSO_EXPORT bool ml::CSOGeometry::csoIsEnclosedByCSO	(	CSO *	toTestInnerCSO,
		CSO *	toTestOuterCSO )

Returns whether the first given CSO lies fully within the second given CSO without crossing.

References csoIsEnclosedByCSO().

Referenced by csoIsEnclosedByCSO().

◆ distanceToLine()

MLCSO_EXPORT double ml::CSOGeometry::distanceToLine	(	const Vector3 &	point,
		const Vector3 &	linePoint1,
		const Vector3 &	linePoint2 )

Computes distance of point to (infinite) line given by two other points:

References distanceToLine().

Referenced by distanceToLine().

◆ getCenterOfGravity() [1/2]

MLCSO_EXPORT Vector3 ml::CSOGeometry::getCenterOfGravity ( const std::vector< Vector3 > & positions )

Returns the center of gravity of the given positions.

References getCenterOfGravity().

◆ getCenterOfGravity() [2/2]

MLCSO_EXPORT Vector3 ml::CSOGeometry::getCenterOfGravity	(	CSO *	cso,
		bool	considerSeedPointsExtra = false )

Returns the center of gravity of a given CSO.

An optional parameter can cause the seed points to be considered for the calculation (default = false), for example, if they are not positioned on the paths themselves.

References getCenterOfGravity().

Referenced by getCenterOfGravity(), and getCenterOfGravity().

◆ getLargestDistanceBetweenAllPathPoints()

MLCSO_EXPORT double ml::CSOGeometry::getLargestDistanceBetweenAllPathPoints	(	CSO &	cso,
		Vector3 &	point0,
		Vector3 &	point1 )

Returns the largest distance between any of the path points of the CSO.

If the CSO has a plane normal, the calculation is done in O(N * log(N)), if the CSO does not lie in a plane the calculation is done in O(N*N). This method also returns the two points that are furthest apart.

References getLargestDistanceBetweenAllPathPoints().

Referenced by getLargestDistanceBetweenAllPathPoints().

◆ getLevelOfEmbedding() [1/2]

MLCSO_EXPORT size_t ml::CSOGeometry::getLevelOfEmbedding	(	const CSOListPtr &	csoList,
		std::vector< size_t > &	result )

Writes the level of embedding of the CSOs in the given CSOList into the given vector of integers.

Returns the maximum level of embedding. An odd number indicates an inner CSO, an even number an outer CSO. Note that the inner CSO of an inner CSO is considered an outer CSO again.

References getLevelOfEmbedding().

Referenced by getLevelOfEmbedding(), and getLevelOfEmbedding().

◆ getLevelOfEmbedding() [2/2]

MLCSO_EXPORT size_t ml::CSOGeometry::getLevelOfEmbedding	(	const std::vector< CSO * > &	csos,
		std::vector< size_t > &	result,
		std::vector< std::vector< size_t > > &	enclosedCSOIndices )

Extension of getLevelOfEmbedding which also records the indices of the CSOs enclosed by each CSO.

The input is a vector of CSOs to make it usable for CSOLists, CSOGroups or custom collections of CSOs.

References getLevelOfEmbedding().

◆ groupByLevelOfEmbedding()

MLCSO_EXPORT void ml::CSOGeometry::groupByLevelOfEmbedding	(	const std::vector< CSO * > &	csos,
		std::vector< std::vector< CSO * > > &	groupedCSOs )

Arranges the given CSOs into a vector of vectors so that CSOs embedded into each other are grouped together with increasing level of embedding.

The input is a vector of CSOs to make it usable for CSOLists, CSOGroups, or custom collections of CSOs.

References groupByLevelOfEmbedding().

Referenced by groupByLevelOfEmbedding().

◆ intersect2DSegments()

MLCSO_EXPORT int ml::CSOGeometry::intersect2DSegments	(	const Vector2 &	start0,
		const Vector2 &	end0,
		const Vector2 &	start1,
		const Vector2 &	end1,
		Vector2 &	intersection0,
		Vector2 &	intersection1 )

Computes whether the two given 2D segments intersect; if they intersect, the intersection point is valid.

Returns 0 if no intersection, 1 if intersects, and 2 if overlap from intersection0 to intersection1.

References intersect2DSegments().

Referenced by intersect2DSegments().

◆ isApproximatelyParallel()

MLCSO_EXPORT bool ml::CSOGeometry::isApproximatelyParallel	(	const CSO *	cso,
		const Vector3 &	normal,
		double	epsilon = 0.1 )

Returns whether the given CSO is approximately parallel to a plane given by the normal vector.

The optional thickness parameter epsilon is a limit to the thickness of the point cloud of the CSO points in direction of the normal. This method can also be used to determine if a CSO is in-plane with a very small epsilon value and a normal pointing into the same direction as the assumed CSO's normal.

References isApproximatelyParallel().

Referenced by isApproximatelyParallel().

◆ isInSegment()

bool ml::CSOGeometry::isInSegment	(	const Vector2 &	point,
		const Vector2 &	segmentStart,
		const Vector2 &	segmentEnd )

Helper function for intersect2DSegments.

References isInSegment().

Referenced by isInSegment().

◆ isPointInsidePolygon()

MLCSO_EXPORT bool ml::CSOGeometry::isPointInsidePolygon	(	const std::vector< Vector3 > &	polygonPoints,
		const Vector3 &	point )

Returns whether a point is inside the polygon defined by the given list of positions.

Make sure that the point and the list of positions lie both in the z-plane (the plane with the z-axis as the normal).

References isPointInsidePolygon().

Referenced by isPointInsidePolygon().

◆ isSamePosition()

template<class T >

bool ml::CSOGeometry::isSamePosition	(	const T &	pos1,
		const T &	pos2 )

inline

Returns true if the two positions are considered equal as points of a CSO.

Definition at line 223 of file CSOGeometry.h.

References isSamePosition(), maxPointDiff, and mlrange_cast().

Referenced by isSamePosition().

◆ isSelfIntersecting() [1/4]

MLCSO_EXPORT bool ml::CSOGeometry::isSelfIntersecting ( const CSO * cso )

Returns whether the given contour intersects itself.

References isSelfIntersecting().

◆ isSelfIntersecting() [2/4]

MLCSO_EXPORT bool ml::CSOGeometry::isSelfIntersecting	(	const CSO *	cso,
		std::vector< Vector3 > &	intersectPositions )

Returns whether the given contour intersects itself. Fills up the given intersectPositions vector.

References isSelfIntersecting().

◆ isSelfIntersecting() [3/4]

MLCSO_EXPORT bool ml::CSOGeometry::isSelfIntersecting	(	const std::vector< Vector3 > &	positions,
		bool	isClosed )

Returns whether the given list of points interpreted as a contour intersects itself.

References isSelfIntersecting().

◆ isSelfIntersecting() [4/4]

MLCSO_EXPORT bool ml::CSOGeometry::isSelfIntersecting	(	const std::vector< Vector3 > &	positions,
		std::vector< Vector3 > &	intersectPoints,
		bool	isClosed )

Returns whether the given list of points interpreted as a contour intersects itself.

Fills up the given intersectPoints vector.

References isSelfIntersecting().

Referenced by isSelfIntersecting(), isSelfIntersecting(), isSelfIntersecting(), and isSelfIntersecting().

◆ level() [1/2]

MLCSO_EXPORT void ml::CSOGeometry::level ( CSO * cso )

Determines the normal and the center of gravity of the given CSO.

Then, all seed points and all path points are projected onto the plane that is defined by the normal and the point (CoG). In case you know the plane to which the CSO should be leveled, please use the levelToPlane method instead

References level().

Referenced by level(), and level().

◆ level() [2/2]

MLCSO_EXPORT void ml::CSOGeometry::level ( std::vector< Vector3 > & positions )

Levels the given positions so that they all lie on the average plane of the input positions.

References level().

◆ levelToPlane()

MLCSO_EXPORT void ml::CSOGeometry::levelToPlane	(	CSO &	cso,
		const Vector3 &	normal,
		const Vector3 &	planeAnchorPoint )

Projects all seed points and all path points to the plane that is defined by the given normal and plane anchor point.

References levelToPlane().

Referenced by levelToPlane().

◆ perp()

MLdouble ml::CSOGeometry::perp	(	const Vector2 &	v0,
		const Vector2 &	v1 )

Helper function for intersect2DSegments.

References perp().

Referenced by perp().

◆ projectTo2D()

MLCSO_EXPORT std::vector< Vector2 > ml::CSOGeometry::projectTo2D	(	const std::vector< Vector3 > &	points,
		const Vector3 &	normal,
		const Vector3 &	planeAnchorPoint )

Projects the 3D points to 2D by subtracting planeAnchorPoint, rotating from the normal vector to (0,0,1) and discarding the z positions.

References projectTo2D().

Referenced by projectTo2D().

◆ rotateAndProject()

MLCSO_EXPORT void ml::CSOGeometry::rotateAndProject	(	Rotation &	rot,
		Vector3 &	voxelPos,
		bool	shouldProject = true )

Transforms and projects a voxelPos according to a rotation.

Make sure that the rotation rotates the voxelPos to the z-plane (the plane with the z-axis as a normal).

References rotateAndProject().

Referenced by rotateAndProject().

◆ squaredDistanceToLineSegment() [1/3]

MLCSO_EXPORT double ml::CSOGeometry::squaredDistanceToLineSegment	(	const Vector2 &	point,
		const Vector2 &	linePoint1,
		const Vector2 &	linePoint2 )

Computes the squared distance of point to line segment given by two other points.

References squaredDistanceToLineSegment().

◆ squaredDistanceToLineSegment() [2/3]

MLCSO_EXPORT double ml::CSOGeometry::squaredDistanceToLineSegment	(	const Vector3 &	point,
		const Vector3 &	linePoint1,
		const Vector3 &	linePoint2 )

Computes the squared distance of point to line segment given by two other points.

References squaredDistanceToLineSegment().

Referenced by squaredDistanceToLineSegment(), squaredDistanceToLineSegment(), and squaredDistanceToLineSegment().

◆ squaredDistanceToLineSegment() [3/3]

MLCSO_EXPORT double ml::CSOGeometry::squaredDistanceToLineSegment	(	const Vector3 &	point,
		const Vector3 &	linePoint1,
		const Vector3 &	linePoint2,
		Vector3 &	resultPoint )

Computes the squared distance of point to line segment given by two other points.

References squaredDistanceToLineSegment().

◆ thinOutCSO()

MLCSO_EXPORT void ml::CSOGeometry::thinOutCSO	(	CSO *	cso,
		float	quality = 0.5f,
		ReductionMode	reductionMode = REDUCTION_MODE_ANGLE_AND_LENGTH,
		unsigned int	minPoints = 5,
		float	maxAngleLimit = 1.0 )

Thins out the given cso by removing all positions that do not contribute to the overall geometry (angle and length criterion).

This function is a modification of CSOMath::thinOutPathPoints(...).

References thinOutCSO().

Referenced by thinOutCSO().

◆ thinOutPointList()

MLCSO_EXPORT void ml::CSOGeometry::thinOutPointList	(	std::vector< Vector3 > &	positionList,
		float	quality = 0.5f,
		ReductionMode	reductionMode = REDUCTION_MODE_ANGLE_AND_LENGTH,
		unsigned int	minPoints = 5,
		float	maxAngleLimit = 1.0 )

Thins out the given list of positions by removing all positions that do not contribute to the overall geometry (angle and length criterion).

References thinOutPointList().

Referenced by thinOutPointList().

◆ translate()

MLCSO_EXPORT void ml::CSOGeometry::translate	(	CSO *	cso,
		const Vector3 &	translation )

Translates a CSO with all its seed- and path points by the given translation vector.

References translate().

Referenced by translate().

Variable Documentation

◆ INVALID_INDEX

const unsigned int ml::CSOGeometry::INVALID_INDEX = static_cast<unsigned int>(-1)

A symbolic value that indicates an invalid index (-1).

Definition at line 234 of file CSOGeometry.h.

◆ maxPointDiff

const double ml::CSOGeometry::maxPointDiff = 10e-6

Maximum distance of 2 points in each axis to be considered equal.

Definition at line 50 of file CSOGeometry.h.

Referenced by isSamePosition().

Classes

Enumerations

Functions

Variables

Detailed Description

Enumeration Type Documentation

◆ ReductionMode

Function Documentation

◆ appendUniquePosition()

◆ areInSamePlane()

◆ areOverlapping()

◆ arePointsCollinear()

◆ backprojectTo3D()

◆ computeClosestPathPoint()

◆ computeClosestPoint() [1/2]

◆ computeClosestPoint() [2/2]

◆ computeClosestSeedPoint()

◆ computeDiameter() [1/2]

◆ computeDiameter() [2/2]

◆ computeDistance()

◆ computeIsInPlane() [1/2]

◆ computeIsInPlane() [2/2]

◆ computeLength()

◆ computeNewellsNormal()

◆ computeSegmentSegmentDistance() [1/2]

◆ computeSegmentSegmentDistance() [2/2]

◆ computeSumOfAreas()

◆ computeVolume()

◆ csoIsEnclosedByCSO()

◆ distanceToLine()

◆ getCenterOfGravity() [1/2]

◆ getCenterOfGravity() [2/2]

◆ getLargestDistanceBetweenAllPathPoints()

◆ getLevelOfEmbedding() [1/2]

◆ getLevelOfEmbedding() [2/2]

◆ groupByLevelOfEmbedding()

◆ intersect2DSegments()

◆ isApproximatelyParallel()

◆ isInSegment()

◆ isPointInsidePolygon()

◆ isSamePosition()

◆ isSelfIntersecting() [1/4]

◆ isSelfIntersecting() [2/4]

◆ isSelfIntersecting() [3/4]

◆ isSelfIntersecting() [4/4]

◆ level() [1/2]

◆ level() [2/2]

◆ levelToPlane()

◆ perp()

◆ projectTo2D()

◆ rotateAndProject()

◆ squaredDistanceToLineSegment() [1/3]

◆ squaredDistanceToLineSegment() [2/3]

◆ squaredDistanceToLineSegment() [3/3]

◆ thinOutCSO()

◆ thinOutPointList()

◆ translate()

Variable Documentation

◆ INVALID_INDEX

◆ maxPointDiff