`mrpt.math`

Package Contents

class mrpt.math.CHistogram(min: float, max: float, nBins: int)

C++ API: class mrpt::math::CHistogram

add(arg0: float) → None

clear() → None

getBinCount(arg0: int) → int

getBinRatio(arg0: int) → float

getHistogram() → tuple: Returns (bin_centers, hit_counts) as two lists

getHistogramNormalized() → tuple: Returns (bin_centers, normalized_hits) — integral equals 1 as PDF

class mrpt.math.CMatrixDouble

class mrpt.math.CMatrixDouble(arg0: int, arg1: int)

class mrpt.math.CMatrixDouble(arg0: numpy.ndarray)

as_numpy() → numpy.ndarray

class mrpt.math.CPolygon

C++ API: class mrpt::math::CPolygon

Bases: mrpt.serialization.CSerializable

add_vertex(x: float, y: float) → None

get_vertex_x(arg0: int) → float

get_vertex_y(arg0: int) → float

get_vertices() → tuple: Returns (xs, ys) as two lists of vertex coordinates

set_vertices(arg0: list[float], arg1: list[float]) → None

class mrpt.math.CVectorDouble

class mrpt.math.CVectorDouble(arg0: int)

class mrpt.math.CVectorDouble(arg0: numpy.ndarray)

as_numpy() → numpy.ndarray

class mrpt.math.TBoundingBox(arg0: TPoint3D, arg1: TPoint3D)

max: TPoint3D

min: TPoint3D

static PlusMinusInfinity() → TBoundingBox

containsPoint(arg0: TPoint3D) → bool

intersection(arg0: TBoundingBox) → Any

unionWith(arg0: TBoundingBox) → TBoundingBox

volume() → float

class mrpt.math.TBoundingBoxf(arg0: TPoint3Df, arg1: TPoint3Df)

max: TPoint3Df

min: TPoint3Df

static PlusMinusInfinity() → TBoundingBoxf

containsPoint(arg0: TPoint3Df) → bool

unionWith(arg0: TBoundingBoxf) → TBoundingBoxf

volume() → float

class mrpt.math.TLine2D

C++ API: struct mrpt::math::TLine2D

TLine2D(arg0: TPoint2D, arg1: TPoint2D) TLine2D(A: float, B: float, C: float)

coefs: list[float]

static FromTwoPoints(arg0: TPoint2D, arg1: TPoint2D) → TLine2D

contains(arg0: TPoint2D) → bool

distance(arg0: TPoint2D) → float

evaluatePoint(arg0: TPoint2D) → float

unitarize() → None

class mrpt.math.TLine3D

C++ API: struct mrpt::math::TLine3D

TLine3D(arg0: TPoint3D, arg1: TPoint3D)

director: TPoint3D

pBase: TPoint3D

static FromTwoPoints(arg0: TPoint3D, arg1: TPoint3D) → TLine3D

closestPointTo(arg0: TPoint3D) → TPoint3D

contains(arg0: TPoint3D) → bool

distance(arg0: TPoint3D) → float

unitarize() → None

class mrpt.math.TPlane

C++ API: struct mrpt::math::TPlane

TPlane(A: float, B: float, C: float, D: float) TPlane(arg0: TPoint3D, arg1: TPoint3D, arg2: TPoint3D)

coefs: list[float]

static From3Points(arg0: TPoint3D, arg1: TPoint3D, arg2: TPoint3D) → TPlane

contains(arg0: TPoint3D) → bool

distance(arg0: TPoint3D) → float

evaluatePoint(arg0: TPoint3D) → float

unitarize() → None

class mrpt.math.TPoint2D

class mrpt.math.TPoint2D(arg0: float, arg1: float)

class mrpt.math.TPoint2D(arg0: list[float])

x: float

y: float

cast_float() → Any

norm() → float

sqrNorm() → float

unitarize() → TPoint2D

class mrpt.math.TPoint2Df

class mrpt.math.TPoint2Df(arg0: float, arg1: float)

class mrpt.math.TPoint2Df(arg0: list[float])

x: float

y: float

cast_double() → TPoint2D

norm() → float

sqrNorm() → float

unitarize() → TPoint2Df

class mrpt.math.TPoint3D

class mrpt.math.TPoint3D(arg0: float, arg1: float, arg2: float)

class mrpt.math.TPoint3D(arg0: list[float])

x: float

y: float

z: float

cast_float() → Any

cross(arg0: TPoint3D) → TPoint3D

dot(arg0: TPoint3D) → float

norm() → float

sqrNorm() → float

unitarize() → TPoint3D

class mrpt.math.TPoint3Df

class mrpt.math.TPoint3Df(arg0: float, arg1: float, arg2: float)

class mrpt.math.TPoint3Df(arg0: list[float])

x: float

y: float

z: float

cast_double() → TPoint3D

cross(arg0: TPoint3Df) → TPoint3Df

dot(arg0: TPoint3Df) → float

norm() → float

sqrNorm() → float

unitarize() → TPoint3Df

class mrpt.math.TPose2D

C++ API: struct mrpt::math::TPose2D

TPose2D(arg0: float, arg1: float, arg2: float) TPose2D(arg0: list[float])

phi: float

x: float

y: float

composePoint(arg0: TPoint2D) → TPoint2D

inverseComposePoint(arg0: TPoint2D) → TPoint2D

norm() → float

normalizePhi() → None

class mrpt.math.TPose3D

C++ API: struct mrpt::math::TPose3D

TPose3D(arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float) TPose3D(arg0: list[float])

pitch: float

roll: float

x: float

y: float

yaw: float

z: float

composePoint(arg0: TPoint3D) → TPoint3D

getHomogeneousMatrix() → CMatrixDouble44

getRotationMatrix() → CMatrixDouble33

inverseComposePoint(arg0: TPoint3D) → TPoint3D

norm() → float

class mrpt.math.TPose3DQuat

C++ API: struct mrpt::math::TPose3DQuat

TPose3DQuat(x: float, y: float, z: float, qr: float, qx: float, qy: float, qz: float)

qr: float

qx: float

qy: float

qz: float

x: float

y: float

z: float

class mrpt.math.TSegment2D

C++ API: struct mrpt::math::TSegment2D

TSegment2D(arg0: TPoint2D, arg1: TPoint2D)

point1: TPoint2D

point2: TPoint2D

static FromPoints(arg0: TPoint2D, arg1: TPoint2D) → TSegment2D

contains(arg0: TPoint2D) → bool

distance(arg0: TPoint2D) → float

length() → float

class mrpt.math.TSegment3D

C++ API: struct mrpt::math::TSegment3D

TSegment3D(arg0: TPoint3D, arg1: TPoint3D)

point1: TPoint3D

point2: TPoint3D

contains(arg0: TPoint3D) → bool

distance(arg0: TPoint3D) → float

length() → float

class mrpt.math.TTwist2D

C++ API: struct mrpt::math::TTwist2D

TTwist2D(vx: float, vy: float, omega: float)

omega: float

vx: float

vy: float

asString() → str

rotate(arg0: float) → None

rotated(arg0: float) → TTwist2D

class mrpt.math.TTwist3D

C++ API: struct mrpt::math::TTwist3D

TTwist3D(vx: float, vy: float, vz: float, wx: float, wy: float, wz: float)

vx: float

vy: float

vz: float

wx: float

wy: float

wz: float

asString() → str

rotate(arg0: TPose3D) → None

rotated(arg0: TPose3D) → TTwist3D

mrpt.math.wrapTo2Pi(arg0: float) → float: Wrap angle to [0, 2*pi]

mrpt.math.wrapToPi(arg0: float) → float: Wrap angle to [-pi, pi]

mrpt.math

Package Contents

`mrpt.math`