Lightweight SE(2)/SE(3) types, geometry functions.

static constexpr unsigned char mrpt::math::GEOMETRIC_TYPE_SEGMENT = 1

Object type identifier for TSegment2D or TSegment3D.

See also:

static constexpr unsigned char mrpt::math::GEOMETRIC_TYPE_LINE = 2

Object type identifier for TLine2D or TLine3D.

See also:

static constexpr unsigned char mrpt::math::GEOMETRIC_TYPE_POLYGON = 3

Object type identifier for TPolygon2D or TPolygon3D.

See also:

static constexpr unsigned char mrpt::math::GEOMETRIC_TYPE_PLANE = 4

Object type identifier for TPlane.

See also:

static constexpr unsigned char mrpt::math::GEOMETRIC_TYPE_UNDEFINED = 255

Object type identifier for empty TObject2D or TObject3D.

See also:

Global Functions

bool mrpt::math::intersect(const TSegment3D& s1, const TSegment3D& s2, TObject3D& obj)

Gets the intersection between two 3D segments.

Possible outcomes:

Segments intersect: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT
Segments don’t intersect & are parallel: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT, obj is the segment “in between” both segments.
Segments don’t intersect & aren’t parallel: Return=false.

See also:

bool mrpt::math::intersect(const TSegment3D& s1, const TPlane& p2, TObject3D& obj)

Gets the intersection between a 3D segment and a plane.

Possible outcomes:

Don’t intersect: Return=false
s1 is within the plane: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
s1 intersects the plane at one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TSegment3D& s1, const TLine3D& r2, TObject3D& obj)

Gets the intersection between a 3D segment and a 3D line.

Possible outcomes:

They don’t intersect : Return=false
s1 lies within the line: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
s1 intersects the line at a point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TPlane& p1, const TSegment3D& s2, TObject3D& obj)

Gets the intersection between a plane and a 3D segment.

Possible outcomes:

Don’t intersect: Return=false
s2 is within the plane: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
s2 intersects the plane at one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TPlane& p1, const TPlane& p2, TObject3D& obj)

Gets the intersection between two planes.

Possible outcomes:

Planes are parallel: Return=false
Planes intersect into a line: Return=true, obj.getType()=GEOMETRIC_TYPE_LINE

See also:

bool mrpt::math::intersect(const TPlane& p1, const TLine3D& p2, TObject3D& obj)

Gets the intersection between a plane and a 3D line.

Possible outcomes:

Line is parallel to plane but not within it: Return=false
Line is contained in the plane: Return=true, obj.getType()=GEOMETRIC_TYPE_LINE
Line intersects the plane at one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TLine3D& r1, const TSegment3D& s2, TObject3D& obj)

Gets the intersection between a 3D line and a 3D segment.

Possible outcomes:

They don’t intersect : Return=false
s2 lies within the line: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
s2 intersects the line at a point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TLine3D& r1, const TPlane& p2, TObject3D& obj)

Gets the intersection between a 3D line and a plane.

Possible outcomes:

Line is parallel to plane but not within it: Return=false
Line is contained in the plane: Return=true, obj.getType()=GEOMETRIC_TYPE_LINE
Line intersects the plane at one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TLine3D& r1, const TLine3D& r2, TObject3D& obj)

Gets the intersection between two 3D lines.

Possible outcomes:

Lines do not intersect: Return=false
Lines are parallel and do not coincide: Return=false
Lines coincide (are the same): Return=true, obj.getType()=GEOMETRIC_TYPE_LINE
Lines intesect in a point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TLine2D& r1, const TLine2D& r2, TObject2D& obj)

Gets the intersection between two 2D lines.

Possible outcomes:

Lines do not intersect: Return=false
Lines are parallel and do not coincide: Return=false
Lines coincide (are the same): Return=true, obj.getType()=GEOMETRIC_TYPE_LINE
Lines intesect in a point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TLine2D& r1, const TSegment2D& s2, TObject2D& obj)

Gets the intersection between a 2D line and a 2D segment.

Possible outcomes:

They don’t intersect: Return=false
s2 lies within the line: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
Both intersects in one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TSegment2D& s1, const TLine2D& r2, TObject2D& obj)

Gets the intersection between a 2D line and a 2D segment.

Possible outcomes:

They don’t intersect: Return=false
s1 lies within the line: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT
Both intersects in one point: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT

See also:

bool mrpt::math::intersect(const TSegment2D& s1, const TSegment2D& s2, TObject2D& obj)

Gets the intersection between two 2D segments.

Possible outcomes:

Segments intersect: Return=true, obj.getType()=GEOMETRIC_TYPE_POINT
Segments don’t intersect & are parallel: Return=true, obj.getType()=GEOMETRIC_TYPE_SEGMENT, obj is the segment “in between” both segments.
Segments don’t intersect & aren’t parallel: Return=false.

See also:

double mrpt::math::getAngle(const TPlane& p1, const TPlane& p2)

Computes the angle between two planes.

double mrpt::math::getAngle(const TPlane& p1, const TLine3D& r2)

Computes the angle between a plane and a 3D line or segment (implicit constructor will be used if passing a segment instead of a line).

double mrpt::math::getAngle(const TLine3D& r1, const TPlane& p2)

Computes the angle between a 3D line or segment and a plane (implicit constructor will be used if passing a segment instead of a line).

double mrpt::math::getAngle(const TLine3D& r1, const TLine3D& r2)

Computes the accute relative angle (range: [-PI/2,PI/2]) between two lines.

Implicit constructor allows passing a segment as argument too.

double mrpt::math::getAngle(const TLine2D& r1, const TLine2D& r2)

Computes the relative angle (range: [-PI,PI]) of line 2 wrt line 1.

Implicit constructor allows passing a segment as argument too.

void mrpt::math::createFromPoseX(const mrpt::math::TPose3D& p, TLine3D& r)

Gets a 3D line corresponding to the X axis in a given pose.

An implicit constructor is used if a TPose3D is given.

void mrpt::math::createFromPoseY(const mrpt::math::TPose3D& p, TLine3D& r)

Gets a 3D line corresponding to the Y axis in a given pose.

An implicit constructor is used if a TPose3D is given.

void mrpt::math::createFromPoseZ(const mrpt::math::TPose3D& p, TLine3D& r)

Gets a 3D line corresponding to the Z axis in a given pose.

An implicit constructor is used if a TPose3D is given.

void mrpt::math::createFromPoseAndVector(
    const mrpt::math::TPose3D& p,
    const double(&) vector [3],
    TLine3D& r
    )

Gets a 3D line corresponding to any arbitrary vector, in the base given by the pose.

An implicit constructor is used if a TPose3D is given.

void mrpt::math::createFromPoseX(const TPose2D& p, TLine2D& r)

Gets a 2D line corresponding to the X axis in a given pose.

An implicit constructor is used if a CPose2D is given.

void mrpt::math::createFromPoseY(const TPose2D& p, TLine2D& r)

Gets a 2D line corresponding to the Y axis in a given pose.

An implicit constructor is used if a CPose2D is given.

void mrpt::math::createFromPoseAndVector(
    const TPose2D& p,
    const double(&) vector [2],
    TLine2D& r
    )

Gets a 2D line corresponding to any arbitrary vector, in the base given the given pose.

An implicit constructor is used if a CPose2D is given.

bool mrpt::math::conformAPlane(const std::vector<TPoint3D>& points)

Checks whether this polygon or set of points acceptably fits a plane.

See also:

TPolygon3D, getEpsilon

bool mrpt::math::conformAPlane(const std::vector<TPoint3D>& points, TPlane& p)

Checks whether this polygon or set of points acceptably fits a plane, and if it’s the case returns it in the second argument.

See also:

TPolygon3D, getEpsilon

bool mrpt::math::areAligned(const std::vector<TPoint2D>& points)

Checks whether this set of points acceptably fits a 2D line.

See also:

getEpsilon

bool mrpt::math::areAligned(const std::vector<TPoint2D>& points, TLine2D& r)

Checks whether this set of points acceptably fits a 2D line, and if it’s the case returns it in the second argument.

See also:

getEpsilon

bool mrpt::math::areAligned(const std::vector<TPoint3D>& points)

Checks whether this set of points acceptably fits a 3D line.

See also:

getEpsilon

bool mrpt::math::areAligned(const std::vector<TPoint3D>& points, TLine3D& r)

Checks whether this set of points acceptably fits a 3D line, and if it’s the case returns it in the second argument.

void mrpt::math::project3D(const TPoint3D& point, const mrpt::math::TPose3D& newXYpose, TPoint3D& newPoint)

Uses the given pose 3D to project a point into a new base.

void mrpt::math::project3D(const TSegment3D& segment, const mrpt::math::TPose3D& newXYpose, TSegment3D& newSegment)

Uses the given pose 3D to project a segment into a new base

void mrpt::math::project3D(const TLine3D& line, const mrpt::math::TPose3D& newXYpose, TLine3D& newLine)

Uses the given pose 3D to project a line into a new base.

void mrpt::math::project3D(const TPlane& plane, const mrpt::math::TPose3D& newXYpose, TPlane& newPlane)

Uses the given pose 3D to project a plane into a new base.

void mrpt::math::project3D(const TPolygon3D& polygon, const mrpt::math::TPose3D& newXYpose, TPolygon3D& newPolygon)

Uses the given pose 3D to project a polygon into a new base.

void mrpt::math::project3D(const TObject3D& object, const mrpt::math::TPose3D& newXYPose, TObject3D& newObject)

Uses the given pose 3D to project any 3D object into a new base.

template <typename Object>
Object mrpt::math::project3D(
    const Object& o,
    const mrpt::math::TPose3D& newPose
    )

Returns the transformed point/line/segment/plane after applying the given SE(3) transformation.

[New in MRPT 2.3.1]

template <class T>
void mrpt::math::project3D(
    const T& obj,
    const TPlane& newXYPlane,
    T& newObj
    )

Projects any 3D object into the plane’s base, using its inverse pose.

If the object is exactly inside the plane, this projection will zero its Z coordinates

template <class T>
void mrpt::math::project3D(
    const T& obj,
    const TPlane& newXYPlane,
    const TPoint3D& newOrigin,
    T& newObj
    )

Projects any 3D object into the plane’s base, using its inverse pose and forcing the position of the new coordinates origin.

If the object is exactly inside the plane, this projection will zero its Z coordinates

template <class T>
void mrpt::math::project3D(
    const std::vector<T>& objs,
    const mrpt::math::TPose3D& newXYpose,
    std::vector<T>& newObjs
    )

Projects a set of 3D objects into the plane’s base.

void mrpt::math::project2D(const TPoint2D& point, const TPose2D& newXpose, TPoint2D& newPoint)

Uses the given pose 2D to project a point into a new base.

void mrpt::math::project2D(const TSegment2D& segment, const TPose2D& newXpose, TSegment2D& newSegment)

Uses the given pose 2D to project a segment into a new base

void mrpt::math::project2D(const TLine2D& line, const TPose2D& newXpose, TLine2D& newLine)

Uses the given pose 2D to project a line into a new base.

void mrpt::math::project2D(const TPolygon2D& polygon, const TPose2D& newXpose, TPolygon2D& newPolygon)

Uses the given pose 2D to project a polygon into a new base.

void mrpt::math::project2D(const TObject2D& object, const TPose2D& newXpose, TObject2D& newObject)

Uses the given pose 2D to project any 2D object into a new base.

template <typename Object>
Object mrpt::math::project2D(
    const Object& o,
    const mrpt::math::TPose2D& newPose
    )

Returns the transformed point/line/segment after applying the given SE(2) transformation.

[New in MRPT 2.3.1]

template <class T, class CPOSE2D>
void mrpt::math::project2D(
    const T& obj,
    const TLine2D& newXLine,
    T& newObj
    )

Projects any 2D object into the line’s base, using its inverse pose.

If the object is exactly inside the line, this projection will zero its Y coordinate.

Parameters:

CPOSE2D

set to TPose2D

template <class T, class CPOSE2D>
void mrpt::math::project2D(
    const T& obj,
    const TLine2D& newXLine,
    const TPoint2D& newOrigin,
    T& newObj
    )

Projects any 2D object into the line’s base, using its inverse pose and forcing the position of the new coordinate origin.

If the object is exactly inside the line, this projection will zero its Y coordinate.

Parameters:

CPOSE2D

set to TPose2D

template <class T>
void mrpt::math::project2D(
    const std::vector<T>& objs,
    const TPose2D& newXpose,
    std::vector<T>& newObjs
    )

Projects a set of 2D objects into the line’s base.

bool mrpt::math::intersect(const TPolygon2D& p1, const TSegment2D& s2, TObject2D& obj)

Gets the intersection between a 2D polygon and a 2D segment.

See also:

bool mrpt::math::intersect(const TPolygon2D& p1, const TLine2D& r2, TObject2D& obj)

Gets the intersection between a 2D polygon and a 2D line.

See also:

TPolygon2D mrpt::math::intersect(const TPolygon2D& subject, const TPolygon2D& clipping)

The Sutherland-Hodgman algorithm for finding the intersection between two 2D polygons.

Note that at least one of the polygons (clipping) must be convex. The other polygon (subject) may be convex or concave.

See code example: Example: math_polygon_intersection

(New in MRPT 2.4.1)

Returns:

The intersection, or an empty (no points) polygon if there is no intersection at all.

bool mrpt::math::intersect(const TSegment2D& s1, const TPolygon2D& p2, TObject2D& obj)

Gets the intersection between a 2D segment and a 2D polygon.

See also:

bool mrpt::math::intersect(const TLine2D& r1, const TPolygon2D& p2, TObject2D& obj)

Gets the intersection between a 2D line and a 2D polygon.

See also:

bool mrpt::math::intersect(const TPolygon3D& p1, const TSegment3D& s2, TObject3D& obj)

Gets the intersection between a 3D polygon and a 3D segment.

See also:

bool mrpt::math::intersect(const TPolygon3D& p1, const TLine3D& r2, TObject3D& obj)

Gets the intersection between a 3D polygon and a 3D line.

See also:

bool mrpt::math::intersect(const TPolygon3D& p1, const TPlane& p2, TObject3D& obj)

Gets the intersection between a 3D polygon and a plane.

See also:

bool mrpt::math::intersect(const TPolygon3D& p1, const TPolygon3D& p2, TObject3D& obj)

Gets the intersection between two 3D polygons.

See also:

bool mrpt::math::intersect(const TSegment3D& s1, const TPolygon3D& p2, TObject3D& obj)

Gets the intersection between a 3D segment and a 3D polygon.

See also:

bool mrpt::math::intersect(const TLine3D& r1, const TPolygon3D& p2, TObject3D& obj)

Gets the intersection between a 3D line and a 3D polygon.

See also:

bool mrpt::math::intersect(const TPlane& p1, const TPolygon3D& p2, TObject3D& obj)

Gets the intersection between a plane and a 3D polygon.

See also:

TObject3D, CSparseMatrixTemplate

size_t mrpt::math::intersect(
    const std::vector<TPolygon3D>& v1,
    const std::vector<TPolygon3D>& v2,
    CSparseMatrixTemplate<TObject3D>& objs
    )

Gets the intersection between two sets of 3D polygons.

The intersection is returned as an sparse matrix with each pair of polygons’ intersections, and the return value is the amount of intersections found.

See also:

size_t mrpt::math::intersect(
    const std::vector<TPolygon3D>& v1,
    const std::vector<TPolygon3D>& v2,
    std::vector<TObject3D>& objs
    )

Gets the intersection between two sets of 3D polygons.

The intersection is returned as a vector with every intersection found, and the return value is the amount of intersections found.

See also:

template <class T, class U, class O>
size_t mrpt::math::intersect(
    const std::vector<T>& v1,
    const std::vector<U>& v2,
    CSparseMatrixTemplate<O>& objs
    )

Gets the intersection between vectors of geometric objects and returns it in a sparse matrix of either TObject2D or TObject3D.

See also:

TObject2D, TObject3D, CSparseMatrix

template <class T, class U, class O>
size_t mrpt::math::intersect(
    const std::vector<T>& v1,
    const std::vector<U>& v2,
    std::vector<O> objs
    )

Gets the intersection between vectors of geometric objects and returns it in a vector of either TObject2D or TObject3D.

See also: