mrpt.pymrpt.mrpt.poses
index
(built-in)

Bindings for mrpt::poses namespace

 
Modules
       
mrpt.pymrpt.mrpt.poses.Lie

 
Classes
       
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t(pybind11_builtins.pybind11_object)
CPoint2DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t)
CPoint2DPDFGaussian
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t(pybind11_builtins.pybind11_object)
CPointPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t)
CPointPDFGaussian
CPointPDFParticles(CPointPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t)
CPointPDFSOG
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t(pybind11_builtins.pybind11_object)
CPosePDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t)
CPosePDFGaussian
CPosePDFGaussianInf
CPosePDFGrid(CPosePDF, CPose2DGridTemplate_double_t)
CPosePDFParticles(CPosePDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.Stringifyable)
CPosePDFSOG
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t(pybind11_builtins.pybind11_object)
CPose3DQuatPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t)
CPose3DQuatPDFGaussian
CPose3DQuatPDFGaussianInf
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t(pybind11_builtins.pybind11_object)
CPose3DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t)
CPose3DPDFGaussian(CPose3DPDF, mrpt.pymrpt.mrpt.Stringifyable)
CPose3DPDFGaussianInf
CPose3DPDFGrid(CPose3DPDF, CPose3DGridTemplate_double_t)
CPose3DPDFParticles(CPose3DPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.Stringifyable)
CPose3DPDFSOG
mrpt.pymrpt.mrpt.serialization.CSerializable(mrpt.pymrpt.mrpt.rtti.CObject)
CPoint2DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t)
CPoint2DPDFGaussian
CPointPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t)
CPointPDFGaussian
CPointPDFParticles(CPointPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t)
CPointPDFSOG
CPose2DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_2_t)
CPose3DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_3_t)
CPose3DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t)
CPose3DPDFGaussian(CPose3DPDF, mrpt.pymrpt.mrpt.Stringifyable)
CPose3DPDFGaussianInf
CPose3DPDFGrid(CPose3DPDF, CPose3DGridTemplate_double_t)
CPose3DPDFParticles(CPose3DPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.Stringifyable)
CPose3DPDFSOG
CPose3DQuatPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t)
CPose3DQuatPDFGaussian
CPose3DQuatPDFGaussianInf
CPosePDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t)
CPosePDFGaussian
CPosePDFGaussianInf
CPosePDFGrid(CPosePDF, CPose2DGridTemplate_double_t)
CPosePDFParticles(CPosePDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.Stringifyable)
CPosePDFSOG
CPoses2DSequence
CPoses3DSequence
pybind11_builtins.pybind11_object(builtins.object)
CPose2DGridTemplate_double_t
CPose3DGridTemplate_double_t
CPoseInterpolatorBase_2_t
CPose2DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_2_t)
CPoseInterpolatorBase_3_t
CPose3DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_3_t)
CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
CPoint_mrpt_poses_CPoint2D_2UL_t(CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, mrpt.pymrpt.mrpt.Stringifyable)
CPoint2D(CPoint_mrpt_poses_CPoint2D_2UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable)
CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
CPoint_mrpt_poses_CPoint3D_3UL_t(CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, mrpt.pymrpt.mrpt.Stringifyable)
CPoint3D(CPoint_mrpt_poses_CPoint3D_3UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable)
CPoseOrPoint_mrpt_poses_CPose2D_3UL_t
CPose_mrpt_poses_CPose2D_3UL_t
CPose2D(CPose_mrpt_poses_CPose2D_3UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t
CPose_mrpt_poses_CPose3DQuat_7UL_t
CPose3DQuat(CPose_mrpt_poses_CPose3DQuat_7UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
CPoseOrPoint_mrpt_poses_CPose3D_6UL_t
CPose_mrpt_poses_CPose3D_6UL_t
CPose3D(CPose_mrpt_poses_CPose3D_6UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
CPoseRandomSampler
CRobot2DPoseEstimator
FrameLookUpStatus
SE_average_2UL_t
SE_average_3UL_t
SO_average_2UL_t
SO_average_3UL_t
TConstructorFlags_Poses
TInterpolatorMethod

 
class CPoint2D(CPoint_mrpt_poses_CPoint2D_2UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable)
    A class used to store a 2D point.
 
 For a complete description of Points/Poses, see mrpt::poses::CPoseOrPoint,
or refer
   to the 2D/3D Geometry
tutorial in the wiki.
 
 
  
 
 
 
CPoseOrPoint,CPose, CPoint
 
 
Method resolution order:
CPoint2D
CPoint_mrpt_poses_CPoint2D_2UL_t
CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
mrpt.pymrpt.mrpt.Stringifyable
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, arg0: float) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, x: float, y: float) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, o: mrpt::math::TPoint2D_<double>) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, o: mrpt::math::TPoint3D_<double>) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, arg0: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, arg0: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> str
__sub__(...)
__sub__(self: mrpt.pymrpt.mrpt.poses.CPoint2D, b: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPoint2D
 
The operator D="this"-b is the pose inverse compounding operator,
   the resulting points "D" fulfils: "this" = b + D, so that: b == a +
 (b-a)
 
C++: mrpt::poses::CPoint2D::operator-(const class mrpt::poses::CPose2D &) const --> class mrpt::poses::CPoint2D
asTPoint(...)
asTPoint(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> mrpt::math::TPoint2D_<double>
 
C++: mrpt::poses::CPoint2D::asTPoint() const --> struct mrpt::math::TPoint2D_<double>
asVector(...)
asVector(self: mrpt.pymrpt.mrpt.poses.CPoint2D, v: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_2UL_1UL_t) -> None
 
Return the pose or point as a 2x1 vector [x, y]' 
 
C++: mrpt::poses::CPoint2D::asVector(class mrpt::math::CMatrixFixed<double, 2, 1> &) const --> void
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoint2D, : mrpt.pymrpt.mrpt.poses.CPoint2D) -> mrpt.pymrpt.mrpt.poses.CPoint2D
 
C++: mrpt::poses::CPoint2D::operator=(const class mrpt::poses::CPoint2D &) --> class mrpt::poses::CPoint2D &
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint2D::clone() const --> class mrpt::rtti::CObject *
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
@} 
 
C++: mrpt::poses::CPoint2D::setToNaN() --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint2D::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2D::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
empty(...) from builtins.PyCapsule
empty() -> bool
 
C++: mrpt::poses::CPoint2D::empty() --> bool
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPoint2D::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPoint2D::is_PDF() --> bool
max_size(...) from builtins.PyCapsule
max_size() -> int
 
C++: mrpt::poses::CPoint2D::max_size() --> unsigned long
resize(...) from builtins.PyCapsule
resize(n: int) -> None
 
C++: mrpt::poses::CPoint2D::resize(size_t) --> void
size(...) from builtins.PyCapsule
size() -> int
 
C++: mrpt::poses::CPoint2D::size() --> unsigned long

Data descriptors defined here:
m_coords

Methods inherited from CPoint_mrpt_poses_CPoint2D_2UL_t:
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, i: int) -> float
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::operator[](unsigned int) --> double &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, s: float) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::operator*=(const double) --> void
asString(...)
asString(*args, **kwargs)
Overloaded function.
 
1. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> str
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::asString() const --> std::string
 
2. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> str
 
Returns a human-friendly textual description of the object. For classes
 with a large/complex internal state, only a summary should be returned
 instead of the exhaustive enumeration of all data members.
 
C++: mrpt::Stringifyable::asString() const --> std::string
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::math::CMatrixFixed<double, 2ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 2, 1>
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::poses::CPoint2D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::derived() --> class mrpt::poses::CPoint2D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, s: str) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::fromString(const std::string &) --> void
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::norm() const --> double
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y_incr(const double) --> void

Static methods inherited from CPoint_mrpt_poses_CPoint2D_2UL_t:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::is3DPoseOrPoint() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoint2DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t)
    Declares a class that represents a Probability Distribution function (PDF)
of a 2D point (x,y).
  This class is just the base class for unifying many diferent
   ways this PDF can be implemented.
 
 For convenience, a pose composition is also defined for any
   PDF derived class, changeCoordinatesReference, in the form of a method
rather than an operator.
 
 For a similar class for 6D poses (a 3D point with attitude), see CPose3DPDF
 
 See also:
 [probabilistic spatial representations](tutorial-pdf-over-poses.html)
 
 
 
 
CPoint2DCPointPDF
 
 
Method resolution order:
CPoint2DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2DPDF::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, arg0: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, : mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> mrpt.pymrpt.mrpt.poses.CPoint2DPDF
 
C++: mrpt::poses::CPoint2DPDF::operator=(const class mrpt::poses::CPoint2DPDF &) --> class mrpt::poses::CPoint2DPDF &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p1: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p2: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p1: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p2: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPoint2DPDF::bayesianFusion(const class mrpt::poses::CPoint2DPDF &, const class mrpt::poses::CPoint2DPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPoint2DPDF::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, o: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
C++: mrpt::poses::CPoint2DPDF::copyFrom(const class mrpt::poses::CPoint2DPDF &) --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2DPDF::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPoint2DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPoint2DPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
clone(...)
clone(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Returns a deep copy (clone) of the object, indepently of its class. 
 
C++: mrpt::rtti::CObject::clone() const --> class mrpt::rtti::CObject *
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t:
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, outPart: mrpt::poses::CPoint2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::drawSingleSample(class mrpt::poses::CPoint2D &) const --> void
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixFixed<double, 2ul, 2ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance(class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> mrpt::math::CMatrixFixed<double, 2ul, 2ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 2, 2>
getCovarianceAndMean(...)
getCovarianceAndMean(*args, **kwargs)
Overloaded function.
 
1. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> Tuple[mrpt::math::CMatrixFixed<double, 2ul, 2ul>, mrpt::poses::CPoint2D]
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 2, 2>, class mrpt::poses::CPoint2D>
 
2. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, c: mrpt::math::CMatrixFixed<double, 2ul, 2ul>, mean: mrpt::poses::CPoint2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceAndMean(class mrpt::math::CMatrixFixed<double, 2, 2> &, class mrpt::poses::CPoint2D &) const --> void
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint2D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, inf: mrpt::math::CMatrixFixed<double, 2ul, 2ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, mean_point: mrpt::poses::CPoint2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getMean(class mrpt::poses::CPoint2D &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> mrpt::poses::CPoint2D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getMeanVal() const --> class mrpt::poses::CPoint2D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, file: str) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::saveToTextFile(const std::string &) const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoint2DPDFGaussian(CPoint2DPDF)
    A gaussian distribution for 2D points. Also a method for bayesian fusion is
provided.
 
 
 
 
CPoint2DPDF
 
 
Method resolution order:
CPoint2DPDFGaussian
CPoint2DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2DPDFGaussian::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPoint2D, init_Cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_2UL_2UL_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, : mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian
 
C++: mrpt::poses::CPoint2DPDFGaussian::operator=(const class mrpt::poses::CPoint2DPDFGaussian &) --> class mrpt::poses::CPoint2DPDFGaussian &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p2: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPoint2DPDFGaussian::bayesianFusion(const class mrpt::poses::CPoint2DPDFGaussian &, const class mrpt::poses::CPoint2DPDFGaussian &) --> void
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p2: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
 
3. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, p2: mrpt.pymrpt.mrpt.poses.CPoint2DPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPoint2DPDFGaussian::bayesianFusion(const class mrpt::poses::CPoint2DPDF &, const class mrpt::poses::CPoint2DPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. Both the mean value and the covariance matrix
 are updated correctly. 
 
C++: mrpt::poses::CPoint2DPDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint2DPDFGaussian::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPoint2DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPoint2DPDFGaussian::copyFrom(const class mrpt::poses::CPoint2DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, outSample: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
Draw a sample from the pdf 
 
C++: mrpt::poses::CPoint2DPDFGaussian::drawSingleSample(class mrpt::poses::CPoint2D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_2UL_2UL_t, mrpt.pymrpt.mrpt.poses.CPoint2D]
 
Returns an estimate of the point covariance matrix (2x2 cov matrix) and
 the mean, both at once. 
 
 getMean 
 
C++: mrpt::poses::CPoint2DPDFGaussian::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 2, 2>, class mrpt::poses::CPoint2D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPoint2D) -> None
 
Returns an estimate of the point, (the mean, or mathematical expectation
 of the PDF) 
 
C++: mrpt::poses::CPoint2DPDFGaussian::getMean(class mrpt::poses::CPoint2D &) const --> void
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, other: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> float
 
Returns the Mahalanobis distance from this PDF to another PDF, that is,
 it's evaluation at (0,0,0) 
 
C++: mrpt::poses::CPoint2DPDFGaussian::mahalanobisDistanceTo(const class mrpt::poses::CPoint2DPDFGaussian &) const --> double
mahalanobisDistanceToPoint(...)
mahalanobisDistanceToPoint(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, x: float, y: float) -> float
 
Returns the Mahalanobis distance from this PDF to some point 
 
C++: mrpt::poses::CPoint2DPDFGaussian::mahalanobisDistanceToPoint(const double, const double) const --> double
productIntegralNormalizedWith(...)
productIntegralNormalizedWith(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is in the range [0,1].
  Note that the resulting value is in fact
  
 
 
  , with 
 being the square Mahalanobis distance between the
 two pdfs.
 
 
 productIntegralWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPoint2DPDFGaussian::productIntegralNormalizedWith(const class mrpt::poses::CPoint2DPDFGaussian &) const --> double
productIntegralWith(...)
productIntegralWith(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is >=0.
 
 
 productIntegralNormalizedWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPoint2DPDFGaussian::productIntegralWith(const class mrpt::poses::CPoint2DPDFGaussian &) const --> double
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoint2DPDFGaussian, file: str) -> bool
 
Save PDF's particles to a text file, containing the 2D pose in the first
 line, then the covariance matrix in next 3 lines 
 
C++: mrpt::poses::CPoint2DPDFGaussian::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint2DPDFGaussian::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint2DPDFGaussian::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov
mean

Static methods inherited from CPoint2DPDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPoint2DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPoint2DPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixFixed<double, 2ul, 2ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance(class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> mrpt::math::CMatrixFixed<double, 2ul, 2ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 2, 2>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint2D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t, inf: mrpt::math::CMatrixFixed<double, 2ul, 2ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> mrpt::poses::CPoint2D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::getMeanVal() const --> class mrpt::poses::CPoint2D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint2D_2UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint2D, 2>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoint3D(CPoint_mrpt_poses_CPoint3D_3UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable)
    A class used to store a 3D point.
 
 For a complete description of Points/Poses, see mrpt::poses::CPoseOrPoint,
or refer
   to the 2D/3D Geometry
tutorial in the wiki.
 
 
  
 
 
 
 
 
CPoseOrPoint,CPose, CPoint
 
 
Method resolution order:
CPoint3D
CPoint_mrpt_poses_CPoint3D_3UL_t
CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
mrpt.pymrpt.mrpt.Stringifyable
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint3D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__add__(...)
__add__(*args, **kwargs)
Overloaded function.
 
1. __add__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, b: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.poses.CPoint3D
 
Returns this point plus point "b", i.e. result = this + b 
 
C++: mrpt::poses::CPoint3D::operator+(const class mrpt::poses::CPoint3D &) const --> class mrpt::poses::CPoint3D
 
2. __add__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, b: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Returns this point plus pose "b", i.e. result = this + b  
 
C++: mrpt::poses::CPoint3D::operator+(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPose3D
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, arg0: float) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, arg0: float, arg1: float) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, x: float, y: float, z: float) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, xyz: mrpt::math::CMatrixFixed<double, 3ul, 1ul>) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, p: mrpt::poses::CPoint2D) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, p: mrpt::math::TPoint3D_<double>) -> None
 
10. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, arg0: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
11. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, arg0: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> str
__sub__(...)
__sub__(*args, **kwargs)
Overloaded function.
 
1. __sub__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, b: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPoint3D
 
Returns this point as seen from "b", i.e. result = this - b 
 
C++: mrpt::poses::CPoint3D::operator-(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPoint3D
 
2. __sub__(self: mrpt.pymrpt.mrpt.poses.CPoint3D, b: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.poses.CPoint3D
 
Returns this point minus point "b", i.e. result = this - b 
 
C++: mrpt::poses::CPoint3D::operator-(const class mrpt::poses::CPoint3D &) const --> class mrpt::poses::CPoint3D
asTPoint(...)
asTPoint(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt::math::TPoint3D_<double>
 
C++: mrpt::poses::CPoint3D::asTPoint() const --> struct mrpt::math::TPoint3D_<double>
asVector(...)
asVector(self: mrpt.pymrpt.mrpt.poses.CPoint3D, v: mrpt::math::CMatrixFixed<double, 3ul, 1ul>) -> None
 
Return the pose or point as a 3x1 vector [x y z]' 
 
C++: mrpt::poses::CPoint3D::asVector(class mrpt::math::CMatrixFixed<double, 3, 1> &) const --> void
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoint3D, : mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.poses.CPoint3D
 
C++: mrpt::poses::CPoint3D::operator=(const class mrpt::poses::CPoint3D &) --> class mrpt::poses::CPoint3D &
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint3D::clone() const --> class mrpt::rtti::CObject *
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
@} 
 
C++: mrpt::poses::CPoint3D::setToNaN() --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPoint3D::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPoint3D::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
empty(...) from builtins.PyCapsule
empty() -> bool
 
C++: mrpt::poses::CPoint3D::empty() --> bool
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPoint3D::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPoint3D::is_PDF() --> bool
max_size(...) from builtins.PyCapsule
max_size() -> int
 
C++: mrpt::poses::CPoint3D::max_size() --> unsigned long
resize(...) from builtins.PyCapsule
resize(n: int) -> None
 
C++: mrpt::poses::CPoint3D::resize(const unsigned long) --> void
size(...) from builtins.PyCapsule
size() -> int
 
C++: mrpt::poses::CPoint3D::size() --> unsigned long

Data descriptors defined here:
m_coords

Methods inherited from CPoint_mrpt_poses_CPoint3D_3UL_t:
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, i: int) -> float
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::operator[](unsigned int) --> double &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, s: float) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::operator*=(const double) --> void
asString(...)
asString(*args, **kwargs)
Overloaded function.
 
1. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> str
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::asString() const --> std::string
 
2. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> str
 
Returns a human-friendly textual description of the object. For classes
 with a large/complex internal state, only a summary should be returned
 instead of the exhaustive enumeration of all data members.
 
C++: mrpt::Stringifyable::asString() const --> std::string
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 3, 1>
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::derived() --> class mrpt::poses::CPoint3D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, s: str) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::fromString(const std::string &) --> void
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::norm() const --> double
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y_incr(const double) --> void

Static methods inherited from CPoint_mrpt_poses_CPoint3D_3UL_t:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::is3DPoseOrPoint() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPointPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t)
    Declares a class that represents a Probability Distribution
   function (PDF) of a 3D point (x,y,z).
  This class is just the base class for unifying many diferent
   ways this PDF can be implemented.
 
 For convenience, a pose composition is also defined for any
   PDF derived class, changeCoordinatesReference, in the form of a method
rather than an operator.
 
 For a similar class for 6D poses (a 3D point with attitude), see CPose3DPDF
 
 See also:
 [probabilistic spatial representations](tutorial-pdf-over-poses.html)
 
 
CPoint3D
 
 
Method resolution order:
CPointPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPointPDF) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDF::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDF, arg0: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPointPDF, : mrpt.pymrpt.mrpt.poses.CPointPDF) -> mrpt.pymrpt.mrpt.poses.CPointPDF
 
C++: mrpt::poses::CPointPDF::operator=(const class mrpt::poses::CPointPDF &) --> class mrpt::poses::CPointPDF &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDF, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDF, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPointPDF::bayesianFusion(const class mrpt::poses::CPointPDF &, const class mrpt::poses::CPointPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPointPDF, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPointPDF::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPointPDF, o: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
C++: mrpt::poses::CPointPDF::copyFrom(const class mrpt::poses::CPointPDF &) --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDF::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPointPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPointPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
clone(...)
clone(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Returns a deep copy (clone) of the object, indepently of its class. 
 
C++: mrpt::rtti::CObject::clone() const --> class mrpt::rtti::CObject *
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t:
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, outPart: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::drawSingleSample(class mrpt::poses::CPoint3D &) const --> void
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceAndMean(...)
getCovarianceAndMean(*args, **kwargs)
Overloaded function.
 
1. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> Tuple[mrpt::math::CMatrixFixed<double, 3ul, 3ul>, mrpt::poses::CPoint3D]
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPoint3D>
 
2. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, c: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, mean: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceAndMean(class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::poses::CPoint3D &) const --> void
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, mean_point: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getMean(class mrpt::poses::CPoint3D &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getMeanVal() const --> class mrpt::poses::CPoint3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, file: str) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::saveToTextFile(const std::string &) const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPointPDFGaussian(CPointPDF)
    A gaussian distribution for 3D points. Also a method for bayesian fusion is
provided.
 
 
CPointPDF
 
 
Method resolution order:
CPointPDFGaussian
CPointPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFGaussian::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPoint3D, init_Cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, : mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPointPDFGaussian
 
C++: mrpt::poses::CPointPDFGaussian::operator=(const class mrpt::poses::CPointPDFGaussian &) --> class mrpt::poses::CPointPDFGaussian &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p2: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPointPDFGaussian::bayesianFusion(const class mrpt::poses::CPointPDFGaussian &, const class mrpt::poses::CPointPDFGaussian &) --> void
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
3. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPointPDFGaussian::bayesianFusion(const class mrpt::poses::CPointPDF &, const class mrpt::poses::CPointPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. Both the mean value and the covariance matrix
 are updated correctly. 
 
C++: mrpt::poses::CPointPDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFGaussian::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPointPDFGaussian::copyFrom(const class mrpt::poses::CPointPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, outSample: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
Draw a sample from the pdf 
 
C++: mrpt::poses::CPointPDFGaussian::drawSingleSample(class mrpt::poses::CPoint3D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPoint3D]
 
C++: mrpt::poses::CPointPDFGaussian::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPoint3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
C++: mrpt::poses::CPointPDFGaussian::getMean(class mrpt::poses::CPoint3D &) const --> void
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(*args, **kwargs)
Overloaded function.
 
1. mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, other: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> float
 
2. mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, other: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, only_2D: bool) -> float
 
Returns the Mahalanobis distance from this PDF to another PDF, that is,
 it's evaluation at (0,0,0) 
 
C++: mrpt::poses::CPointPDFGaussian::mahalanobisDistanceTo(const class mrpt::poses::CPointPDFGaussian &, bool) const --> double
productIntegralNormalizedWith(...)
productIntegralNormalizedWith(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is in the range [0,1]
  Note that the resulting value is in fact
  
 
 
  , with 
 being the square Mahalanobis distance between the
 two pdfs.
 
 
 productIntegralWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPointPDFGaussian::productIntegralNormalizedWith(const class mrpt::poses::CPointPDFGaussian &) const --> double
productIntegralNormalizedWith2D(...)
productIntegralNormalizedWith2D(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is in the range [0,1]. This versions ignores the
 "z" coordinate.
 
  Note that the resulting value is in fact
  
 
 
  , with 
 being the square Mahalanobis distance between the
 two pdfs.
 
 
 productIntegralWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPointPDFGaussian::productIntegralNormalizedWith2D(const class mrpt::poses::CPointPDFGaussian &) const --> double
productIntegralWith(...)
productIntegralWith(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is >=0.
 
 
 productIntegralNormalizedWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPointPDFGaussian::productIntegralWith(const class mrpt::poses::CPointPDFGaussian &) const --> double
productIntegralWith2D(...)
productIntegralWith2D(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, p: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> float
 
Computes the "correspondence likelihood" of this PDF with another one:
 This is implemented as the integral from -inf to +inf of the product of
 both PDF.
 The resulting number is >=0.
 NOTE: This version ignores the "z" coordinates!!
 
 
 productIntegralNormalizedWith
 
 
 std::exception On errors like covariance matrix with null
 determinant, etc...
 
C++: mrpt::poses::CPointPDFGaussian::productIntegralWith2D(const class mrpt::poses::CPointPDFGaussian &) const --> double
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian, file: str) -> bool
 
Save PDF's particles to a text file, containing the 2D pose in the first
 line, then the covariance matrix in next 3 lines. 
 
C++: mrpt::poses::CPointPDFGaussian::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFGaussian::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFGaussian::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov
mean

Static methods inherited from CPointPDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPointPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPointPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getMeanVal() const --> class mrpt::poses::CPoint3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPointPDFParticles(CPointPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t)
    A probability distribution of a 2D/3D point, represented as a set of random
samples (particles).
 
 
CPointPDF
 
 
Method resolution order:
CPointPDFParticles
CPointPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFParticles::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, numParticles: int) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, : mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> mrpt.pymrpt.mrpt.poses.CPointPDFParticles
 
C++: mrpt::poses::CPointPDFParticles::operator=(const class mrpt::poses::CPointPDFParticles &) --> class mrpt::poses::CPointPDFParticles &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPointPDFParticles::bayesianFusion(const class mrpt::poses::CPointPDF &, const class mrpt::poses::CPointPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. Both the mean value and the covariance matrix
 are updated correctly.  
 
C++: mrpt::poses::CPointPDFParticles::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> None
 
Clear all the particles (free memory) 
 
C++: mrpt::poses::CPointPDFParticles::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFParticles::clone() const --> class mrpt::rtti::CObject *
computeKurtosis(...)
computeKurtosis(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> float
 
Compute the kurtosis of the distribution 
 
C++: mrpt::poses::CPointPDFParticles::computeKurtosis() --> double
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, o: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPointPDFParticles::copyFrom(const class mrpt::poses::CPointPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, outSample: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
Draw a sample from the pdf 
 
C++: mrpt::poses::CPointPDFParticles::drawSingleSample(class mrpt::poses::CPoint3D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPoint3D]
 
C++: mrpt::poses::CPointPDFParticles::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPoint3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, mean_point: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
C++: mrpt::poses::CPointPDFParticles::getMean(class mrpt::poses::CPoint3D &) const --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, file: str) -> bool
 
Save PDF's particles to a text file, where each line is: X Y Z LOG_W 
 
C++: mrpt::poses::CPointPDFParticles::saveToTextFile(const std::string &) const --> bool
setSize(...)
setSize(*args, **kwargs)
Overloaded function.
 
1. setSize(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, numberParticles: int) -> None
 
2. setSize(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles, numberParticles: int, defaultValue: mrpt::math::TPoint3D_<float>) -> None
 
Erase all the previous particles and change the number of particles,
 with a given initial value  
 
C++: mrpt::poses::CPointPDFParticles::setSize(size_t, const struct mrpt::math::TPoint3D_<float> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPointPDFParticles) -> int
 
Returns the number of particles 
 
C++: mrpt::poses::CPointPDFParticles::size() const --> size_t

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFParticles::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFParticles::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Static methods inherited from CPointPDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPointPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPointPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getMeanVal() const --> class mrpt::poses::CPoint3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::isInfType() const --> bool

Methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t:
clearParticles(...)
clearParticles(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> None
 
C++: mrpt::bayes::CParticleFilterData<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>::clearParticles() --> void
getMostLikelyParticle(...)
getMostLikelyParticle(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, (mrpt::bayes::particle_storage_mode)1>
 
C++: mrpt::bayes::CParticleFilterData<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>::getMostLikelyParticle() const --> const struct mrpt::bayes::CProbabilityParticle<struct mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER> *

Data descriptors inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t:
m_particles

Methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t:
ESS(...)
ESS(*args, **kwargs)
Overloaded function.
 
1. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::ESS() const --> double
 
2. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> float
 
Returns the normalized ESS (Estimated Sample Size), in the range [0,1].
  Note that you do NOT need to normalize the weights before calling this.
 
C++: mrpt::bayes::CParticleFilterCapable::ESS() const --> double
derived(...)
derived(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> mrpt::poses::CPointPDFParticles
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::derived() --> class mrpt::poses::CPointPDFParticles &
fastDrawSample(...)
fastDrawSample(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> int
 
Draws a random sample from the particle filter, in such a way that each
particle has a probability proportional to its weight (in the standard PF
algorithm).
   This method can be used to generate a variable number of m_particles
when resampling: to vary the number of m_particles in the filter.
   See prepareFastDrawSample for more information, or the 
*href="http://www.mrpt.org/Particle_Filters" >Particle Filter
tutorial.
 
 NOTES:
                - You MUST call "prepareFastDrawSample" ONCE before calling this
method. That method must be called after modifying the particle filter
(executing one step, resampling, etc...)
                - This method returns ONE index for the selected ("drawn") particle,
in
the range [0,M-1]
                - You do not need to call "normalizeWeights" before calling this.
 
 
 prepareFastDrawSample
 
C++: mrpt::bayes::CParticleFilterCapable::fastDrawSample(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) const --> size_t
getW(...)
getW(*args, **kwargs)
Overloaded function.
 
1. getW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, i: int) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::getW(size_t) const --> double
 
2. getW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, i: int) -> float
 
Access to i'th particle (logarithm) weight, where first one is index 0.
 
C++: mrpt::bayes::CParticleFilterCapable::getW(size_t) const --> double
normalizeWeights(...)
normalizeWeights(*args, **kwargs)
Overloaded function.
 
1. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> float
 
2. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, out_max_log_w: float) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::normalizeWeights(double *) --> double
 
3. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable) -> float
 
4. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, out_max_log_w: float) -> float
 
Normalize the (logarithmic) weights, such as the maximum weight is zero.
 
 
 If provided, will return with the maximum log_w
 before normalizing, such as new_weights = old_weights - max_log_w.
 
 
 The max/min ratio of weights ("dynamic range")
 
C++: mrpt::bayes::CParticleFilterCapable::normalizeWeights(double *) --> double
particlesCount(...)
particlesCount(*args, **kwargs)
Overloaded function.
 
1. particlesCount(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> int
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::particlesCount() const --> size_t
 
2. particlesCount(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t) -> int
 
Get the m_particles count.
 
C++: mrpt::bayes::CParticleFilterCapable::particlesCount() const --> size_t
performResampling(...)
performResampling(*args, **kwargs)
Overloaded function.
 
1. performResampling(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
2. performResampling(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, out_particle_count: int) -> None
 
Performs a resample of the m_particles, using the method selected in the
 constructor.
 After computing the surviving samples, this method internally calls
 "performSubstitution" to actually perform the particle replacement.
 This method is called automatically by CParticleFilter::execute,
 andshould not be invoked manually normally.
 To just obtaining the sequence of resampled indexes from a sequence of
 weights, use "resample"
 
 
 The desired number of output particles
 after resampling; 0 means don't modify the current number.
 
 
 resample
 
C++: mrpt::bayes::CParticleFilterCapable::performResampling(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t) --> void
prediction_and_update(...)
prediction_and_update(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Performs the prediction stage of the Particle Filter.
  This method simply selects the appropiate protected method according to
 the particle filter algorithm to run.
 
 
 
 prediction_and_update_pfStandardProposal,prediction_and_update_pfAuxiliaryPFStandard,prediction_and_update_pfOptimalProposal,prediction_and_update_pfAuxiliaryPFOptimal
 
C++: mrpt::bayes::CParticleFilterCapable::prediction_and_update(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
setW(...)
setW(*args, **kwargs)
Overloaded function.
 
1. setW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, i: int, w: float) -> None
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPointPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPoint3D_<float>, mrpt::bayes::particle_storage_mode::POINTER>>>::setW(size_t, double) --> void
 
2. setW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t, i: int, w: float) -> None
 
Modifies i'th particle (logarithm) weight, where first one is index 0.
 
C++: mrpt::bayes::CParticleFilterCapable::setW(size_t, double) --> void

Static methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPointPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPoint3D_float_mrpt_bayes_particle_storage_mode_POINTER_t:
defaultEvaluator(...) from builtins.PyCapsule
defaultEvaluator(PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, obj: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable, index: int, action: capsule, observation: capsule) -> float
 
The default evaluator function, which simply returns the particle
 weight.
  The action and the observation are declared as "void*" for a greater
 flexibility.
 
 
 prepareFastDrawSample
 
C++: mrpt::bayes::CParticleFilterCapable::defaultEvaluator(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, const class mrpt::bayes::CParticleFilterCapable *, size_t, const void *, const void *) --> double

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPointPDFSOG(CPointPDF)
    Declares a class that represents a Probability Density function (PDF) of a
 3D point 
 
.
   This class implements that PDF as the following multi-modal Gaussian
 distribution:
 
 
 
 
  Where the number of modes N is the size of CPointPDFSOG::m_modes
 
  See mrpt::poses::CPointPDF for more details.
 
 
 CPointPDFCPosePDF,
 
 
Method resolution order:
CPointPDFSOG
CPointPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
ESS(...)
ESS(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> float
 
Computes the "Effective sample size" (typical measure for Particle
 Filters), applied to the weights of the individual Gaussian modes, as a
 measure of the equality of the modes (in the range [0,total # of modes]).
 
C++: mrpt::poses::CPointPDFSOG::ESS() const --> double
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFSOG::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, i: int) -> mrpt::poses::CPointPDFSOG::TGaussianMode
 
Access to individual beacons 
 
C++: mrpt::poses::CPointPDFSOG::operator[](size_t) --> struct mrpt::poses::CPointPDFSOG::TGaussianMode &
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, nModes: int) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, arg0: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, : mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> mrpt.pymrpt.mrpt.poses.CPointPDFSOG
 
C++: mrpt::poses::CPointPDFSOG::operator=(const class mrpt::poses::CPointPDFSOG &) --> class mrpt::poses::CPointPDFSOG &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, p1: mrpt.pymrpt.mrpt.poses.CPointPDF, p2: mrpt.pymrpt.mrpt.poses.CPointPDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two point distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPointPDFSOG::bayesianFusion(const class mrpt::poses::CPointPDF &, const class mrpt::poses::CPointPDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPointPDFSOG::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> None
 
Clear all the gaussian modes 
 
C++: mrpt::poses::CPointPDFSOG::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFSOG::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, o: mrpt.pymrpt.mrpt.poses.CPointPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPointPDFSOG::copyFrom(const class mrpt::poses::CPointPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, outSample: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
Draw a sample from the pdf. 
 
C++: mrpt::poses::CPointPDFSOG::drawSingleSample(class mrpt::poses::CPoint3D &) const --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> bool
 
Return whether there is any Gaussian mode. 
 
C++: mrpt::poses::CPointPDFSOG::empty() const --> bool
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, x: mrpt.pymrpt.mrpt.poses.CPoint3D, sumOverAllZs: bool) -> float
 
Evaluates the PDF at a given point 
 
C++: mrpt::poses::CPointPDFSOG::evaluatePDF(const class mrpt::poses::CPoint3D &, bool) const --> double
evaluatePDFInArea(...)
evaluatePDFInArea(*args, **kwargs)
Overloaded function.
 
1. evaluatePDFInArea(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, x_min: float, x_max: float, y_min: float, y_max: float, resolutionXY: float, z: float, outMatrix: mrpt.pymrpt.mrpt.math.CMatrixD) -> None
 
2. evaluatePDFInArea(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, x_min: float, x_max: float, y_min: float, y_max: float, resolutionXY: float, z: float, outMatrix: mrpt.pymrpt.mrpt.math.CMatrixD, sumOverAllZs: bool) -> None
 
Evaluates the PDF within a rectangular grid and saves the result in a
 matrix (each row contains values for a fixed y-coordinate value).
 
C++: mrpt::poses::CPointPDFSOG::evaluatePDFInArea(float, float, float, float, float, float, class mrpt::math::CMatrixD &, bool) --> void
get(...)
get(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, i: int) -> mrpt::poses::CPointPDFSOG::TGaussianMode
 
Access to individual beacons 
 
C++: mrpt::poses::CPointPDFSOG::get(size_t) --> struct mrpt::poses::CPointPDFSOG::TGaussianMode &
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPoint3D]
 
C++: mrpt::poses::CPointPDFSOG::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPoint3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, mean_point: mrpt.pymrpt.mrpt.poses.CPoint3D) -> None
 
C++: mrpt::poses::CPointPDFSOG::getMean(class mrpt::poses::CPoint3D &) const --> void
getMostLikelyMode(...)
getMostLikelyMode(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, outVal: mrpt.pymrpt.mrpt.poses.CPointPDFGaussian) -> None
 
Return the Gaussian mode with the highest likelihood (or an empty
 Gaussian if there are no modes in this SOG) 
 
C++: mrpt::poses::CPointPDFSOG::getMostLikelyMode(class mrpt::poses::CPointPDFGaussian &) const --> void
normalizeWeights(...)
normalizeWeights(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> None
 
Normalize the weights in m_modes such as the maximum log-weight is 0 
 
C++: mrpt::poses::CPointPDFSOG::normalizeWeights() --> void
push_back(...)
push_back(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, m: mrpt::poses::CPointPDFSOG::TGaussianMode) -> None
 
Inserts a copy of the given mode into the SOG 
 
C++: mrpt::poses::CPointPDFSOG::push_back(const struct mrpt::poses::CPointPDFSOG::TGaussianMode &) --> void
resize(...)
resize(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, N: int) -> None
 
Resize the number of SOG modes 
 
C++: mrpt::poses::CPointPDFSOG::resize(size_t) --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG, file: str) -> bool
 
Save the density to a text file, with the following format:
  There is one row per Gaussian "mode", and each row contains 10
 elements:
   - w (The weight)
   - x_mean (gaussian mean value)
   - y_mean (gaussian mean value)
   - x_mean (gaussian mean value)
   - C11 (Covariance elements)
   - C22 (Covariance elements)
   - C33 (Covariance elements)
   - C12 (Covariance elements)
   - C13 (Covariance elements)
   - C23 (Covariance elements)
 
         
 
C++: mrpt::poses::CPointPDFSOG::saveToTextFile(const std::string &) const --> bool
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPointPDFSOG) -> int
 
Return the number of Gaussian modes. 
 
C++: mrpt::poses::CPointPDFSOG::size() const --> size_t

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPointPDFSOG::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPointPDFSOG::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data and other attributes defined here:
TGaussianMode = <class 'mrpt.pymrpt.mrpt.poses.CPointPDFSOG.TGaussianMode'>
The struct for each mode:

Static methods inherited from CPointPDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPointPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPointPDF::is_PDF() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPoint3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPoint3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::getMeanVal() const --> class mrpt::poses::CPoint3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPoint3D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPoint3D, 3>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoint_mrpt_poses_CPoint2D_2UL_t(CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, mrpt.pymrpt.mrpt.Stringifyable)
    
Method resolution order:
CPoint_mrpt_poses_CPoint2D_2UL_t
CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, i: int) -> float
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::operator[](unsigned int) --> double &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, s: float) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::operator*=(const double) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> None
asString(...)
asString(*args, **kwargs)
Overloaded function.
 
1. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> str
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::asString() const --> std::string
 
2. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> str
 
Returns a human-friendly textual description of the object. For classes
 with a large/complex internal state, only a summary should be returned
 instead of the exhaustive enumeration of all data members.
 
C++: mrpt::Stringifyable::asString() const --> std::string
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::math::CMatrixFixed<double, 2ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 2, 1>
assign(...)
assign(*args, **kwargs)
Overloaded function.
 
1. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, : mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::operator=(const class mrpt::poses::CPoint<class mrpt::poses::CPoint2D, 2> &) --> class mrpt::poses::CPoint<class mrpt::poses::CPoint2D, 2> &
 
2. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint2D, 2> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint2D, 2> &
 
3. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, : mrpt.pymrpt.mrpt.Stringifyable) -> mrpt.pymrpt.mrpt.Stringifyable
 
C++: mrpt::Stringifyable::operator=(const class mrpt::Stringifyable &) --> class mrpt::Stringifyable &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::poses::CPoint2D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::derived() --> class mrpt::poses::CPoint2D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, s: str) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint2D, 2>::fromString(const std::string &) --> void
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoint_mrpt_poses_CPoint3D_3UL_t(CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, mrpt.pymrpt.mrpt.Stringifyable)
    
Method resolution order:
CPoint_mrpt_poses_CPoint3D_3UL_t
CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, i: int) -> float
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::operator[](unsigned int) --> double &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, s: float) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::operator*=(const double) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> None
asString(...)
asString(*args, **kwargs)
Overloaded function.
 
1. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> str
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::asString() const --> std::string
 
2. asString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> str
 
Returns a human-friendly textual description of the object. For classes
 with a large/complex internal state, only a summary should be returned
 instead of the exhaustive enumeration of all data members.
 
C++: mrpt::Stringifyable::asString() const --> std::string
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 3, 1>
assign(...)
assign(*args, **kwargs)
Overloaded function.
 
1. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, : mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::operator=(const class mrpt::poses::CPoint<class mrpt::poses::CPoint3D, 3> &) --> class mrpt::poses::CPoint<class mrpt::poses::CPoint3D, 3> &
 
2. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint3D, 3> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint3D, 3> &
 
3. assign(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, : mrpt.pymrpt.mrpt.Stringifyable) -> mrpt.pymrpt.mrpt.Stringifyable
 
C++: mrpt::Stringifyable::operator=(const class mrpt::Stringifyable &) --> class mrpt::Stringifyable &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::derived() --> class mrpt::poses::CPoint3D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, s: str) -> None
 
C++: mrpt::poses::CPoint<mrpt::poses::CPoint3D, 3>::fromString(const std::string &) --> void
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose2D(CPose_mrpt_poses_CPose2D_3UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
    A class used to store a 2D pose, including the 2D coordinate point and a
 heading (phi) angle.
  Use this class instead of lightweight mrpt::math::TPose2D when pose/point
 composition is to be called
  multiple times with the same pose, since this class caches calls to
 expensive trigronometric functions.
 
 For a complete description of Points/Poses, see mrpt::poses::CPoseOrPoint,
 or refer to [this documentation page]
(http://www.mrpt.org/tutorials/programming/maths-and-geometry/2d_3d_geometry/)
 
  
   
  
 
 
 Read also: "A tutorial on SE(3) transformation parameterizations and
 on-manifold optimization", Jose-Luis Blanco.
 http://ingmec.ual.es/~jlblanco/papers/jlblanco2010geometry3D_techrep.pdf
 
 
 CPoseOrPoint,CPoint2D
 
 
Method resolution order:
CPose2D
CPose_mrpt_poses_CPose2D_3UL_t
CPoseOrPoint_mrpt_poses_CPose2D_3UL_t
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
AddComponents(...)
AddComponents(self: mrpt.pymrpt.mrpt.poses.CPose2D, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Scalar sum of components: This is diferent from poses
    composition, which is implemented as "+" operators in "CPose" derived
 classes.
 
C++: mrpt::poses::CPose2D::AddComponents(const class mrpt::poses::CPose2D &) --> void
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose2D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__add__(...)
__add__(*args, **kwargs)
Overloaded function.
 
1. __add__(self: mrpt.pymrpt.mrpt.poses.CPose2D, D: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
The operator 
 is the pose compounding operator.
 
C++: mrpt::poses::CPose2D::operator+(const class mrpt::poses::CPose2D &) const --> class mrpt::poses::CPose2D
 
2. __add__(self: mrpt.pymrpt.mrpt.poses.CPose2D, D: mrpt::poses::CPose3D) -> mrpt::poses::CPose3D
 
The operator 
 is the pose compounding operator.
 
C++: mrpt::poses::CPose2D::operator+(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPose3D
 
3. __add__(self: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt::poses::CPoint2D) -> mrpt::poses::CPoint2D
 
The operator 
 is the pose/point compounding
 operator.  
 
C++: mrpt::poses::CPose2D::operator+(const class mrpt::poses::CPoint2D &) const --> class mrpt::poses::CPoint2D
 
4. __add__(self: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt::poses::CPoint3D) -> mrpt::poses::CPoint3D
 
The operator 
 is the pose/point compounding
 operator. 
 
C++: mrpt::poses::CPose2D::operator+(const class mrpt::poses::CPoint3D &) const --> class mrpt::poses::CPoint3D
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPose2D, i: int) -> float
 
C++: mrpt::poses::CPose2D::operator[](unsigned int) --> double &
__iadd__(...)
__iadd__(self: mrpt.pymrpt.mrpt.poses.CPose2D, b: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
Make 
  
 
C++: mrpt::poses::CPose2D::operator+=(const class mrpt::poses::CPose2D &) --> class mrpt::poses::CPose2D &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPose2D, s: float) -> None
 
Scalar multiplication.
 
C++: mrpt::poses::CPose2D::operator*=(const double) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, x: float, y: float, phi: float) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt::poses::CPoint2D) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt::poses::CPose3D) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt::math::TPose2D) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt::poses::CPoint3D) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt.pymrpt.mrpt.poses.TConstructorFlags_Poses) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, arg0: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2D, arg0: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> str
__sub__(...)
__sub__(*args, **kwargs)
Overloaded function.
 
1. __sub__(self: mrpt.pymrpt.mrpt.poses.CPose2D, b: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
Compute 
  
 
C++: mrpt::poses::CPose2D::operator-(const class mrpt::poses::CPose2D &) const --> class mrpt::poses::CPose2D
 
2. __sub__(self: mrpt.pymrpt.mrpt.poses.CPose2D, b: mrpt::poses::CPose3D) -> mrpt::poses::CPose3D
 
The operator 
 is the pose inverse compounding
 operator. 
 
C++: mrpt::poses::CPose2D::operator-(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPose3D
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> str
 
Returns a human-readable textual representation of the object (eg: "[x y
 yaw]", yaw in degrees)
 
 
 fromString
 
C++: mrpt::poses::CPose2D::asString() const --> std::string
asTPose(...)
asTPose(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt::math::TPose2D
 
C++: mrpt::poses::CPose2D::asTPose() const --> struct mrpt::math::TPose2D
asVector(...)
asVector(self: mrpt.pymrpt.mrpt.poses.CPose2D, v: mrpt::math::CMatrixFixed<double, 3ul, 1ul>) -> None
 
Returns a 1x3 vector with [x y phi] 
 
C++: mrpt::poses::CPose2D::asVector(class mrpt::math::CMatrixFixed<double, 3, 1> &) const --> void
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose2D, : mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPose2D::operator=(const class mrpt::poses::CPose2D &) --> class mrpt::poses::CPose2D &
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose2D, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
makes: this = p (+) this 
 
C++: mrpt::poses::CPose2D::changeCoordinatesReference(const class mrpt::poses::CPose2D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose2D::clone() const --> class mrpt::rtti::CObject *
composeFrom(...)
composeFrom(self: mrpt.pymrpt.mrpt.poses.CPose2D, A: mrpt.pymrpt.mrpt.poses.CPose2D, B: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Makes 
 
  
 A or B can be "this" without problems.  
 
C++: mrpt::poses::CPose2D::composeFrom(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &) --> void
composePoint(...)
composePoint(*args, **kwargs)
Overloaded function.
 
1. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, lx: float, ly: float, gx: float, gy: float) -> None
 
An alternative, slightly more efficient way of doing 
 
 with G and L being 2D points and P this 2D pose.  
 
C++: mrpt::poses::CPose2D::composePoint(double, double, double &, double &) const --> void
 
2. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, l: mrpt::math::TPoint2D_<double>, g: mrpt::math::TPoint2D_<double>) -> None
 
overload 
 with G and L being 2D points and P this
 2D pose 
 
C++: mrpt::poses::CPose2D::composePoint(const struct mrpt::math::TPoint2D_<double> &, struct mrpt::math::TPoint2D_<double> &) const --> void
 
3. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, l: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
C++: mrpt::poses::CPose2D::composePoint(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
 
4. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, l: mrpt::math::TPoint3D_<double>, g: mrpt::math::TPoint3D_<double>) -> None
 
overload 
 with G and L being 3D points and P this
 2D pose (the "z" coordinate remains unmodified) 
 
C++: mrpt::poses::CPose2D::composePoint(const struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint3D_<double> &) const --> void
 
5. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, lx: float, ly: float, lz: float, gx: float, gy: float, gz: float) -> None
 
overload (the "z" coordinate remains unmodified) 
 
C++: mrpt::poses::CPose2D::composePoint(double, double, double, double &, double &, double &) const --> void
distance2DFrobeniusTo(...)
distance2DFrobeniusTo(self: mrpt.pymrpt.mrpt.poses.CPose2D, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Returns the 2D distance from this pose/point to a 2D pose using the
 Frobenius distance. 
 
C++: mrpt::poses::CPose2D::distance2DFrobeniusTo(const class mrpt::poses::CPose2D &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPose2D, s: str) -> None
 
Set the current object value from a string generated by 'asString' (eg:
 "[0.02 1.04 -0.8]" )
 
 
 asString
 
 
 std::exception On invalid format
 
C++: mrpt::poses::CPose2D::fromString(const std::string &) --> void
fromStringRaw(...)
fromStringRaw(self: mrpt.pymrpt.mrpt.poses.CPose2D, s: str) -> None
 
Same as fromString, but without requiring the square brackets in the
 string 
 
C++: mrpt::poses::CPose2D::fromStringRaw(const std::string &) --> void
getHomogeneousMatrix(...)
getHomogeneousMatrix(self: mrpt.pymrpt.mrpt.poses.CPose2D, out_HM: mrpt::math::CMatrixFixed<double, 4ul, 4ul>) -> None
 
Returns the corresponding 4x4 homogeneous transformation matrix for the
 point(translation) or pose (translation+orientation).
 
 
 getInverseHomogeneousMatrix
 
C++: mrpt::poses::CPose2D::getHomogeneousMatrix(class mrpt::math::CMatrixFixed<double, 4, 4> &) const --> void
getOppositeScalar(...)
getOppositeScalar(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
Return the opposite of the current pose instance by taking the negative
 of all its components 
         
 
C++: mrpt::poses::CPose2D::getOppositeScalar() const --> class mrpt::poses::CPose2D
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPose2D::getPoseMean() --> class mrpt::poses::CPose2D &
getRotationMatrix(...)
getRotationMatrix(*args, **kwargs)
Overloaded function.
 
1. getRotationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose2D, R: mrpt::math::CMatrixFixed<double, 2ul, 2ul>) -> None
 
Returns the SE(2) 2x2 rotation matrix 
 
C++: mrpt::poses::CPose2D::getRotationMatrix(class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
 
2. getRotationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose2D, R: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
Returns the equivalent SE(3) 3x3 rotation matrix, with (2,2)=1. 
 
C++: mrpt::poses::CPose2D::getRotationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Convert this pose into its inverse, saving the result in itself. 
 
 operator- 
 
C++: mrpt::poses::CPose2D::inverse() --> void
inverseComposeFrom(...)
inverseComposeFrom(self: mrpt.pymrpt.mrpt.poses.CPose2D, A: mrpt.pymrpt.mrpt.poses.CPose2D, B: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Makes 
 this method is slightly more efficient
 than "this= A - B;" since it avoids the temporary object.
  
 
 A or B can be "this" without problems.
 
 
 composeFrom, composePoint
 
C++: mrpt::poses::CPose2D::inverseComposeFrom(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &) --> void
inverseComposePoint(...)
inverseComposePoint(*args, **kwargs)
Overloaded function.
 
1. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, gx: float, gy: float, lx: float, ly: float) -> None
 
Computes the 2D point L such as 

 
 composePoint, composeFrom 
 
C++: mrpt::poses::CPose2D::inverseComposePoint(const double, const double, double &, double &) const --> void
 
2. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, g: mrpt::math::TPoint2D_<double>, l: mrpt::math::TPoint2D_<double>) -> None
 
C++: mrpt::poses::CPose2D::inverseComposePoint(const struct mrpt::math::TPoint2D_<double> &, struct mrpt::math::TPoint2D_<double> &) const --> void
 
3. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose2D, g: mrpt::math::TPoint2D_<double>) -> mrpt::math::TPoint2D_<double>
 
C++: mrpt::poses::CPose2D::inverseComposePoint(const struct mrpt::math::TPoint2D_<double> &) const --> struct mrpt::math::TPoint2D_<double>
normalizePhi(...)
normalizePhi(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Forces "phi" to be in the range [-pi,pi];
 
C++: mrpt::poses::CPose2D::normalizePhi() --> void
phi(...)
phi(*args, **kwargs)
Overloaded function.
 
1. phi(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
C++: mrpt::poses::CPose2D::phi() --> double &
 
2. phi(self: mrpt.pymrpt.mrpt.poses.CPose2D, angle: float) -> None
 
Set the phi angle of the 2D pose (in radians) 
 
C++: mrpt::poses::CPose2D::phi(double) --> void
phi_cos(...)
phi_cos(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Get a (cached) value of cos(phi), recomputing it only once when phi
 changes. 
 
C++: mrpt::poses::CPose2D::phi_cos() const --> double
phi_incr(...)
phi_incr(self: mrpt.pymrpt.mrpt.poses.CPose2D, Aphi: float) -> None
 
Increment the PHI angle (without checking the 2 PI range, call
 normalizePhi is needed) 
 
C++: mrpt::poses::CPose2D::phi_incr(const double) --> void
phi_sin(...)
phi_sin(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Get a (cached) value of sin(phi), recomputing it only once when phi
 changes. 
 
C++: mrpt::poses::CPose2D::phi_sin() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPose2D::setToNaN() --> void
translation(...)
translation(self: mrpt.pymrpt.mrpt.poses.CPose2D) -> mrpt::math::TPoint2D_<double>
 
Returns the (x,y) translational part of the SE(2) transformation. 
 
C++: mrpt::poses::CPose2D::translation() const --> struct mrpt::math::TPoint2D_<double>

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose2D::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
FromString(...) from builtins.PyCapsule
FromString(s: str) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPose2D::FromString(const std::string &) --> class mrpt::poses::CPose2D
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose2D::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
Identity(...) from builtins.PyCapsule
Identity() -> mrpt.pymrpt.mrpt.poses.CPose2D
 
Returns the identity transformation 
 
C++: mrpt::poses::CPose2D::Identity() --> class mrpt::poses::CPose2D
empty(...) from builtins.PyCapsule
empty() -> bool
 
C++: mrpt::poses::CPose2D::empty() --> bool
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose2D::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose2D::is_PDF() --> bool
max_size(...) from builtins.PyCapsule
max_size() -> int
 
C++: mrpt::poses::CPose2D::max_size() --> unsigned long
resize(...) from builtins.PyCapsule
resize(n: int) -> None
 
C++: mrpt::poses::CPose2D::resize(size_t) --> void
size(...) from builtins.PyCapsule
size() -> int
 
C++: mrpt::poses::CPose2D::size() --> unsigned long

Data descriptors defined here:
m_coords

Methods inherited from CPose_mrpt_poses_CPose2D_3UL_t:
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 3, 1>
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t) -> mrpt::poses::CPose2D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::derived() --> class mrpt::poses::CPose2D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::norm() const --> double
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y_incr(const double) --> void

Static methods inherited from CPose_mrpt_poses_CPose2D_3UL_t:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::is3DPoseOrPoint() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose2DGridTemplate_double_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPose2DGridTemplate_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float) -> None
 
doc
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float) -> None
 
doc
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float) -> None
 
doc
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float) -> None
 
doc
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float, phiMin: float) -> None
 
doc
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float, phiMin: float, phiMax: float) -> None
 
10. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, arg0: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, : mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t
 
C++: mrpt::poses::CPose2DGridTemplate<double>::operator=(const class mrpt::poses::CPose2DGridTemplate<double> &) --> class mrpt::poses::CPose2DGridTemplate<double> &
getByIndex(...)
getByIndex(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, x: int, y: int, phi: int) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getByIndex(size_t, size_t, size_t) --> double *
getByPos(...)
getByPos(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, x: float, y: float, phi: float) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getByPos(double, double, double) --> double *
getPhiMax(...)
getPhiMax(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getPhiMax() const --> double
getPhiMin(...)
getPhiMin(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getPhiMin() const --> double
getResolutionPhi(...)
getResolutionPhi(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getResolutionPhi() const --> double
getResolutionXY(...)
getResolutionXY(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getResolutionXY() const --> double
getSizePhi(...)
getSizePhi(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getSizePhi() const --> size_t
getSizeX(...)
getSizeX(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getSizeX() const --> size_t
getSizeY(...)
getSizeY(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getSizeY() const --> size_t
getXMax(...)
getXMax(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getXMax() const --> double
getXMin(...)
getXMin(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getXMin() const --> double
getYMax(...)
getYMax(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getYMax() const --> double
getYMin(...)
getYMin(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::getYMin() const --> double
idx2phi(...)
idx2phi(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, phi: int) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::idx2phi(size_t) const --> double
idx2x(...)
idx2x(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, x: int) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::idx2x(size_t) const --> double
idx2y(...)
idx2y(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, y: int) -> float
 
C++: mrpt::poses::CPose2DGridTemplate<double>::idx2y(size_t) const --> double
phi2idx(...)
phi2idx(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, phi: float) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::phi2idx(double) const --> size_t
setSize(...)
setSize(*args, **kwargs)
Overloaded function.
 
1. setSize(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float) -> None
 
2. setSize(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float, phiMin: float) -> None
 
3. setSize(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float, phiMin: float, phiMax: float) -> None
 
C++: mrpt::poses::CPose2DGridTemplate<double>::setSize(double, double, double, double, double, double, double, double) --> void
x2idx(...)
x2idx(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, x: float) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::x2idx(double) const --> size_t
y2idx(...)
y2idx(self: mrpt.pymrpt.mrpt.poses.CPose2DGridTemplate_double_t, y: float) -> int
 
C++: mrpt::poses::CPose2DGridTemplate<double>::y2idx(double) const --> size_t

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose2DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_2_t)
    This class stores a time-stamped trajectory in SE(2) (mrpt::math::TPose2D
poses).
 It can also interpolate SE(2) poses over time using linear, splines or
SLERP interpolation, as set in CPose2DInterpolator::setInterpolationMethod()
 Usage:
  - Insert new poses into the sequence with CPose2DInterpolator::insert()
  - Query an exact/interpolated pose with
CPose2DInterpolator::interpolate().
Example:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Time is represented with mrpt::Clock::time_point.
 See mrpt::system for methods and utilities to manage these time references.
 
 See TInterpolatorMethod for the list of interpolation methods. The default
method at constructor is "imLinearSlerp".
 
 
CPoseOrPoint
 
 
Method resolution order:
CPose2DInterpolator
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
CPoseInterpolatorBase_2_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose2DInterpolator::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator, arg0: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator, arg0: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator, : mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> mrpt.pymrpt.mrpt.poses.CPose2DInterpolator
 
C++: mrpt::poses::CPose2DInterpolator::operator=(const class mrpt::poses::CPose2DInterpolator &) --> class mrpt::poses::CPose2DInterpolator &
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose2DInterpolator) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose2DInterpolator::clone() const --> class mrpt::rtti::CObject *

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose2DInterpolator::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose2DInterpolator::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from CPoseInterpolatorBase_2_t:
at(...)
at(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> mrpt.pymrpt.mrpt.math.TPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::at(const mrpt::Clock::time_point &) --> struct mrpt::math::TPose2D &
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::clear() --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::empty() const --> bool
filter(...)
filter(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, component: int, samples: int) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::filter(unsigned int, unsigned int) --> void
getBoundingBox(...)
getBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, minCorner: mrpt::math::TPoint2D_<double>, maxCorner: mrpt::math::TPoint2D_<double>) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getBoundingBox(struct mrpt::math::TPoint2D_<double> &, struct mrpt::math::TPoint2D_<double> &) const --> void
getInterpolationMethod(...)
getInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> mrpt.pymrpt.mrpt.poses.TInterpolatorMethod
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getInterpolationMethod() const --> enum mrpt::poses::TInterpolatorMethod
getMaxTimeInterpolation(...)
getMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getMaxTimeInterpolation() --> struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>>
getPreviousPoseWithMinDistance(...)
getPreviousPoseWithMinDistance(*args, **kwargs)
Overloaded function.
 
1. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.math.TPose2D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, struct mrpt::math::TPose2D &) --> bool
 
2. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, class mrpt::poses::CPose2D &) --> bool
insert(...)
insert(*args, **kwargs)
Overloaded function.
 
1. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.math.TPose2D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::insert(const mrpt::Clock::time_point &, const struct mrpt::math::TPose2D &) --> void
 
2. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::insert(const mrpt::Clock::time_point &, const class mrpt::poses::CPose2D &) --> void
interpolate(...)
interpolate(*args, **kwargs)
Overloaded function.
 
1. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.math.TPose2D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.math.TPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::interpolate(const mrpt::Clock::time_point &, struct mrpt::math::TPose2D &, bool &) const --> struct mrpt::math::TPose2D &
 
2. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.poses.CPose2D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::interpolate(const mrpt::Clock::time_point &, class mrpt::poses::CPose2D &, bool &) const --> class mrpt::poses::CPose2D &
loadFromTextFile(...)
loadFromTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::loadFromTextFile(const std::string &) --> bool
saveInterpolatedToTextFile(...)
saveInterpolatedToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str, period: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::saveInterpolatedToTextFile(const std::string &, const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::saveToTextFile(const std::string &) const --> bool
setInterpolationMethod(...)
setInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, method: mrpt.pymrpt.mrpt.poses.TInterpolatorMethod) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::setInterpolationMethod(enum mrpt::poses::TInterpolatorMethod) --> void
setMaxTimeInterpolation(...)
setMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, time: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::setMaxTimeInterpolation(const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> int
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::size() const --> size_t

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3D(CPose_mrpt_poses_CPose3D_6UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
    A SE(3) pose, comprising a 3D translation and a 3D rotation.
 
The transformation is stored in two separate containers:
- a 3-array for the translation ∈ R³, and
- a 3x3 rotation matrix ∈ SO(3).
 
This class allows parameterizing 6D poses as a 6-vector
`[x y z yaw pitch roll]` (read below for the angles convention).
Note however, that the yaw/pitch/roll angles are only computed (on-demand and
transparently) when the user requests them. Normally, rotations and
transformations are always handled via the 3x3 SO(3) rotation matrix.
 
Yaw/Pitch/Roll angles are defined as successive rotations around *local*
(dynamic) axes in the Z/Y/X order:
 
![CPose3D](CPose3D.gif)
 
It can be shown that "yaw, pitch, roll" can be also understood as
rotations around *global* (static) axes. Both conventions lead to exactly
the same SE(3) transformations, although in it is conventional to write
the numbers in reverse order.
That is, the same SO(3) rotation can be described equivalently with any of
these two parameterizations:
 
- In local axes Z/Y/X convention: [yaw pitch roll]   (This is the convention
used in mrpt::poses::CPose3D)
- In global axes X/Y/Z convention: [roll pitch yaw] (One of the Euler angles
conventions)
 
For further descriptions of point & pose classes, see
mrpt::poses::CPoseOrPoint or refer
to the [2D/3D Geometry tutorial](http://www.mrpt.org/2D_3D_Geometry) online.
 
To change the individual components of the pose, use CPose3D::setFromValues.
This class assures that the internal SO(3) rotation matrix is always
up-to-date with the "yaw pitch roll" members.
 
Rotations in 3D can be also represented by quaternions. See
mrpt::math::CQuaternion, and method CPose3D::getAsQuaternion.
 
This class and CPose3DQuat are very similar, and they can be converted to the
each other automatically via transformation constructors.
 
For Lie algebra methods, see mrpt::poses::Lie.
 
 
Read also: "A tutorial on SE(3) transformation parameterizations and
on-manifold optimization", in 
 
 
 
 
CPoseOrPoint,CPoint3D, mrpt::math::CQuaternion
 
 
Method resolution order:
CPose3D
CPose_mrpt_poses_CPose3D_6UL_t
CPoseOrPoint_mrpt_poses_CPose3D_6UL_t
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__add__(...)
__add__(*args, **kwargs)
Overloaded function.
 
1. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3D, b: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
The operator 
 is the pose compounding operator. 
 
C++: mrpt::poses::CPose3D::operator+(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPose3D
 
2. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3D, b: mrpt::poses::CPoint3D) -> mrpt::poses::CPoint3D
 
The operator 
 is the pose compounding operator. 
 
C++: mrpt::poses::CPose3D::operator+(const class mrpt::poses::CPoint3D &) const --> class mrpt::poses::CPoint3D
 
3. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3D, b: mrpt::poses::CPoint2D) -> mrpt::poses::CPoint3D
 
The operator 
 is the pose compounding operator. 
 
C++: mrpt::poses::CPose3D::operator+(const class mrpt::poses::CPoint2D &) const --> class mrpt::poses::CPoint3D
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPose3D, i: int) -> float
 
C++: mrpt::poses::CPose3D::operator[](unsigned int) const --> double
__iadd__(...)
__iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3D, b: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Make 
  ( can be "this" without problems)
 
C++: mrpt::poses::CPose3D::operator+=(const class mrpt::poses::CPose3D &) --> class mrpt::poses::CPose3D &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPose3D, s: float) -> None
 
Scalar multiplication of x,y,z,yaw,pitch & roll (angles will be wrapped
 to the ]-pi,pi] interval). 
 
C++: mrpt::poses::CPose3D::operator*=(const double) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, arg0: float, arg1: float, arg2: float) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, arg0: float, arg1: float, arg2: float, arg3: float) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float) -> None
 
doc
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, x: float, y: float, z: float, yaw: float, pitch: float, roll: float) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, m: mrpt::math::CMatrixDynamic<double>) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, m: mrpt::math::CMatrixFixed<double, 4ul, 4ul>) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, rot: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, xyz: mrpt::math::CMatrixFixed<double, 3ul, 1ul>) -> None
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
10. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt::poses::CPoint3D) -> None
 
11. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt::math::TPose3D) -> None
 
12. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, q: mrpt::math::CQuaternion<double>, x: float, y: float, z: float) -> None
 
13. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt::poses::CPose3DQuat) -> None
 
14. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt.pymrpt.mrpt.poses.TConstructorFlags_Poses) -> None
 
15. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, vec12: mrpt::math::CMatrixFixed<double, 12ul, 1ul>) -> None
 
16. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, arg0: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
17. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3D, arg0: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> str
__sub__(...)
__sub__(self: mrpt.pymrpt.mrpt.poses.CPose3D, b: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Compute 
  
 
C++: mrpt::poses::CPose3D::operator-(const class mrpt::poses::CPose3D &) const --> class mrpt::poses::CPose3D
addComponents(...)
addComponents(self: mrpt.pymrpt.mrpt.poses.CPose3D, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Scalar sum of all 6 components: This is diferent from poses composition,
 which is implemented as "+" operators.
 
 
 normalizeAngles
 
C++: mrpt::poses::CPose3D::addComponents(const class mrpt::poses::CPose3D &) --> void
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> str
 
Returns a human-readable textual representation of the object (eg: "[x y
 z yaw pitch roll]", angles in degrees.)
 
 
 fromString
 
C++: mrpt::poses::CPose3D::asString() const --> std::string
asTPose(...)
asTPose(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt::math::TPose3D
 
C++: mrpt::poses::CPose3D::asTPose() const --> struct mrpt::math::TPose3D
asVector(...)
asVector(self: mrpt.pymrpt.mrpt.poses.CPose3D, v: mrpt::math::CMatrixFixed<double, 6ul, 1ul>) -> None
 
Returns a 6x1 vector with [x y z yaw pitch roll]' 
 
C++: mrpt::poses::CPose3D::asVector(class mrpt::math::CMatrixFixed<double, 6, 1> &) const --> void
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3D, : mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPose3D::operator=(const class mrpt::poses::CPose3D &) --> class mrpt::poses::CPose3D &
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3D, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
makes: this = p (+) this 
 
C++: mrpt::poses::CPose3D::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3D::clone() const --> class mrpt::rtti::CObject *
composeFrom(...)
composeFrom(self: mrpt.pymrpt.mrpt.poses.CPose3D, A: mrpt.pymrpt.mrpt.poses.CPose3D, B: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Makes "this = A (+) B"; this method is slightly more efficient than
 "this= A + B;" since it avoids the temporary object.
  
 
 A or B can be "this" without problems.
 
C++: mrpt::poses::CPose3D::composeFrom(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &) --> void
composePoint(...)
composePoint(*args, **kwargs)
Overloaded function.
 
1. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, local_point: mrpt::math::TPoint3D_<double>, global_point: mrpt::math::TPoint3D_<double>) -> None
 
An alternative, slightly more efficient way of doing 
 
 with G and L being 3D points and P this 6D pose.
 
 
 local_point is passed by value to allow global and local point to
 be the same variable
 
C++: mrpt::poses::CPose3D::composePoint(const struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint3D_<double> &) const --> void
 
2. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, l: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
C++: mrpt::poses::CPose3D::composePoint(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
 
3. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, local_point: mrpt::math::TPoint3D_<double>, global_point: mrpt::math::TPoint2D_<double>) -> None
 
This version of the method assumes that the resulting point has no Z
 component (use with caution!) 
 
C++: mrpt::poses::CPose3D::composePoint(const struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint2D_<double> &) const --> void
 
4. composePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, lx: float, ly: float, lz: float, gx: float, gy: float, gz: float) -> None
 
An alternative, slightly more efficient way of doing 
 
 with G and L being 3D points and P this 6D pose.  
 
C++: mrpt::poses::CPose3D::composePoint(double, double, double, float &, float &, float &) const --> void
distanceEuclidean6D(...)
distanceEuclidean6D(self: mrpt.pymrpt.mrpt.poses.CPose3D, o: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
The euclidean distance between two poses taken as two 6-length vectors
 (angles in radians). 
 
C++: mrpt::poses::CPose3D::distanceEuclidean6D(const class mrpt::poses::CPose3D &) const --> double
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPose3D, s: str) -> None
 
Set the current object value from a string generated by 'asString' (eg:
 "[x y z yaw pitch roll]", angles in deg. )
 
 
 asString
 
 
 std::exception On invalid format
 
C++: mrpt::poses::CPose3D::fromString(const std::string &) --> void
fromStringRaw(...)
fromStringRaw(self: mrpt.pymrpt.mrpt.poses.CPose3D, s: str) -> None
 
Same as fromString, but without requiring the square brackets in the
 string 
 
C++: mrpt::poses::CPose3D::fromStringRaw(const std::string &) --> void
getHomogeneousMatrix(...)
getHomogeneousMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3D, out_HM: mrpt::math::CMatrixFixed<double, 4ul, 4ul>) -> None
 
Returns the corresponding 4x4 homogeneous transformation matrix for the
 point(translation) or pose (translation+orientation).
 
 
 getInverseHomogeneousMatrix, getRotationMatrix
 
C++: mrpt::poses::CPose3D::getHomogeneousMatrix(class mrpt::math::CMatrixFixed<double, 4, 4> &) const --> void
getOppositeScalar(...)
getOppositeScalar(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Return the opposite of the current pose instance by taking the negative
 of all its components 
         
 
C++: mrpt::poses::CPose3D::getOppositeScalar() const --> class mrpt::poses::CPose3D
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPose3D::getPoseMean() --> class mrpt::poses::CPose3D &
getRotationMatrix(...)
getRotationMatrix(*args, **kwargs)
Overloaded function.
 
1. getRotationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3D, ROT: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
Get the 3x3 rotation matrix 
 getHomogeneousMatrix  
 
C++: mrpt::poses::CPose3D::getRotationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
2. getRotationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::poses::CPose3D::getRotationMatrix() const --> const class mrpt::math::CMatrixFixed<double, 3, 3> &
getYawPitchRoll(...)
getYawPitchRoll(self: mrpt.pymrpt.mrpt.poses.CPose3D, yaw: float, pitch: float, roll: float) -> None
 
Returns the three angles (yaw, pitch, roll), in radians, from the
 rotation matrix.
 
 
 setFromValues, yaw, pitch, roll
 
C++: mrpt::poses::CPose3D::getYawPitchRoll(double &, double &, double &) const --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Convert this pose into its inverse, saving the result in itself. 
 
 operator- 
 
C++: mrpt::poses::CPose3D::inverse() --> void
inverseComposeFrom(...)
inverseComposeFrom(self: mrpt.pymrpt.mrpt.poses.CPose3D, A: mrpt.pymrpt.mrpt.poses.CPose3D, B: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Makes 
 this method is slightly more efficient
 than "this= A - B;" since it avoids the temporary object.
  
 
 A or B can be "this" without problems.
 
 
 composeFrom, composePoint
 
C++: mrpt::poses::CPose3D::inverseComposeFrom(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &) --> void
inverseComposePoint(...)
inverseComposePoint(*args, **kwargs)
Overloaded function.
 
1. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, g: mrpt::math::TPoint3D_<double>, l: mrpt::math::TPoint3D_<double>) -> None
 
C++: mrpt::poses::CPose3D::inverseComposePoint(const struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint3D_<double> &) const --> void
 
2. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, g: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
C++: mrpt::poses::CPose3D::inverseComposePoint(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
 
3. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, g: mrpt::math::TPoint2D_<double>, l: mrpt::math::TPoint2D_<double>) -> None
 
4. inverseComposePoint(self: mrpt.pymrpt.mrpt.poses.CPose3D, g: mrpt::math::TPoint2D_<double>, l: mrpt::math::TPoint2D_<double>, eps: float) -> None
 
overload for 2D points 
 If the z component of the result is
 greater than some epsilon 
 
C++: mrpt::poses::CPose3D::inverseComposePoint(const struct mrpt::math::TPoint2D_<double> &, struct mrpt::math::TPoint2D_<double> &, const double) const --> void
inverseRotateVector(...)
inverseRotateVector(self: mrpt.pymrpt.mrpt.poses.CPose3D, global: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
Inverse of rotateVector(), i.e. using the inverse rotation matrix 
 
C++: mrpt::poses::CPose3D::inverseRotateVector(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
isHorizontal(...)
isHorizontal(*args, **kwargs)
Overloaded function.
 
1. isHorizontal(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> bool
 
2. isHorizontal(self: mrpt.pymrpt.mrpt.poses.CPose3D, tolerance: float) -> bool
 
Return true if the 6D pose represents a Z axis almost exactly vertical
 (upwards or downwards), with a given tolerance (if set to 0 exact
 horizontality is tested). 
 
C++: mrpt::poses::CPose3D::isHorizontal(const double) const --> bool
jacobian_pose_rodrigues_from_YPR(...)
jacobian_pose_rodrigues_from_YPR(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::poses::CPose3D::jacobian_pose_rodrigues_from_YPR() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
jacobian_rodrigues_from_YPR(...)
jacobian_rodrigues_from_YPR(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::poses::CPose3D::jacobian_rodrigues_from_YPR() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
normalizeAngles(...)
normalizeAngles(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Rebuild the internal matrix & update the yaw/pitch/roll angles within
 the ]-PI,PI] range (Must be called after using addComponents)
 
 
 addComponents
 
C++: mrpt::poses::CPose3D::normalizeAngles() --> void
pitch(...)
pitch(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Get the PITCH angle (in radians) 
 setFromValues 
 
C++: mrpt::poses::CPose3D::pitch() const --> double
roll(...)
roll(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Get the ROLL angle (in radians) 
 setFromValues 
 
C++: mrpt::poses::CPose3D::roll() const --> double
rotateVector(...)
rotateVector(self: mrpt.pymrpt.mrpt.poses.CPose3D, local: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
Rotates a vector (i.e. like composePoint(), but ignoring translation) 
 
C++: mrpt::poses::CPose3D::rotateVector(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
setFrom12Vector(...)
setFrom12Vector(self: mrpt.pymrpt.mrpt.poses.CPose3D, vec12: mrpt::math::CMatrixFixed<double, 12ul, 1ul>) -> None
 
C++: mrpt::poses::CPose3D::setFrom12Vector(const class mrpt::math::CMatrixFixed<double, 12, 1> &) --> void
setFromValues(...)
setFromValues(*args, **kwargs)
Overloaded function.
 
1. setFromValues(self: mrpt.pymrpt.mrpt.poses.CPose3D, x0: float, y0: float, z0: float) -> None
 
2. setFromValues(self: mrpt.pymrpt.mrpt.poses.CPose3D, x0: float, y0: float, z0: float, yaw: float) -> None
 
3. setFromValues(self: mrpt.pymrpt.mrpt.poses.CPose3D, x0: float, y0: float, z0: float, yaw: float, pitch: float) -> None
 
4. setFromValues(self: mrpt.pymrpt.mrpt.poses.CPose3D, x0: float, y0: float, z0: float, yaw: float, pitch: float, roll: float) -> None
 
Set the pose from a 3D position (meters) and yaw/pitch/roll angles
 (radians) - This method recomputes the internal rotation matrix.
 
 
 getYawPitchRoll, setYawPitchRoll
 
C++: mrpt::poses::CPose3D::setFromValues(const double, const double, const double, const double, const double, const double) --> void
setRotationMatrix(...)
setRotationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3D, ROT: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
Sets the 3x3 rotation matrix 
 getRotationMatrix, getHomogeneousMatrix
 
C++: mrpt::poses::CPose3D::setRotationMatrix(const class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::poses::CPose3D::setToNaN() --> void
setYawPitchRoll(...)
setYawPitchRoll(self: mrpt.pymrpt.mrpt.poses.CPose3D, yaw_: float, pitch_: float, roll_: float) -> None
 
Set the 3 angles of the 3D pose (in radians) - This method recomputes
 the internal rotation coordinates matrix.
 
 
 getYawPitchRoll, setFromValues
 
C++: mrpt::poses::CPose3D::setYawPitchRoll(const double, const double, const double) --> void
sphericalCoordinates(...)
sphericalCoordinates(self: mrpt.pymrpt.mrpt.poses.CPose3D, point: mrpt::math::TPoint3D_<double>, out_range: float, out_yaw: float, out_pitch: float) -> None
 
Computes the spherical coordinates of a 3D point as seen from the 6D
 pose specified by this object. For the coordinate system see the top of
 this page. 
 
C++: mrpt::poses::CPose3D::sphericalCoordinates(const struct mrpt::math::TPoint3D_<double> &, double &, double &, double &) const --> void
translation(...)
translation(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> mrpt::math::TPoint3D_<double>
 
Returns the (x,y,z) translational part of the SE(3) transformation. 
 
C++: mrpt::poses::CPose3D::translation() const --> struct mrpt::math::TPoint3D_<double>
yaw(...)
yaw(self: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Get the YAW angle (in radians)  
 setFromValues 
 
C++: mrpt::poses::CPose3D::yaw() const --> double

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3D::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
FromQuaternion(...) from builtins.PyCapsule
FromQuaternion(q: mrpt::math::CQuaternion<double>) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Builds a pose from a quaternion (and no translation).
 
 
 (New in MRPT 2.1.8)
 
C++: mrpt::poses::CPose3D::FromQuaternion(const class mrpt::math::CQuaternion<double> &) --> class mrpt::poses::CPose3D
FromQuaternionAndTranslation(...) from builtins.PyCapsule
FromQuaternionAndTranslation(q: mrpt::math::CQuaternion<double>, x: float, y: float, z: float) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Builds a pose from a quaternion and a (x,y,z) translation.
 
 
 (New in MRPT 2.1.8)
 
C++: mrpt::poses::CPose3D::FromQuaternionAndTranslation(const class mrpt::math::CQuaternion<double> &, double, double, double) --> class mrpt::poses::CPose3D
FromString(...) from builtins.PyCapsule
FromString(s: str) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPose3D::FromString(const std::string &) --> class mrpt::poses::CPose3D
FromTranslation(...) from builtins.PyCapsule
FromTranslation(*args, **kwargs)
Overloaded function.
 
1. FromTranslation(x: float, y: float, z: float) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Builds a pose with a translation without rotation 
 (New in
 MRPT 2.1.8)
 
C++: mrpt::poses::CPose3D::FromTranslation(double, double, double) --> class mrpt::poses::CPose3D
 
2. FromTranslation(t: mrpt::math::TPoint3D_<double>) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
         
 
C++: mrpt::poses::CPose3D::FromTranslation(const struct mrpt::math::TPoint3D_<double> &) --> class mrpt::poses::CPose3D
FromXYZYawPitchRoll(...) from builtins.PyCapsule
FromXYZYawPitchRoll(x: float, y: float, z: float, yaw: float, pitch: float, roll: float) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Builds a pose from a translation (x,y,z) in
 meters and (yaw,pitch,roll) angles in radians. 
 
 (New in MRPT 2.1.8)
 
C++: mrpt::poses::CPose3D::FromXYZYawPitchRoll(double, double, double, double, double, double) --> class mrpt::poses::CPose3D
FromYawPitchRoll(...) from builtins.PyCapsule
FromYawPitchRoll(yaw: float, pitch: float, roll: float) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Builds a pose with a null translation and (yaw,pitch,roll) angles in
 radians. 
 
 (New in MRPT 2.1.8)
 
C++: mrpt::poses::CPose3D::FromYawPitchRoll(double, double, double) --> class mrpt::poses::CPose3D
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3D::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
Identity(...) from builtins.PyCapsule
Identity() -> mrpt.pymrpt.mrpt.poses.CPose3D
 
Returns the identity transformation 
 
C++: mrpt::poses::CPose3D::Identity() --> class mrpt::poses::CPose3D
empty(...) from builtins.PyCapsule
empty() -> bool
 
C++: mrpt::poses::CPose3D::empty() --> bool
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3D::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3D::is_PDF() --> bool
max_size(...) from builtins.PyCapsule
max_size() -> int
 
C++: mrpt::poses::CPose3D::max_size() --> unsigned long
resize(...) from builtins.PyCapsule
resize(n: int) -> None
 
C++: mrpt::poses::CPose3D::resize(size_t) --> void
size(...) from builtins.PyCapsule
size() -> int
 
C++: mrpt::poses::CPose3D::size() --> unsigned long

Data descriptors defined here:
m_coords

Methods inherited from CPose_mrpt_poses_CPose3D_6UL_t:
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 6, 1>
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::derived() --> class mrpt::poses::CPose3D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
getHomogeneousMatrixVal(...)
getHomogeneousMatrixVal(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 4ul, 4ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::getHomogeneousMatrixVal() const --> class mrpt::math::CMatrixFixed<double, 4, 4>
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::norm() const --> double
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y_incr(const double) --> void

Static methods inherited from CPose_mrpt_poses_CPose3D_6UL_t:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::is3DPoseOrPoint() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DGridTemplate_double_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPose3DGridTemplate_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D, resolution_XYZ: float) -> None
 
doc
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D, resolution_XYZ: float, resolution_YPR: float) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, arg0: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, : mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t
 
C++: mrpt::poses::CPose3DGridTemplate<double>::operator=(const class mrpt::poses::CPose3DGridTemplate<double> &) --> class mrpt::poses::CPose3DGridTemplate<double> &
fill(...)
fill(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, val: float) -> None
 
C++: mrpt::poses::CPose3DGridTemplate<double>::fill(const double &) --> void
getByIndex(...)
getByIndex(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cx: int, cy: int, cz: int, cY: int, cP: int, cR: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByIndex(int, int, int, int, int, int) --> double *
getByPos(...)
getByPos(*args, **kwargs)
Overloaded function.
 
1. getByPos(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, x: float, y: float, z: float, yaw: float, pitch: float, roll: float) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByPos(double, double, double, double, double, double) --> double *
 
2. getByPos(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, p: mrpt.pymrpt.mrpt.math.TPose3D) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByPos(const struct mrpt::math::TPose3D &) --> double *
getMaxBoundingBox(...)
getMaxBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getMaxBoundingBox() const --> struct mrpt::math::TPose3D
getMinBoundingBox(...)
getMinBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getMinBoundingBox() const --> struct mrpt::math::TPose3D
getResolutionAngles(...)
getResolutionAngles(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getResolutionAngles() const --> double
getResolutionXYZ(...)
getResolutionXYZ(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getResolutionXYZ() const --> double
getSizePitch(...)
getSizePitch(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizePitch() const --> uint32_t
getSizeRoll(...)
getSizeRoll(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeRoll() const --> uint32_t
getSizeX(...)
getSizeX(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeX() const --> uint32_t
getSizeY(...)
getSizeY(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeY() const --> uint32_t
getSizeYaw(...)
getSizeYaw(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeYaw() const --> uint32_t
getSizeZ(...)
getSizeZ(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeZ() const --> uint32_t
getTotalVoxelCount(...)
getTotalVoxelCount(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getTotalVoxelCount() const --> uint32_t
idx2pitch(...)
idx2pitch(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cP: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2pitch(uint32_t) const --> double
idx2roll(...)
idx2roll(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cR: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2roll(uint32_t) const --> double
idx2x(...)
idx2x(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cx: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2x(uint32_t) const --> double
idx2y(...)
idx2y(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cy: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2y(uint32_t) const --> double
idx2yaw(...)
idx2yaw(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cY: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2yaw(uint32_t) const --> double
idx2z(...)
idx2z(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cz: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2z(uint32_t) const --> double
pitch2idx(...)
pitch2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, pitch: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::pitch2idx(double) const --> int
roll2idx(...)
roll2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, roll: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::roll2idx(double) const --> int
setSize(...)
setSize(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D, resolution_XYZ: float, resolution_YPR: float) -> None
 
C++: mrpt::poses::CPose3DGridTemplate<double>::setSize(const struct mrpt::math::TPose3D &, const struct mrpt::math::TPose3D &, double, double) --> void
x2idx(...)
x2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, x: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::x2idx(double) const --> int
y2idx(...)
y2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, y: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::y2idx(double) const --> int
yaw2idx(...)
yaw2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, yaw: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::yaw2idx(double) const --> int
z2idx(...)
z2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, z: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::z2idx(double) const --> int

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DInterpolator(mrpt.pymrpt.mrpt.serialization.CSerializable, CPoseInterpolatorBase_3_t)
    This class stores a time-stamped trajectory in SE(3) (CPose3D poses).
 It can also interpolate SE(3) poses over time using linear, splines or
SLERP interpolation, as set in CPose3DInterpolator::setInterpolationMethod()
 Usage:
  - Insert new poses into the sequence with CPose3DInterpolator::insert()
  - Query an exact/interpolated pose with
CPose3DInterpolator::interpolate().
Example:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 Time is represented with mrpt::Clock::time_point. See mrpt::system for
methods and utilities to manage these time references.
 
 See TInterpolatorMethod for the list of interpolation methods. The default
method at constructor is "imLinearSlerp".
 
 
CPoseOrPoint
 
 
Method resolution order:
CPose3DInterpolator
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
CPoseInterpolatorBase_3_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DInterpolator::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator, arg0: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator, arg0: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator, : mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> mrpt.pymrpt.mrpt.poses.CPose3DInterpolator
 
C++: mrpt::poses::CPose3DInterpolator::operator=(const class mrpt::poses::CPose3DInterpolator &) --> class mrpt::poses::CPose3DInterpolator &
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DInterpolator) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DInterpolator::clone() const --> class mrpt::rtti::CObject *

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DInterpolator::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DInterpolator::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from CPoseInterpolatorBase_3_t:
at(...)
at(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::at(const mrpt::Clock::time_point &) --> struct mrpt::math::TPose3D &
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::clear() --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::empty() const --> bool
filter(...)
filter(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, component: int, samples: int) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::filter(unsigned int, unsigned int) --> void
getBoundingBox(...)
getBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, minCorner: mrpt::math::TPoint3D_<double>, maxCorner: mrpt::math::TPoint3D_<double>) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getBoundingBox(struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint3D_<double> &) const --> void
getInterpolationMethod(...)
getInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> mrpt.pymrpt.mrpt.poses.TInterpolatorMethod
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getInterpolationMethod() const --> enum mrpt::poses::TInterpolatorMethod
getMaxTimeInterpolation(...)
getMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getMaxTimeInterpolation() --> struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>>
getPreviousPoseWithMinDistance(...)
getPreviousPoseWithMinDistance(*args, **kwargs)
Overloaded function.
 
1. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.math.TPose3D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, struct mrpt::math::TPose3D &) --> bool
 
2. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, class mrpt::poses::CPose3D &) --> bool
insert(...)
insert(*args, **kwargs)
Overloaded function.
 
1. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::insert(const mrpt::Clock::time_point &, const struct mrpt::math::TPose3D &) --> void
 
2. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::insert(const mrpt::Clock::time_point &, const class mrpt::poses::CPose3D &) --> void
interpolate(...)
interpolate(*args, **kwargs)
Overloaded function.
 
1. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.math.TPose3D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::interpolate(const mrpt::Clock::time_point &, struct mrpt::math::TPose3D &, bool &) const --> struct mrpt::math::TPose3D &
 
2. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.poses.CPose3D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::interpolate(const mrpt::Clock::time_point &, class mrpt::poses::CPose3D &, bool &) const --> class mrpt::poses::CPose3D &
loadFromTextFile(...)
loadFromTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::loadFromTextFile(const std::string &) --> bool
saveInterpolatedToTextFile(...)
saveInterpolatedToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str, period: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::saveInterpolatedToTextFile(const std::string &, const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::saveToTextFile(const std::string &) const --> bool
setInterpolationMethod(...)
setInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, method: mrpt.pymrpt.mrpt.poses.TInterpolatorMethod) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::setInterpolationMethod(enum mrpt::poses::TInterpolatorMethod) --> void
setMaxTimeInterpolation(...)
setMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, time: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::setMaxTimeInterpolation(const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> int
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::size() const --> size_t

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t)
    A Probability Density Function (PDF) of a SE(3) pose.
This class is just the base class for unifying many diferent
   ways this PDF can be implemented.
 
 For convenience, a pose composition is also defined for any
   PDF derived class, changeCoordinatesReference, in the form of a method
rather than an operator.
 
 For a similar class for 3D points (without attitude), see CPointPDF
 
 See also:
 [probabilistic spatial representations](tutorial-pdf-over-poses.html)
 
 
CPose3DCPosePDFCPointPDF
 
 
Method resolution order:
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDF::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, : mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
C++: mrpt::poses::CPose3DPDF::operator=(const class mrpt::poses::CPose3DPDF &) --> class mrpt::poses::CPose3DPDF &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Bayesian fusion of two pose distributions, then save the result in this
 object (WARNING: Currently only distributions of the same class can be
 fused! eg, gaussian with gaussian,etc) 
 
C++: mrpt::poses::CPose3DPDF::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DPDF::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
 
 createFrom2D
 
C++: mrpt::poses::CPose3DPDF::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDF, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DPDF::inverse(class mrpt::poses::CPose3DPDF &) const --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDF::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
clone(...)
clone(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Returns a deep copy (clone) of the object, indepently of its class. 
 
C++: mrpt::rtti::CObject::clone() const --> class mrpt::rtti::CObject *
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, outPart: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceAndMean(...)
getCovarianceAndMean(*args, **kwargs)
Overloaded function.
 
1. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> Tuple[mrpt::math::CMatrixFixed<double, 6ul, 6ul>, mrpt::poses::CPose3D]
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
 
2. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, c: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, mean: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceAndMean(class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, inf: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMean(class mrpt::poses::CPose3D &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, file: str) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::saveToTextFile(const std::string &) const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDFGaussian(CPose3DPDF, mrpt.pymrpt.mrpt.Stringifyable)
    Declares a class that represents a Probability Density function (PDF) of a
 3D pose 
 
.
 
   This class implements that PDF using a mono-modal Gaussian distribution.
 See mrpt::poses::CPose3DPDF for more details.
 
  Uncertainty of pose composition operations (
) is
 implemented in the method "CPose3DPDFGaussian::operator+=".
 
  For further details on implemented methods and the theory behind them,
  see 
* href="http://www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty"
 >this report.
 
 
 CPose3DCPose3DPDFCPose3DPDFParticles
 
 
Method resolution order:
CPose3DPDFGaussian
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGaussian::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated).
 
C++: mrpt::poses::CPose3DPDFGaussian::operator+=(const class mrpt::poses::CPose3D &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated).
 
C++: mrpt::poses::CPose3DPDFGaussian::operator+=(const class mrpt::poses::CPose3DPDFGaussian &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, constructor_dummy_param: mrpt.pymrpt.mrpt.poses.TConstructorFlags_Poses) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3D, init_Cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt::poses::CPosePDFGaussian) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt::poses::CPose3DQuatPDFGaussian) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated).
 
C++: mrpt::poses::CPose3DPDFGaussian::operator-=(const class mrpt::poses::CPose3DPDFGaussian &) --> void
__neg__(...)
__neg__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian
 
Unary - operator, returns the PDF of the inverse pose.  
 
C++: mrpt::poses::CPose3DPDFGaussian::operator-() const --> class mrpt::poses::CPose3DPDFGaussian
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> str
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> str
 
C++: mrpt::poses::CPose3DPDFGaussian::asString() const --> std::string
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, : mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian
 
C++: mrpt::poses::CPose3DPDFGaussian::operator=(const class mrpt::poses::CPose3DPDFGaussian &) --> class mrpt::poses::CPose3DPDFGaussian &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPose3DPDFGaussian::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object.
 
C++: mrpt::poses::CPose3DPDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGaussian::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(*args, **kwargs)
Overloaded function.
 
1. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
C++: mrpt::poses::CPose3DPDFGaussian::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
 
2. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
C++: mrpt::poses::CPose3DPDFGaussian::copyFrom(const class mrpt::poses::CPosePDF &) --> void
 
3. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt::poses::CPose3DQuatPDFGaussian) -> None
 
Copy from a 6D pose PDF described as a Quaternion
 
C++: mrpt::poses::CPose3DPDFGaussian::copyFrom(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, outPart: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Draws a single sample from the distribution
 
C++: mrpt::poses::CPose3DPDFGaussian::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1].
 
C++: mrpt::poses::CPose3DPDFGaussian::evaluateNormalizedPDF(const class mrpt::poses::CPose3D &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluates the PDF at a given point.
 
C++: mrpt::poses::CPose3DPDFGaussian::evaluatePDF(const class mrpt::poses::CPose3D &) const --> double
getCovSubmatrix2D(...)
getCovSubmatrix2D(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, out_cov: mrpt::math::CMatrixDynamic<double>) -> None
 
Returns a 3x3 matrix with submatrix of the covariance for the variables
 (x,y,yaw) only.
 
C++: mrpt::poses::CPose3DPDFGaussian::getCovSubmatrix2D(class mrpt::math::CMatrixDynamic<double> &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> Tuple[mrpt::math::CMatrixFixed<double, 6ul, 6ul>, mrpt.pymrpt.mrpt.poses.CPose3D]
 
Returns an estimate of the pose covariance matrix (6x6 cov matrix) and
 the mean, both at once.
 
 
 getMean
 
C++: mrpt::poses::CPose3DPDFGaussian::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Returns an estimate of the pose, (the mean, or mathematical expectation
 of the PDF).
 
 
 getCovariance
 
C++: mrpt::poses::CPose3DPDFGaussian::getMean(class mrpt::poses::CPose3D &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPose3DPDFGaussian::getPoseMean() --> class mrpt::poses::CPose3D &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF
 
C++: mrpt::poses::CPose3DPDFGaussian::inverse(class mrpt::poses::CPose3DPDF &) const --> void
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, theOther: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> float
 
Computes the Mahalanobis distance between the centers of two Gaussians.
  The variables with a variance exactly equal to 0 are not taken into
 account in the process, but
   "infinity" is returned if the corresponding elements are not exactly
 equal.
 
C++: mrpt::poses::CPose3DPDFGaussian::mahalanobisDistanceTo(const class mrpt::poses::CPose3DPDFGaussian &) --> double
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian, file: str) -> bool
 
Save the PDF to a text file, containing the 3D pose in the first line,
 then the covariance matrix in next 3 lines.
 
C++: mrpt::poses::CPose3DPDFGaussian::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGaussian::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGaussian::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov
mean

Static methods inherited from CPose3DPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, inf: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDFGaussianInf(CPose3DPDF)
    Declares a class that represents a Probability Density function (PDF) of a
 3D pose 
 
 as a
 Gaussian described by its mean and its inverse covariance matrix.
 
   This class implements that PDF using a mono-modal Gaussian distribution in
 "information" form (inverse covariance matrix).
 
  Uncertainty of pose composition operations (
) is
 implemented in the method "CPose3DPDFGaussianInf::operator+=".
 
  For further details on implemented methods and the theory behind them,
  see 
* href="http://www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty"
 >this report.
 
 
 CPose3DCPose3DPDFCPose3DPDFParticlesCPose3DPDFGaussian
 
 
Method resolution order:
CPose3DPDFGaussianInf
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGaussianInf::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::operator+=(const class mrpt::poses::CPose3D &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::operator+=(const class mrpt::poses::CPose3DPDFGaussianInf &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, constructor_dummy_param: mrpt.pymrpt.mrpt.poses.TConstructorFlags_Poses) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3D, init_CovInv: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_6UL_6UL_t) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, o: mrpt::poses::CPose3DQuatPDFGaussian) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated) 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::operator-=(const class mrpt::poses::CPose3DPDFGaussianInf &) --> void
__neg__(...)
__neg__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf
 
Unary - operator, returns the PDF of the inverse pose.  
 
C++: mrpt::poses::CPose3DPDFGaussianInf::operator-() const --> class mrpt::poses::CPose3DPDFGaussianInf
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> str
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, : mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf
 
C++: mrpt::poses::CPose3DPDFGaussianInf::operator=(const class mrpt::poses::CPose3DPDFGaussianInf &) --> class mrpt::poses::CPose3DPDFGaussianInf &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPose3DPDFGaussianInf::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGaussianInf::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(*args, **kwargs)
Overloaded function.
 
1. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
 
2. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::copyFrom(const class mrpt::poses::CPosePDF &) --> void
 
3. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, o: mrpt::poses::CPose3DQuatPDFGaussian) -> None
 
Copy from a 6D pose PDF described as a Quaternion
 
C++: mrpt::poses::CPose3DPDFGaussianInf::copyFrom(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, outPart: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Draws a single sample from the distribution 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1] 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::evaluateNormalizedPDF(const class mrpt::poses::CPose3D &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluates the PDF at a given point 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::evaluatePDF(const class mrpt::poses::CPose3D &) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_6UL_6UL_t, mrpt.pymrpt.mrpt.poses.CPose3D]
 
C++: mrpt::poses::CPose3DPDFGaussianInf::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, inf: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_6UL_6UL_t) -> None
 
Returns the information (inverse covariance) matrix (a STATE_LEN x
 STATE_LEN matrix) 
 
 getMean, getCovarianceAndMean 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getInvCovSubmatrix2D(...)
getInvCovSubmatrix2D(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, out_cov: mrpt.pymrpt.mrpt.math.CMatrixDynamic_double_t) -> None
 
Returns a 3x3 matrix with submatrix of the inverse covariance for the
 variables (x,y,yaw) only 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::getInvCovSubmatrix2D(class mrpt::math::CMatrixDynamic<double> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DPDFGaussianInf::getMean(class mrpt::poses::CPose3D &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPose3DPDFGaussianInf::getPoseMean() --> class mrpt::poses::CPose3D &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::inverse(class mrpt::poses::CPose3DPDF &) const --> void
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> bool
 
C++: mrpt::poses::CPose3DPDFGaussianInf::isInfType() const --> bool
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, theOther: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf) -> float
 
Computes the Mahalanobis distance between the centers of two Gaussians.
  The variables with a variance exactly equal to 0 are not taken into
 account in the process, but
   "infinity" is returned if the corresponding elements are not exactly
 equal.
 
C++: mrpt::poses::CPose3DPDFGaussianInf::mahalanobisDistanceTo(const class mrpt::poses::CPose3DPDFGaussianInf &) --> double
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussianInf, file: str) -> bool
 
Save the PDF to a text file, containing the 3D pose in the first line,
 then the covariance matrix in next 3 lines. 
 
C++: mrpt::poses::CPose3DPDFGaussianInf::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGaussianInf::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGaussianInf::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov_inv
mean

Static methods inherited from CPose3DPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDFGrid(CPose3DPDF, CPose3DGridTemplate_double_t)
    Declares a class that represents a Probability Distribution
 function (PDF) of a SE(3) pose (x,y,z, yaw, pitch, roll), in
the form of a 6-dimensional grid of "voxels".
 
 
CPose3DCPose3DPDF, CPose3DGridTemplate
 
 
Method resolution order:
CPose3DPDFGrid
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
CPose3DGridTemplate_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGrid::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, arg0: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, arg0: mrpt.pymrpt.mrpt.math.TPose3D, arg1: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, arg0: mrpt.pymrpt.mrpt.math.TPose3D, arg1: mrpt.pymrpt.mrpt.math.TPose3D, arg2: float) -> None
 
doc
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D, resolution_XYZ: float, resolution_YPR: float) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, : mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid
 
C++: mrpt::poses::CPose3DPDFGrid::operator=(const class mrpt::poses::CPose3DPDFGrid &) --> class mrpt::poses::CPose3DPDFGrid &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
C++: mrpt::poses::CPose3DPDFGrid::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DPDFGrid::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGrid::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between
 particles and gaussian representations) 
 
C++: mrpt::poses::CPose3DPDFGrid::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, outPart: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Draws a single sample from the distribution.
 
 
 Precondition: voxel weights are assumed to be normalized. 
 
C++: mrpt::poses::CPose3DPDFGrid::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_6UL_6UL_t, mrpt.pymrpt.mrpt.poses.CPose3D]
 
C++: mrpt::poses::CPose3DPDFGrid::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DPDFGrid::getMean(class mrpt::poses::CPose3D &) const --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
C++: mrpt::poses::CPose3DPDFGrid::inverse(class mrpt::poses::CPose3DPDF &) const --> void
normalize(...)
normalize(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> None
 
Normalizes the PDF, such as all voxels sum the unity. 
 
C++: mrpt::poses::CPose3DPDFGrid::normalize() --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid, dataFile: str) -> bool
 
Save the contents of the 3D grid in one file, as a concatenation of
 (X,Y) slices. The size in X,Y,and the values for Z,yaw, pitch, roll, PHI
 are stored in another file named `<filename>_dims.txt`
 
 
 false on error 
 
C++: mrpt::poses::CPose3DPDFGrid::saveToTextFile(const std::string &) const --> bool
uniformDistribution(...)
uniformDistribution(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFGrid) -> None
 
Assigns the same value to all the cells in the grid, so the sum 1 
 
C++: mrpt::poses::CPose3DPDFGrid::uniformDistribution() --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFGrid::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFGrid::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Static methods inherited from CPose3DPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, inf: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::isInfType() const --> bool

Methods inherited from CPose3DGridTemplate_double_t:
fill(...)
fill(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, val: float) -> None
 
C++: mrpt::poses::CPose3DGridTemplate<double>::fill(const double &) --> void
getByIndex(...)
getByIndex(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cx: int, cy: int, cz: int, cY: int, cP: int, cR: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByIndex(int, int, int, int, int, int) --> double *
getByPos(...)
getByPos(*args, **kwargs)
Overloaded function.
 
1. getByPos(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, x: float, y: float, z: float, yaw: float, pitch: float, roll: float) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByPos(double, double, double, double, double, double) --> double *
 
2. getByPos(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, p: mrpt.pymrpt.mrpt.math.TPose3D) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getByPos(const struct mrpt::math::TPose3D &) --> double *
getMaxBoundingBox(...)
getMaxBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getMaxBoundingBox() const --> struct mrpt::math::TPose3D
getMinBoundingBox(...)
getMinBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getMinBoundingBox() const --> struct mrpt::math::TPose3D
getResolutionAngles(...)
getResolutionAngles(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getResolutionAngles() const --> double
getResolutionXYZ(...)
getResolutionXYZ(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getResolutionXYZ() const --> double
getSizePitch(...)
getSizePitch(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizePitch() const --> uint32_t
getSizeRoll(...)
getSizeRoll(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeRoll() const --> uint32_t
getSizeX(...)
getSizeX(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeX() const --> uint32_t
getSizeY(...)
getSizeY(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeY() const --> uint32_t
getSizeYaw(...)
getSizeYaw(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeYaw() const --> uint32_t
getSizeZ(...)
getSizeZ(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getSizeZ() const --> uint32_t
getTotalVoxelCount(...)
getTotalVoxelCount(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::getTotalVoxelCount() const --> uint32_t
idx2pitch(...)
idx2pitch(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cP: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2pitch(uint32_t) const --> double
idx2roll(...)
idx2roll(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cR: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2roll(uint32_t) const --> double
idx2x(...)
idx2x(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cx: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2x(uint32_t) const --> double
idx2y(...)
idx2y(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cy: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2y(uint32_t) const --> double
idx2yaw(...)
idx2yaw(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cY: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2yaw(uint32_t) const --> double
idx2z(...)
idx2z(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, cz: int) -> float
 
C++: mrpt::poses::CPose3DGridTemplate<double>::idx2z(uint32_t) const --> double
pitch2idx(...)
pitch2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, pitch: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::pitch2idx(double) const --> int
roll2idx(...)
roll2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, roll: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::roll2idx(double) const --> int
setSize(...)
setSize(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, bb_min: mrpt.pymrpt.mrpt.math.TPose3D, bb_max: mrpt.pymrpt.mrpt.math.TPose3D, resolution_XYZ: float, resolution_YPR: float) -> None
 
C++: mrpt::poses::CPose3DGridTemplate<double>::setSize(const struct mrpt::math::TPose3D &, const struct mrpt::math::TPose3D &, double, double) --> void
x2idx(...)
x2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, x: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::x2idx(double) const --> int
y2idx(...)
y2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, y: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::y2idx(double) const --> int
yaw2idx(...)
yaw2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, yaw: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::yaw2idx(double) const --> int
z2idx(...)
z2idx(self: mrpt.pymrpt.mrpt.poses.CPose3DGridTemplate_double_t, z: float) -> int
 
C++: mrpt::poses::CPose3DGridTemplate<double>::z2idx(double) const --> int

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDFParticles(CPose3DPDF, mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, mrpt.pymrpt.mrpt.Stringifyable)
    Declares a class that represents a Probability Density function (PDF) of a
3D pose
 
 This class is also the base for the implementation of Monte-Carlo
Localization (MCL), in mrpt::slam::CMonteCarloLocalization2D.
 
 See the application "app/pf-localization" for an example of usage.
 
 
CPose3DCPose3DPDF, CPoseGaussianPDF
 
 
Method resolution order:
CPose3DPDFParticles
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t
mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFParticles::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, Ap: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Appends (pose-composition) a given pose "p" to each particle 
 
C++: mrpt::poses::CPose3DPDFParticles::operator+=(const class mrpt::poses::CPose3D &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, M: int) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> None
append(...)
append(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, o: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> None
 
Appends (add to the list) a set of m_particles to the existing ones, and
 then normalize weights. 
 
C++: mrpt::poses::CPose3DPDFParticles::append(class mrpt::poses::CPose3DPDFParticles &) --> void
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> str
 
C++: mrpt::poses::CPose3DPDFParticles::asString() const --> std::string
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, : mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles
 
C++: mrpt::poses::CPose3DPDFParticles::operator=(const class mrpt::poses::CPose3DPDFParticles &) --> class mrpt::poses::CPose3DPDFParticles &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Bayesian fusion 
 
C++: mrpt::poses::CPose3DPDFParticles::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DPDFParticles::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFParticles::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between m_particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DPDFParticles::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, outPart: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Draws a single sample from the distribution (WARNING: weights are
 assumed to be normalized!) 
 
C++: mrpt::poses::CPose3DPDFParticles::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> Tuple[mrpt::math::CMatrixFixed<double, 6ul, 6ul>, mrpt.pymrpt.mrpt.poses.CPose3D]
 
Returns an estimate of the pose covariance matrix (6x6 cov matrix) and
 the mean, both at once. 
 
 getMean 
 
C++: mrpt::poses::CPose3DPDFParticles::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Returns an estimate of the pose, (the mean, or mathematical expectation
 of the PDF), computed as a weighted average over all m_particles. 
 
 
 getCovariance 
 
C++: mrpt::poses::CPose3DPDFParticles::getMean(class mrpt::poses::CPose3D &) const --> void
getMostLikelyParticle(...)
getMostLikelyParticle(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> mrpt.pymrpt.mrpt.math.TPose3D
 
Returns the particle with the highest weight. 
 
C++: mrpt::poses::CPose3DPDFParticles::getMostLikelyParticle() const --> struct mrpt::math::TPose3D
getParticlePose(...)
getParticlePose(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, i: int) -> mrpt.pymrpt.mrpt.math.TPose3D
 
Returns the pose of the i'th particle 
 
C++: mrpt::poses::CPose3DPDFParticles::getParticlePose(int) const --> struct mrpt::math::TPose3D
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DPDFParticles::inverse(class mrpt::poses::CPose3DPDF &) const --> void
resetDeterministic(...)
resetDeterministic(*args, **kwargs)
Overloaded function.
 
1. resetDeterministic(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, location: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
2. resetDeterministic(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, location: mrpt.pymrpt.mrpt.math.TPose3D, particlesCount: int) -> None
 
Reset the PDF to a single point: All m_particles will be set exactly to
 the supplied pose.
 
 
 The location to set all the m_particles.
 
 
 If this is set to 0 the number of m_particles
 remains unchanged.
  
 
 resetUniform 
 
C++: mrpt::poses::CPose3DPDFParticles::resetDeterministic(const struct mrpt::math::TPose3D &, size_t) --> void
resetUniform(...)
resetUniform(*args, **kwargs)
Overloaded function.
 
1. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, corner_min: mrpt.pymrpt.mrpt.math.TPose3D, corner_max: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
2. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, corner_min: mrpt.pymrpt.mrpt.math.TPose3D, corner_max: mrpt.pymrpt.mrpt.math.TPose3D, particlesCount: int) -> None
 
Reset the PDF to an uniformly distributed one, inside of the defined
 "cube".
 
 
 New particle count, or leave count unchanged if set
 to -1 (default).
 
 
 Orientations can be outside of the [-pi,pi] range if so desired,
       but it must hold `phi_max>=phi_min`.
 
 
 resetDeterministic
 resetAroundSetOfPoses
 
C++: mrpt::poses::CPose3DPDFParticles::resetUniform(const struct mrpt::math::TPose3D &, const struct mrpt::math::TPose3D &, const int) --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, file: str) -> bool
 
Save PDF's m_particles to a text file. In each line it will go: "x y z"
 
C++: mrpt::poses::CPose3DPDFParticles::saveToTextFile(const std::string &) const --> bool
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles) -> int
 
Get the m_particles count (equivalent to "particlesCount") 
 
C++: mrpt::poses::CPose3DPDFParticles::size() const --> size_t

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFParticles::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFParticles::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Static methods inherited from CPose3DPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, inf: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::isInfType() const --> bool

Methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t:
clearParticles(...)
clearParticles(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> None
 
C++: mrpt::bayes::CParticleFilterData<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>::clearParticles() --> void

Data descriptors inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterData_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t:
m_particles

Methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t:
ESS(...)
ESS(*args, **kwargs)
Overloaded function.
 
1. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::ESS() const --> double
 
2. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> float
 
Returns the normalized ESS (Estimated Sample Size), in the range [0,1].
  Note that you do NOT need to normalize the weights before calling this.
 
C++: mrpt::bayes::CParticleFilterCapable::ESS() const --> double
derived(...)
derived(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> mrpt::poses::CPose3DPDFParticles
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::derived() --> class mrpt::poses::CPose3DPDFParticles &
fastDrawSample(...)
fastDrawSample(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> int
 
Draws a random sample from the particle filter, in such a way that each
particle has a probability proportional to its weight (in the standard PF
algorithm).
   This method can be used to generate a variable number of m_particles
when resampling: to vary the number of m_particles in the filter.
   See prepareFastDrawSample for more information, or the 
*href="http://www.mrpt.org/Particle_Filters" >Particle Filter
tutorial.
 
 NOTES:
                - You MUST call "prepareFastDrawSample" ONCE before calling this
method. That method must be called after modifying the particle filter
(executing one step, resampling, etc...)
                - This method returns ONE index for the selected ("drawn") particle,
in
the range [0,M-1]
                - You do not need to call "normalizeWeights" before calling this.
 
 
 prepareFastDrawSample
 
C++: mrpt::bayes::CParticleFilterCapable::fastDrawSample(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) const --> size_t
getW(...)
getW(*args, **kwargs)
Overloaded function.
 
1. getW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::getW(size_t) const --> double
 
2. getW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int) -> float
 
Access to i'th particle (logarithm) weight, where first one is index 0.
 
C++: mrpt::bayes::CParticleFilterCapable::getW(size_t) const --> double
normalizeWeights(...)
normalizeWeights(*args, **kwargs)
Overloaded function.
 
1. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> float
 
2. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, out_max_log_w: float) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::normalizeWeights(double *) --> double
 
3. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable) -> float
 
4. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, out_max_log_w: float) -> float
 
Normalize the (logarithmic) weights, such as the maximum weight is zero.
 
 
 If provided, will return with the maximum log_w
 before normalizing, such as new_weights = old_weights - max_log_w.
 
 
 The max/min ratio of weights ("dynamic range")
 
C++: mrpt::bayes::CParticleFilterCapable::normalizeWeights(double *) --> double
particlesCount(...)
particlesCount(*args, **kwargs)
Overloaded function.
 
1. particlesCount(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> int
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::particlesCount() const --> size_t
 
2. particlesCount(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> int
 
Get the m_particles count.
 
C++: mrpt::bayes::CParticleFilterCapable::particlesCount() const --> size_t
performResampling(...)
performResampling(*args, **kwargs)
Overloaded function.
 
1. performResampling(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
2. performResampling(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, out_particle_count: int) -> None
 
Performs a resample of the m_particles, using the method selected in the
 constructor.
 After computing the surviving samples, this method internally calls
 "performSubstitution" to actually perform the particle replacement.
 This method is called automatically by CParticleFilter::execute,
 andshould not be invoked manually normally.
 To just obtaining the sequence of resampled indexes from a sequence of
 weights, use "resample"
 
 
 The desired number of output particles
 after resampling; 0 means don't modify the current number.
 
 
 resample
 
C++: mrpt::bayes::CParticleFilterCapable::performResampling(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t) --> void
prediction_and_update(...)
prediction_and_update(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Performs the prediction stage of the Particle Filter.
  This method simply selects the appropiate protected method according to
 the particle filter algorithm to run.
 
 
 
 prediction_and_update_pfStandardProposal,prediction_and_update_pfAuxiliaryPFStandard,prediction_and_update_pfOptimalProposal,prediction_and_update_pfAuxiliaryPFOptimal
 
C++: mrpt::bayes::CParticleFilterCapable::prediction_and_update(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
setW(...)
setW(*args, **kwargs)
Overloaded function.
 
1. setW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int, w: float) -> None
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPose3DPDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE>>>::setW(size_t, double) --> void
 
2. setW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int, w: float) -> None
 
Modifies i'th particle (logarithm) weight, where first one is index 0.
 
C++: mrpt::bayes::CParticleFilterCapable::setW(size_t, double) --> void

Static methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPose3DPDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose3D_mrpt_bayes_particle_storage_mode_VALUE_t:
defaultEvaluator(...) from builtins.PyCapsule
defaultEvaluator(PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, obj: mrpt.pymrpt.mrpt.bayes.CParticleFilterCapable, index: int, action: capsule, observation: capsule) -> float
 
The default evaluator function, which simply returns the particle
 weight.
  The action and the observation are declared as "void*" for a greater
 flexibility.
 
 
 prepareFastDrawSample
 
C++: mrpt::bayes::CParticleFilterCapable::defaultEvaluator(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, const class mrpt::bayes::CParticleFilterCapable *, size_t, const void *, const void *) --> double

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DPDFSOG(CPose3DPDF)
    Declares a class that represents a Probability Density function (PDF) of a
 3D(6D) pose 
 
.
   This class implements that PDF as the following multi-modal Gaussian
 distribution:
 
 
 
 
  Where the number of modes N is the size of CPose3DPDFSOG::m_modes. Angles
 are always in radians.
 
  See mrpt::poses::CPose3DPDF for more details.
 
 
 
 
 CPose3DPDF
 
 
Method resolution order:
CPose3DPDFSOG
CPose3DPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFSOG::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, nModes: int) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, arg0: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
appendFrom(...)
appendFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, o: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
 
Append the Gaussian modes from "o" to the current set of modes of "this"
 density 
 
C++: mrpt::poses::CPose3DPDFSOG::appendFrom(const class mrpt::poses::CPose3DPDFSOG &) --> void
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, : mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG
 
C++: mrpt::poses::CPose3DPDFSOG::operator=(const class mrpt::poses::CPose3DPDFSOG &) --> class mrpt::poses::CPose3DPDFSOG &
bayesianFusion(...)
bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, p1: mrpt.pymrpt.mrpt.poses.CPose3DPDF, p2: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Bayesian fusion of two pose distributions, then save the result in this
 object (WARNING: Currently p1 must be a mrpt::poses::CPose3DPDFSOG object
 and p2 a mrpt::poses::CPose3DPDFSOG object) 
 
C++: mrpt::poses::CPose3DPDFSOG::bayesianFusion(const class mrpt::poses::CPose3DPDF &, const class mrpt::poses::CPose3DPDF &) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DPDFSOG::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
 
Clear all the gaussian modes 
 
C++: mrpt::poses::CPose3DPDFSOG::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFSOG::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DPDFSOG::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, outPart: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Draws a single sample from the distribution 
 
C++: mrpt::poses::CPose3DPDFSOG::drawSingleSample(class mrpt::poses::CPose3D &) const --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> bool
 
Return whether there is any Gaussian mode. 
 
C++: mrpt::poses::CPose3DPDFSOG::empty() const --> bool
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_6UL_6UL_t, mrpt.pymrpt.mrpt.poses.CPose3D]
 
C++: mrpt::poses::CPose3DPDFSOG::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 6, 6>, class mrpt::poses::CPose3D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DPDFSOG::getMean(class mrpt::poses::CPose3D &) const --> void
getMostLikelyMode(...)
getMostLikelyMode(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, outVal: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
Return the Gaussian mode with the highest likelihood (or an empty
 Gaussian if there are no modes in this SOG) 
 
C++: mrpt::poses::CPose3DPDFSOG::getMostLikelyMode(class mrpt::poses::CPose3DPDFGaussian &) const --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DPDFSOG::inverse(class mrpt::poses::CPose3DPDF &) const --> void
normalizeWeights(...)
normalizeWeights(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> None
 
Normalize the weights in m_modes such as the maximum log-weight is 0. 
 
C++: mrpt::poses::CPose3DPDFSOG::normalizeWeights() --> void
resize(...)
resize(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, N: int) -> None
 
Set the number of SOG modes 
 
C++: mrpt::poses::CPose3DPDFSOG::resize(size_t) --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG, file: str) -> bool
 
Save the density to a text file, with the following format:
  There is one row per Gaussian "mode", and each row contains 10
 elements:
   - w (The linear weight)
   - x_mean (gaussian mean value)
   - y_mean (gaussian mean value)
   - x_mean (gaussian mean value)
   - yaw_mean (gaussian mean value, in radians)
   - pitch_mean (gaussian mean value, in radians)
   - roll_mean (gaussian mean value, in radians)
   - C11,C22,C33,C44,C55,C66 (Covariance elements)
   - C12,C13,C14,C15,C16 (Covariance elements)
   - C23,C24,C25,C25 (Covariance elements)
   - C34,C35,C36 (Covariance elements)
   - C45,C46 (Covariance elements)
   - C56 (Covariance elements)
 
         
 
C++: mrpt::poses::CPose3DPDFSOG::saveToTextFile(const std::string &) const --> bool
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG) -> int
 
Return the number of Gaussian modes. 
 
C++: mrpt::poses::CPose3DPDFSOG::size() const --> size_t

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DPDFSOG::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DPDFSOG::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data and other attributes defined here:
TGaussianMode = <class 'mrpt.pymrpt.mrpt.poses.CPose3DPDFSOG.TGaussianMode'>
The struct for each mode:

Static methods inherited from CPose3DPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
 
 
 It returns a new object of any of the derived classes of
 CPose3DPDF. This object must be deleted by the user when not required
 anymore.
 
 
 copyFrom
 
C++: mrpt::poses::CPose3DPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DPDF *
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DPDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3D, u: mrpt.pymrpt.mrpt.poses.CPose3D, df_dx: mrpt::math::CMatrixFixed<double, 6ul, 6ul>, df_du: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
This static method computes the pose composition Jacobians.
 
 See this techical report:
 http:///www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty
 
 Direct equations (for the covariances) in yaw-pitch-roll are too complex.
  Make a way around them and consider instead this path:
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
         
 
C++: mrpt::poses::CPose3DPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3D &, const class mrpt::poses::CPose3D &, class mrpt::math::CMatrixFixed<double, 6, 6> &, class mrpt::math::CMatrixFixed<double, 6, 6> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 6ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 6, 6>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t, inf: mrpt::math::CMatrixFixed<double, 6ul, 6ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 6, 6> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::getMeanVal() const --> class mrpt::poses::CPose3D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3D_6UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3D, 6>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DQuat(CPose_mrpt_poses_CPose3DQuat_7UL_t, mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
    A class used to store a 3D pose as a translation (x,y,z) and a quaternion
(qr,qx,qy,qz).
 
 For a complete description of Points/Poses, see mrpt::poses::CPoseOrPoint,
or refer
   to the  2D/3D Geometry
tutorial in the wiki.
 
 To access the translation use x(), y() and z(). To access the rotation, use
CPose3DQuat::quat().
 
 This class also behaves like a STL container, since it has begin(), end(),
iterators, and can be accessed with the [] operator
  with indices running from 0 to 6 to access the  [x y z qr qx qy qz] as if
they were a vector. Thus, a CPose3DQuat can be used
  as a 7-vector anywhere the MRPT math functions expect any kind of vector.
 
 This class and CPose3D are very similar, and they can be converted to the
each other automatically via transformation constructors.
 
 
CPose3D (for a class based on a 4x4 matrix instead of a quaternion),
mrpt::math::TPose3DQuat, mrpt::poses::CPose3DQuatPDF for a probabilistic
version of this class,  mrpt::math::CQuaternion, CPoseOrPoint
 
 
Method resolution order:
CPose3DQuat
CPose_mrpt_poses_CPose3DQuat_7UL_t
CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuat::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__add__(...)
__add__(*args, **kwargs)
Overloaded function.
 
1. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, L: mrpt.pymrpt.mrpt.poses.CPoint3D) -> mrpt.pymrpt.mrpt.poses.CPoint3D
 
Computes the 3D point G such as 
.  
 
 composePoint    
 
C++: mrpt::poses::CPose3DQuat::operator+(const class mrpt::poses::CPoint3D &) const --> class mrpt::poses::CPoint3D
 
2. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, L: mrpt::math::TPoint3D_<double>) -> mrpt::math::TPoint3D_<double>
 
Computes the 3D point G such as 
.  
 
 composePoint    
 
C++: mrpt::poses::CPose3DQuat::operator+(const struct mrpt::math::TPoint3D_<double> &) const --> struct mrpt::math::TPoint3D_<double>
 
3. __add__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, p: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
Return the composed pose 
  
 
C++: mrpt::poses::CPose3DQuat::operator+(const class mrpt::poses::CPose3DQuat &) const --> class mrpt::poses::CPose3DQuat
__getitem__(...)
__getitem__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, i: int) -> float
 
Read/write [] operator 
 
C++: mrpt::poses::CPose3DQuat::operator[](unsigned int) --> double &
__iadd__(...)
__iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, b: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
Make 
  
 
C++: mrpt::poses::CPose3DQuat::operator+=(const class mrpt::poses::CPose3DQuat &) --> class mrpt::poses::CPose3DQuat &
__imul__(...)
__imul__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, s: float) -> None
 
Scalar multiplication (all x y z qr qx qy qz elements are multiplied by
 the scalar). 
 
C++: mrpt::poses::CPose3DQuat::operator*=(const double) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, : mrpt.pymrpt.mrpt.math.TConstructorFlags_Quaternions) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, : mrpt.pymrpt.mrpt.poses.TConstructorFlags_Poses) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, x: float, y: float, z: float, q: mrpt::math::CQuaternion<double>) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, p: mrpt.pymrpt.mrpt.math.TPose3DQuat) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, M: mrpt::math::CMatrixFixed<double, 4ul, 4ul>) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, b: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
Make 
  
 
C++: mrpt::poses::CPose3DQuat::operator-=(const class mrpt::poses::CPose3DQuat &) --> class mrpt::poses::CPose3DQuat &
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> str
__sub__(...)
__sub__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, p: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
Return the composed pose 
  
 
C++: mrpt::poses::CPose3DQuat::operator-(const class mrpt::poses::CPose3DQuat &) const --> class mrpt::poses::CPose3DQuat
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> str
 
Returns a human-readable textual representation of the object as:
  `"[x y z qw qx qy qz]"`
 
 
 fromString
 
C++: mrpt::poses::CPose3DQuat::asString() const --> std::string
asTPose(...)
asTPose(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.math.TPose3DQuat
 
C++: mrpt::poses::CPose3DQuat::asTPose() const --> struct mrpt::math::TPose3DQuat
asVector(...)
asVector(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, v: mrpt::math::CMatrixFixed<double, 7ul, 1ul>) -> None
 
Returns a 7x1 vector with [x y z qr qx qy qz]' 
 
C++: mrpt::poses::CPose3DQuat::asVector(class mrpt::math::CMatrixFixed<double, 7, 1> &) const --> void
assign(...)
assign(*args, **kwargs)
Overloaded function.
 
1. assign(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, N: int, val: float) -> None
 
C++: mrpt::poses::CPose3DQuat::assign(size_t, const double) --> void
 
2. assign(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, : mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
C++: mrpt::poses::CPose3DQuat::operator=(const class mrpt::poses::CPose3DQuat &) --> class mrpt::poses::CPose3DQuat &
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuat::clone() const --> class mrpt::rtti::CObject *
composeFrom(...)
composeFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, A: mrpt.pymrpt.mrpt.poses.CPose3DQuat, B: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Makes 
  this method is slightly more efficient
 than "this= A + B;" since it avoids the temporary object.
  
 
 A or B can be "this" without problems.
 
 
 inverseComposeFrom, composePoint
 
C++: mrpt::poses::CPose3DQuat::composeFrom(const class mrpt::poses::CPose3DQuat &, const class mrpt::poses::CPose3DQuat &) --> void
fromString(...)
fromString(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, s: str) -> None
 
Set the current object value from a string generated by 'asString' (eg:
 "[0.02 1.04 -0.8 1 0 0 0]" )
 
 
 asString
 
 
 std::exception On invalid format
 
C++: mrpt::poses::CPose3DQuat::fromString(const std::string &) --> void
fromStringRaw(...)
fromStringRaw(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, s: str) -> None
 
Same as fromString, but without requiring the square brackets in the
 string 
 
C++: mrpt::poses::CPose3DQuat::fromStringRaw(const std::string &) --> void
getHomogeneousMatrix(...)
getHomogeneousMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, out_HM: mrpt::math::CMatrixFixed<double, 4ul, 4ul>) -> None
 
Returns the corresponding 4x4 homogeneous transformation matrix for the
 point(translation) or pose (translation+orientation).
 
 
 getInverseHomogeneousMatrix
 
C++: mrpt::poses::CPose3DQuat::getHomogeneousMatrix(class mrpt::math::CMatrixFixed<double, 4, 4> &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
C++: mrpt::poses::CPose3DQuat::getPoseMean() --> class mrpt::poses::CPose3DQuat &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Convert this pose into its inverse, saving the result in itself. 
 
 operator- 
 
C++: mrpt::poses::CPose3DQuat::inverse() --> void
inverseComposeFrom(...)
inverseComposeFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, A: mrpt.pymrpt.mrpt.poses.CPose3DQuat, B: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Makes 
 this method is slightly more efficient
 than "this= A - B;" since it avoids the temporary object.
  
 
 A or B can be "this" without problems.
 
 
 composeFrom, composePoint
 
C++: mrpt::poses::CPose3DQuat::inverseComposeFrom(const class mrpt::poses::CPose3DQuat &, const class mrpt::poses::CPose3DQuat &) --> void
quat(...)
quat(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt::math::CQuaternion<double>
 
Read/Write access to the quaternion representing the 3D rotation. 
 
C++: mrpt::poses::CPose3DQuat::quat() --> class mrpt::math::CQuaternion<double> &
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
@} 
 
C++: mrpt::poses::CPose3DQuat::setToNaN() --> void
swap(...)
swap(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat, o: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
C++: mrpt::poses::CPose3DQuat::swap(class mrpt::poses::CPose3DQuat &) --> void
xyz(...)
xyz(self: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
Read/Write access to the translation vector in R^3. 
 
C++: mrpt::poses::CPose3DQuat::xyz() --> class mrpt::math::CMatrixFixed<double, 3, 1> &

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuat::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
FromString(...) from builtins.PyCapsule
FromString(s: str) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
C++: mrpt::poses::CPose3DQuat::FromString(const std::string &) --> class mrpt::poses::CPose3DQuat
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuat::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
empty(...) from builtins.PyCapsule
empty() -> bool
 
C++: mrpt::poses::CPose3DQuat::empty() --> bool
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPose3DQuat::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPose3DQuat::is_PDF() --> bool
max_size(...) from builtins.PyCapsule
max_size() -> int
 
C++: mrpt::poses::CPose3DQuat::max_size() --> unsigned long
resize(...) from builtins.PyCapsule
resize(n: int) -> None
 
C++: mrpt::poses::CPose3DQuat::resize(size_t) --> void
size(...) from builtins.PyCapsule
size() -> int
 
C++: mrpt::poses::CPose3DQuat::size() --> unsigned long

Data descriptors defined here:
m_coords
m_quat

Data and other attributes defined here:
const_iterator = <class 'mrpt.pymrpt.mrpt.poses.CPose3DQuat.const_iterator'>
iterator = <class 'mrpt.pymrpt.mrpt.poses.CPose3DQuat.iterator'>

Methods inherited from CPose_mrpt_poses_CPose3DQuat_7UL_t:
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::math::CMatrixFixed<double, 7ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 7, 1>
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::poses::CPose3DQuat
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::derived() --> class mrpt::poses::CPose3DQuat &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::norm() const --> double
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPose_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y_incr(const double) --> void

Static methods inherited from CPose_mrpt_poses_CPose3DQuat_7UL_t:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::is3DPoseOrPoint() --> bool

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DQuatPDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t)
    Declares a class that represents a Probability Density Function (PDF) of a
3D pose (6D actually), by means of a 7-vector with a translation [x y z] and
a quaternion [qr qx qy qz].
  This class is just the base class for unifying many diferent ways this PDF
can be implemented.
 
 For convenience, a pose composition is also defined for any
   PDF derived class, changeCoordinatesReference, in the form of a method
rather than an operator.
 
 - For a similar class for 3D points (without attitude), see CPointPDF.
 - For a similar class for 3D poses  (with Euler angles instead of
quaternions), see CPose3DPDF.
 
 See also:
 [probabilistic spatial representations](tutorial-pdf-over-poses.html)
 
 
CPose3DQuatPDFCPose3DPDF
 
 
Method resolution order:
CPose3DQuatPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDF::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF, : mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF
 
C++: mrpt::poses::CPose3DQuatPDF::operator=(const class mrpt::poses::CPose3DQuatPDF &) --> class mrpt::poses::CPose3DQuatPDF &
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPose3DQuatPDF::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
 
 createFrom2D
 
C++: mrpt::poses::CPose3DQuatPDF::copyFrom(const class mrpt::poses::CPose3DQuatPDF &) --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DQuatPDF::inverse(class mrpt::poses::CPose3DQuatPDF &) const --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDF::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
  It returns a new object of any of the derived classes of
 CPose3DQuatPDF. This object must be deleted by the user when not required
 anymore.
  
 
 copyFrom
 
C++: mrpt::poses::CPose3DQuatPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DQuatPDF *
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, out_x_oplus_u: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
This static method computes the two Jacobians of a pose composition
 operation 
 
 
  
 If set to !=nullptr, the result of "x+u" will be
 stored here (it will be computed internally anyway).
  To see the mathematical derivation of the formulas, refer to the
 technical report here:
   -
 https://www.mrpt.org/Probability_Density_Distributions_Over_Spatial_Representations
 
C++: mrpt::poses::CPose3DQuatPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3DQuat &, const class mrpt::poses::CPose3DQuat &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::poses::CPose3DQuat *) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
clone(...)
clone(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Returns a deep copy (clone) of the object, indepently of its class. 
 
C++: mrpt::rtti::CObject::clone() const --> class mrpt::rtti::CObject *
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t:
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, outPart: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::drawSingleSample(class mrpt::poses::CPose3DQuat &) const --> void
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixFixed<double, 7ul, 7ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::math::CMatrixFixed<double, 7ul, 7ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 7, 7>
getCovarianceAndMean(...)
getCovarianceAndMean(*args, **kwargs)
Overloaded function.
 
1. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> Tuple[mrpt::math::CMatrixFixed<double, 7ul, 7ul>, mrpt::poses::CPose3DQuat]
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 7, 7>, class mrpt::poses::CPose3DQuat>
 
2. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, c: mrpt::math::CMatrixFixed<double, 7ul, 7ul>, mean: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceAndMean(class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::poses::CPose3DQuat &) const --> void
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3DQuat &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, inf: mrpt::math::CMatrixFixed<double, 7ul, 7ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, mean_point: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getMean(class mrpt::poses::CPose3DQuat &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::poses::CPose3DQuat
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getMeanVal() const --> class mrpt::poses::CPose3DQuat
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, file: str) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::saveToTextFile(const std::string &) const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DQuatPDFGaussian(CPose3DQuatPDF)
    Declares a class that represents a Probability Density function (PDF) of a
 3D pose using a quaternion 
 
 
 
.
 
   This class implements that PDF using a mono-modal Gaussian distribution.
 See mrpt::poses::CPose3DQuatPDF for more details, or
    mrpt::poses::CPose3DPDF for classes based on Euler angles instead.
 
  Uncertainty of pose composition operations (
) is
 implemented in the methods "CPose3DQuatPDFGaussian::operator+=" and
 "CPose3DQuatPDF::jacobiansPoseComposition".
 
  For further details on implemented methods and the theory behind them,
  see 
* href="http://www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty"
 >this report.
 
 
 CPose3DQuatCPose3DQuatPDFCPose3DPDFCPose3DQuatPDFGaussianInf
 
 
Method resolution order:
CPose3DQuatPDFGaussian
CPose3DQuatPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated). 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::operator+=(const class mrpt::poses::CPose3DQuat &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) (see formulas in
 jacobiansPoseComposition ). 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::operator+=(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, constructor_dummy_param: mrpt.pymrpt.mrpt.math.TConstructorFlags_Quaternions) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3DQuat, init_Cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated).
 This operation assumes statistical independence between the two
 variables. If you want to take into account the cross-correlation between
 pose_1 and pose_2, use:
 displacement = pose_1.inverseCompositionCrossCorrelation(pose_2)
 Note: Both poses are correlated if the direct generative model is
 pose_2 = pose_1 + displacement
 
 
 inverseCompositionCrossCorrelation
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::operator-=(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> void
__neg__(...)
__neg__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian
 
Unary - operator, returns the PDF of the inverse pose.  
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::operator-() const --> class mrpt::poses::CPose3DQuatPDFGaussian
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> str
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, : mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::operator=(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> class mrpt::poses::CPose3DQuatPDFGaussian &
changeCoordinatesReference(...)
changeCoordinatesReference(*args, **kwargs)
Overloaded function.
 
1. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3DQuat &) --> void
 
2. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object.
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(*args, **kwargs)
Overloaded function.
 
1. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::copyFrom(const class mrpt::poses::CPose3DQuatPDF &) --> void
 
2. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::copyFrom(const class mrpt::poses::CPosePDF &) --> void
 
3. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::copyFrom(const class mrpt::poses::CPose3DPDFGaussian &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, outPart: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Draws a single sample from the distribution 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::drawSingleSample(class mrpt::poses::CPose3DQuat &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1]. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::evaluateNormalizedPDF(const class mrpt::poses::CPose3DQuat &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> float
 
Evaluates the PDF at a given point. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::evaluatePDF(const class mrpt::poses::CPose3DQuat &) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, mrpt.pymrpt.mrpt.poses.CPose3DQuat]
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 7, 7>, class mrpt::poses::CPose3DQuat>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::getMean(class mrpt::poses::CPose3DQuat &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::getPoseMean() --> class mrpt::poses::CPose3DQuat &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::inverse(class mrpt::poses::CPose3DQuatPDF &) const --> void
inverseCompositionCrossCorrelation(...)
inverseCompositionCrossCorrelation(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, pose_to: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian
 
Returns the displacement from the current pose (pose_from) to pose_to:
 displacement = - pose_from + pose_to
 It assumes that both poses are correlated via
 the direct generative model:
 pose_to = pose_from + displacement
 For a deeper explanation, check https://github.com/MRPT/mrpt/pull/1243
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::inverseCompositionCrossCorrelation(const class mrpt::poses::CPose3DQuatPDFGaussian &) const --> class mrpt::poses::CPose3DQuatPDFGaussian
inverseJacobian(...)
inverseJacobian(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t
 
Compute the inverse Jacobian 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::inverseJacobian() const --> class mrpt::math::CMatrixFixed<double, 7, 7>
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, theOther: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> float
 
Computes the Mahalanobis distance between the centers of two Gaussians.
  The variables with a variance exactly equal to 0 are not taken into
 account in the process, but
   "infinity" is returned if the corresponding elements are not exactly
 equal. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::mahalanobisDistanceTo(const class mrpt::poses::CPose3DQuatPDFGaussian &) --> double
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian, file: str) -> bool
 
Save the PDF to a text file, containing the 3D pose in the first line (x
 y z qr qx qy qz), then the covariance matrix in the next 7 lines. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDFGaussian::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov
mean

Static methods inherited from CPose3DQuatPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
  It returns a new object of any of the derived classes of
 CPose3DQuatPDF. This object must be deleted by the user when not required
 anymore.
  
 
 copyFrom
 
C++: mrpt::poses::CPose3DQuatPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DQuatPDF *
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, out_x_oplus_u: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
This static method computes the two Jacobians of a pose composition
 operation 
 
 
  
 If set to !=nullptr, the result of "x+u" will be
 stored here (it will be computed internally anyway).
  To see the mathematical derivation of the formulas, refer to the
 technical report here:
   -
 https://www.mrpt.org/Probability_Density_Distributions_Over_Spatial_Representations
 
C++: mrpt::poses::CPose3DQuatPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3DQuat &, const class mrpt::poses::CPose3DQuat &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::poses::CPose3DQuat *) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixFixed<double, 7ul, 7ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::math::CMatrixFixed<double, 7ul, 7ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 7, 7>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3DQuat &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, inf: mrpt::math::CMatrixFixed<double, 7ul, 7ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::poses::CPose3DQuat
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getMeanVal() const --> class mrpt::poses::CPose3DQuat
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPose3DQuatPDFGaussianInf(CPose3DQuatPDF)
    Declares a class that represents a Probability Density function (PDF) of a
 3D pose using a quaternion 
 
 
 
.
 
   This class implements that PDF using a mono-modal Gaussian distribution
 storing the information matrix instead of its inverse, the covariance matrix.
     See mrpt::poses::CPose3DQuatPDF for more details, or
     mrpt::poses::CPose3DPDF for classes based on Euler angles instead.
 
  Uncertainty of pose composition operations (
) is
 implemented in the methods "CPose3DQuatPDFGaussianInf::operator+=" and
 "CPose3DQuatPDF::jacobiansPoseComposition".
 
  For further details on implemented methods and the theory behind them,
  see 
* href="http://www.mrpt.org/6D_poses:equivalences_compositions_and_uncertainty"
 >this report.
 
 
 CPose3DQuatCPose3DQuatPDFCPose3DPDFCPose3DQuatPDFGaussian
 
 
Method resolution order:
CPose3DQuatPDFGaussianInf
CPose3DQuatPDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated). 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::operator+=(const class mrpt::poses::CPose3DQuat &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) (see formulas in
 jacobiansPoseComposition ). 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::operator+=(const class mrpt::poses::CPose3DQuatPDFGaussianInf &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, constructor_dummy_param: mrpt.pymrpt.mrpt.math.TConstructorFlags_Quaternions) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose3DQuat, init_CovInv: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated). 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::operator-=(const class mrpt::poses::CPose3DQuatPDFGaussianInf &) --> void
__neg__(...)
__neg__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf
 
Unary - operator, returns the PDF of the inverse pose.  
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::operator-() const --> class mrpt::poses::CPose3DQuatPDFGaussianInf
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> str
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, : mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::operator=(const class mrpt::poses::CPose3DQuatPDFGaussianInf &) --> class mrpt::poses::CPose3DQuatPDFGaussianInf &
changeCoordinatesReference(...)
changeCoordinatesReference(*args, **kwargs)
Overloaded function.
 
1. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::changeCoordinatesReference(const class mrpt::poses::CPose3DQuat &) --> void
 
2. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::copyFrom(const class mrpt::poses::CPose3DQuatPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, outPart: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
Draws a single sample from the distribution 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::drawSingleSample(class mrpt::poses::CPose3DQuat &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1] 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::evaluateNormalizedPDF(const class mrpt::poses::CPose3DQuat &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> float
 
Evaluates the PDF at a given point 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::evaluatePDF(const class mrpt::poses::CPose3DQuat &) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, mrpt.pymrpt.mrpt.poses.CPose3DQuat]
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 7, 7>, class mrpt::poses::CPose3DQuat>
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, inf: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
Returns the information (inverse covariance) matrix (a STATE_LEN x
 STATE_LEN matrix) 
 
 getMean, getCovarianceAndMean 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, mean_pose: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::getMean(class mrpt::poses::CPose3DQuat &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::getPoseMean() --> class mrpt::poses::CPose3DQuat &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::inverse(class mrpt::poses::CPose3DQuatPDF &) const --> void
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf) -> bool
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussianInf, file: str) -> bool
 
Save the PDF to a text file, containing the 3D pose in the first line (x
 y z qr qx qy qz), then the information matrix in the next 7 lines. 
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPose3DQuatPDFGaussianInf::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov_inv
mean

Static methods inherited from CPose3DQuatPDF:
createFrom2D(...) from builtins.PyCapsule
createFrom2D(o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPose3DQuatPDF
 
This is a static transformation method from 2D poses to 3D PDFs,
 preserving the representation type (particles->particles,
 Gaussians->Gaussians,etc)
  It returns a new object of any of the derived classes of
 CPose3DQuatPDF. This object must be deleted by the user when not required
 anymore.
  
 
 copyFrom
 
C++: mrpt::poses::CPose3DQuatPDF::createFrom2D(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPose3DQuatPDF *
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose3DQuat, u: mrpt.pymrpt.mrpt.poses.CPose3DQuat, df_dx: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, df_du: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_7UL_7UL_t, out_x_oplus_u: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
This static method computes the two Jacobians of a pose composition
 operation 
 
 
  
 If set to !=nullptr, the result of "x+u" will be
 stored here (it will be computed internally anyway).
  To see the mathematical derivation of the formulas, refer to the
 technical report here:
   -
 https://www.mrpt.org/Probability_Density_Distributions_Over_Spatial_Representations
 
C++: mrpt::poses::CPose3DQuatPDF::jacobiansPoseComposition(const class mrpt::poses::CPose3DQuat &, const class mrpt::poses::CPose3DQuat &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::math::CMatrixFixed<double, 7, 7> &, class mrpt::poses::CPose3DQuat *) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixFixed<double, 7ul, 7ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance(class mrpt::math::CMatrixFixed<double, 7, 7> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::math::CMatrixFixed<double, 7ul, 7ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 7, 7>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt::poses::CPose3DQuat) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose3DQuat &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getCovarianceEntropy() const --> double
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::poses::CPose3DQuat
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose3DQuat, 7>::getMeanVal() const --> class mrpt::poses::CPose3DQuat

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseInterpolatorBase_2_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseInterpolatorBase_2_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, : mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::operator=(const class mrpt::poses::CPoseInterpolatorBase<2> &) --> class mrpt::poses::CPoseInterpolatorBase<2> &
at(...)
at(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> mrpt.pymrpt.mrpt.math.TPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::at(const mrpt::Clock::time_point &) --> struct mrpt::math::TPose2D &
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::clear() --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::empty() const --> bool
filter(...)
filter(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, component: int, samples: int) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::filter(unsigned int, unsigned int) --> void
getBoundingBox(...)
getBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, minCorner: mrpt::math::TPoint2D_<double>, maxCorner: mrpt::math::TPoint2D_<double>) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getBoundingBox(struct mrpt::math::TPoint2D_<double> &, struct mrpt::math::TPoint2D_<double> &) const --> void
getInterpolationMethod(...)
getInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> mrpt.pymrpt.mrpt.poses.TInterpolatorMethod
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getInterpolationMethod() const --> enum mrpt::poses::TInterpolatorMethod
getMaxTimeInterpolation(...)
getMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getMaxTimeInterpolation() --> struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>>
getPreviousPoseWithMinDistance(...)
getPreviousPoseWithMinDistance(*args, **kwargs)
Overloaded function.
 
1. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.math.TPose2D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, struct mrpt::math::TPose2D &) --> bool
 
2. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, class mrpt::poses::CPose2D &) --> bool
insert(...)
insert(*args, **kwargs)
Overloaded function.
 
1. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.math.TPose2D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::insert(const mrpt::Clock::time_point &, const struct mrpt::math::TPose2D &) --> void
 
2. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::insert(const mrpt::Clock::time_point &, const class mrpt::poses::CPose2D &) --> void
interpolate(...)
interpolate(*args, **kwargs)
Overloaded function.
 
1. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.math.TPose2D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.math.TPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::interpolate(const mrpt::Clock::time_point &, struct mrpt::math::TPose2D &, bool &) const --> struct mrpt::math::TPose2D &
 
2. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.poses.CPose2D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::interpolate(const mrpt::Clock::time_point &, class mrpt::poses::CPose2D &, bool &) const --> class mrpt::poses::CPose2D &
loadFromTextFile(...)
loadFromTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::loadFromTextFile(const std::string &) --> bool
saveInterpolatedToTextFile(...)
saveInterpolatedToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str, period: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::saveInterpolatedToTextFile(const std::string &, const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::saveToTextFile(const std::string &) const --> bool
setInterpolationMethod(...)
setInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, method: mrpt.pymrpt.mrpt.poses.TInterpolatorMethod) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::setInterpolationMethod(enum mrpt::poses::TInterpolatorMethod) --> void
setMaxTimeInterpolation(...)
setMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t, time: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::setMaxTimeInterpolation(const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_2_t) -> int
 
C++: mrpt::poses::CPoseInterpolatorBase<2>::size() const --> size_t

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseInterpolatorBase_3_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseInterpolatorBase_3_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, : mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::operator=(const class mrpt::poses::CPoseInterpolatorBase<3> &) --> class mrpt::poses::CPoseInterpolatorBase<3> &
at(...)
at(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::at(const mrpt::Clock::time_point &) --> struct mrpt::math::TPose3D &
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::clear() --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::empty() const --> bool
filter(...)
filter(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, component: int, samples: int) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::filter(unsigned int, unsigned int) --> void
getBoundingBox(...)
getBoundingBox(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, minCorner: mrpt::math::TPoint3D_<double>, maxCorner: mrpt::math::TPoint3D_<double>) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getBoundingBox(struct mrpt::math::TPoint3D_<double> &, struct mrpt::math::TPoint3D_<double> &) const --> void
getInterpolationMethod(...)
getInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> mrpt.pymrpt.mrpt.poses.TInterpolatorMethod
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getInterpolationMethod() const --> enum mrpt::poses::TInterpolatorMethod
getMaxTimeInterpolation(...)
getMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getMaxTimeInterpolation() --> struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>>
getPreviousPoseWithMinDistance(...)
getPreviousPoseWithMinDistance(*args, **kwargs)
Overloaded function.
 
1. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.math.TPose3D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, struct mrpt::math::TPose3D &) --> bool
 
2. getPreviousPoseWithMinDistance(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, distance: float, out_pose: mrpt.pymrpt.mrpt.poses.CPose3D) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::getPreviousPoseWithMinDistance(const mrpt::Clock::time_point &, double, class mrpt::poses::CPose3D &) --> bool
insert(...)
insert(*args, **kwargs)
Overloaded function.
 
1. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::insert(const mrpt::Clock::time_point &, const struct mrpt::math::TPose3D &) --> void
 
2. insert(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::insert(const mrpt::Clock::time_point &, const class mrpt::poses::CPose3D &) --> void
interpolate(...)
interpolate(*args, **kwargs)
Overloaded function.
 
1. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.math.TPose3D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::interpolate(const mrpt::Clock::time_point &, struct mrpt::math::TPose3D &, bool &) const --> struct mrpt::math::TPose3D &
 
2. interpolate(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, t: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t, out_interp: mrpt.pymrpt.mrpt.poses.CPose3D, out_valid_interp: bool) -> mrpt.pymrpt.mrpt.poses.CPose3D
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::interpolate(const mrpt::Clock::time_point &, class mrpt::poses::CPose3D &, bool &) const --> class mrpt::poses::CPose3D &
loadFromTextFile(...)
loadFromTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::loadFromTextFile(const std::string &) --> bool
saveInterpolatedToTextFile(...)
saveInterpolatedToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str, period: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::saveInterpolatedToTextFile(const std::string &, const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, s: str) -> bool
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::saveToTextFile(const std::string &) const --> bool
setInterpolationMethod(...)
setInterpolationMethod(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, method: mrpt.pymrpt.mrpt.poses.TInterpolatorMethod) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::setInterpolationMethod(enum mrpt::poses::TInterpolatorMethod) --> void
setMaxTimeInterpolation(...)
setMaxTimeInterpolation(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t, time: mrpt.pymrpt.std.chrono.duration_long_std_ratio_1_10000000_t) -> None
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::setMaxTimeInterpolation(const struct std::chrono::duration<int64_t,struct std::ratio<1,10000000>> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPoseInterpolatorBase_3_t) -> int
 
C++: mrpt::poses::CPoseInterpolatorBase<3>::size() const --> size_t

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> None
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::math::CMatrixFixed<double, 2ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 2, 1>
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint2D, 2> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint2D, 2> &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> mrpt::poses::CPoint2D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::derived() --> class mrpt::poses::CPoint2D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint2D_2UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint2D, 2>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> None
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 3, 1>
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint3D, 3> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPoint3D, 3> &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> mrpt::poses::CPoint3D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::derived() --> class mrpt::poses::CPoint3D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPoint3D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPoint3D, 3>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseOrPoint_mrpt_poses_CPose2D_3UL_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseOrPoint_mrpt_poses_CPose2D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> None
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 3, 1>
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose2D, 3> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose2D, 3> &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> mrpt::poses::CPose2D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::derived() --> class mrpt::poses::CPose2D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose2D_3UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose2D, 3>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> None
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::math::CMatrixFixed<double, 7ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 7, 1>
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose3DQuat, 7> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose3DQuat, 7> &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> mrpt::poses::CPose3DQuat
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::derived() --> class mrpt::poses::CPose3DQuat &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3DQuat_7UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3DQuat, 7>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPoseOrPoint_mrpt_poses_CPose3D_6UL_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
CPoseOrPoint_mrpt_poses_CPose3D_6UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, arg0: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> None
asVectorVal(...)
asVectorVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 6ul, 1ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::asVectorVal() const --> class mrpt::math::CMatrixFixed<double, 6, 1>
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, : mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::operator=(const class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose3D, 6> &) --> class mrpt::poses::CPoseOrPoint<class mrpt::poses::CPose3D, 6> &
derived(...)
derived(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> mrpt::poses::CPose3D
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::derived() --> class mrpt::poses::CPose3D &
distance2DTo(...)
distance2DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance2DTo(double, double) const --> double
distance2DToSquare(...)
distance2DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance2DToSquare(double, double) const --> double
distance3DTo(...)
distance3DTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance3DTo(double, double, double) const --> double
distance3DToSquare(...)
distance3DToSquare(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, ax: float, ay: float, az: float) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distance3DToSquare(double, double, double) const --> double
distanceTo(...)
distanceTo(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, b: mrpt::math::TPoint3D_<double>) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::distanceTo(const struct mrpt::math::TPoint3D_<double> &) const --> double
getHomogeneousMatrixVal(...)
getHomogeneousMatrixVal(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> mrpt::math::CMatrixFixed<double, 4ul, 4ul>
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::getHomogeneousMatrixVal() const --> class mrpt::math::CMatrixFixed<double, 4, 4>
norm(...)
norm(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::norm() const --> double
setToNaN(...)
setToNaN(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::setToNaN() --> void
x(...)
x(*args, **kwargs)
Overloaded function.
 
1. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x() --> double &
 
2. x(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x(const double) --> void
x_incr(...)
x_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::x_incr(const double) --> void
y(...)
y(*args, **kwargs)
Overloaded function.
 
1. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t) -> float
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y() --> double &
 
2. y(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y(const double) --> void
y_incr(...)
y_incr(self: mrpt.pymrpt.mrpt.poses.CPoseOrPoint_mrpt_poses_CPose3D_6UL_t, v: float) -> None
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::y_incr(const double) --> void

Static methods defined here:
is3DPoseOrPoint(...) from builtins.PyCapsule
is3DPoseOrPoint() -> bool
 
C++: mrpt::poses::CPoseOrPoint<mrpt::poses::CPose3D, 6>::is3DPoseOrPoint() --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPosePDF(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t)
    Declares a class that represents a probability density function (pdf) of a
2D pose (x,y,phi).
  This class is just the base class for unifying many diferent ways this pdf
can be implemented.
 
 For convenience, a pose composition is also defined for any pdf derived
class,
  changeCoordinatesReference, in the form of a method rather than an
operator.
 
 See also:
 [probabilistic spatial representations](tutorial-pdf-over-poses.html)
 
 
CPose2DCPose3DPDFCPoseRandomSampler
 
 
Method resolution order:
CPosePDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDF::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDF, arg0: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPosePDF, : mrpt.pymrpt.mrpt.poses.CPosePDF) -> mrpt.pymrpt.mrpt.poses.CPosePDF
 
C++: mrpt::poses::CPosePDF::operator=(const class mrpt::poses::CPosePDF &) --> class mrpt::poses::CPosePDF &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDF, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDF, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two pose distributions (product of two
 distributions->new distribution), then save the result in this object
 (WARNING: See implementing classes to see classes that can and cannot be
 mixtured!)
 
 
 The first distribution to fuse
 
 
 The second distribution to fuse
 
 
 If set to different of 0, the result of
 very separate Gaussian modes (that will result in negligible components)
 in SOGs will be dropped to reduce the number of modes in the output.
 
C++: mrpt::poses::CPosePDF::bayesianFusion(const class mrpt::poses::CPosePDF &, const class mrpt::poses::CPosePDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDF, newReferenceBase: mrpt::poses::CPose3D) -> None
 
C++: mrpt::poses::CPosePDF::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDF, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations)
 
C++: mrpt::poses::CPosePDF::copyFrom(const class mrpt::poses::CPosePDF &) --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPosePDF, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF
 
C++: mrpt::poses::CPosePDF::inverse(class mrpt::poses::CPosePDF &) const --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDF::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPosePDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPosePDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool) -> None
 
3. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool, compute_df_du: bool) -> None
 
This static method computes the pose composition Jacobians, with these
           formulas:
                
 
 
 
 
 
 
 
 
 
 
 
          
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &, const bool, const bool) --> void
 
4. jacobiansPoseComposition(x: mrpt::poses::CPosePDFGaussian, u: mrpt::poses::CPosePDFGaussian, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
clone(...)
clone(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Returns a deep copy (clone) of the object, indepently of its class. 
 
C++: mrpt::rtti::CObject::clone() const --> class mrpt::rtti::CObject *
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t:
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, outPart: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceAndMean(...)
getCovarianceAndMean(*args, **kwargs)
Overloaded function.
 
1. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> Tuple[mrpt::math::CMatrixFixed<double, 3ul, 3ul>, mrpt.pymrpt.mrpt.poses.CPose2D]
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPose2D>
 
2. getCovarianceAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, c: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, mean: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceAndMean(class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::poses::CPose2D &) const --> void
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose2D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, mean_point: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getMean(class mrpt::poses::CPose2D &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getMeanVal() const --> class mrpt::poses::CPose2D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::isInfType() const --> bool
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, file: str) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::saveToTextFile(const std::string &) const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPosePDFGaussian(CPosePDF)
    Declares a class that represents a Probability Density  function (PDF) of a
 2D pose 
 
.
 
   This class implements that PDF using a mono-modal Gaussian distribution.
 See mrpt::poses::CPosePDF for more details.
 
 
 CPose2DCPosePDFCPosePDFParticles
 
 
Method resolution order:
CPosePDFGaussian
CPosePDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGaussian::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated). 
 
C++: mrpt::poses::CPosePDFGaussian::operator+=(const class mrpt::poses::CPose2D &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, Ap: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) (see formulas in
 jacobiansPoseComposition ). 
 
C++: mrpt::poses::CPosePDFGaussian::operator+=(const class mrpt::poses::CPosePDFGaussian &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, init_Mean: mrpt.pymrpt.mrpt.poses.CPose2D, init_Cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, ref: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated) 
 
C++: mrpt::poses::CPosePDFGaussian::operator-=(const class mrpt::poses::CPosePDFGaussian &) --> void
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> str
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, : mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPosePDFGaussian
 
C++: mrpt::poses::CPosePDFGaussian::operator=(const class mrpt::poses::CPosePDFGaussian &) --> class mrpt::poses::CPosePDFGaussian &
assureMinCovariance(...)
assureMinCovariance(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, minStdXY: float, minStdPhi: float) -> None
 
Substitutes the diagonal elements if (square) they are below some given
 minimum values (Use this before bayesianFusion, for example, to avoid
 inversion of singular matrixes, etc...)  
 
C++: mrpt::poses::CPosePDFGaussian::assureMinCovariance(double, double) --> void
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPosePDFGaussian::bayesianFusion(const class mrpt::poses::CPosePDF &, const class mrpt::poses::CPosePDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(*args, **kwargs)
Overloaded function.
 
1. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object.
 
C++: mrpt::poses::CPosePDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
 
2. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object.
 
C++: mrpt::poses::CPosePDFGaussian::changeCoordinatesReference(const class mrpt::poses::CPose2D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGaussian::clone() const --> class mrpt::rtti::CObject *
composePoint(...)
composePoint(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, l: mrpt::math::TPoint2D_<double>, g: mrpt::poses::CPoint2DPDFGaussian) -> None
 
Returns the PDF of the 2D point 
 with "q"=this pose
 and "l" a point without uncertainty 
 
C++: mrpt::poses::CPosePDFGaussian::composePoint(const struct mrpt::math::TPoint2D_<double> &, class mrpt::poses::CPoint2DPDFGaussian &) const --> void
copyFrom(...)
copyFrom(*args, **kwargs)
Overloaded function.
 
1. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPosePDFGaussian::copyFrom(const class mrpt::poses::CPosePDF &) --> void
 
2. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPosePDFGaussian::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, outPart: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Draws a single sample from the distribution
 
C++: mrpt::poses::CPosePDFGaussian::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1]. 
 
C++: mrpt::poses::CPosePDFGaussian::evaluateNormalizedPDF(const class mrpt::poses::CPose2D &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Evaluates the PDF at a given point. 
 
C++: mrpt::poses::CPosePDFGaussian::evaluatePDF(const class mrpt::poses::CPose2D &) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPose2D]
 
C++: mrpt::poses::CPosePDFGaussian::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPose2D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, mean_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPosePDFGaussian::getMean(class mrpt::poses::CPose2D &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPosePDFGaussian::getPoseMean() --> class mrpt::poses::CPose2D &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF
 
C++: mrpt::poses::CPosePDFGaussian::inverse(class mrpt::poses::CPosePDF &) const --> void
inverseComposition(...)
inverseComposition(*args, **kwargs)
Overloaded function.
 
1. inverseComposition(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, x: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, ref: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
Set 
 , computing the mean using the "-"
 operator and the covariances through the corresponding Jacobians (For
 'x0' and 'x1' being independent variables!). 
 
C++: mrpt::poses::CPosePDFGaussian::inverseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &) --> void
 
2. inverseComposition(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, x1: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, x0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, COV_01: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
Set 
 , computing the mean using the "-"
 operator and the covariances through the corresponding Jacobians (Given
 the 3x3 cross-covariance matrix of variables x0 and x1). 
 
C++: mrpt::poses::CPosePDFGaussian::inverseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &, const class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, theOther: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> float
 
Computes the Mahalanobis distance between the centers of two Gaussians.
 
C++: mrpt::poses::CPosePDFGaussian::mahalanobisDistanceTo(const class mrpt::poses::CPosePDFGaussian &) --> double
rotateCov(...)
rotateCov(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, ang: float) -> None
 
Rotate the covariance matrix by replacing it by 
 
 
, where 
 
 
 
.
 
C++: mrpt::poses::CPosePDFGaussian::rotateCov(const double) --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian, file: str) -> bool
 
Save PDF's particles to a text file, containing the 2D pose in the first
 line, then the covariance matrix in next 3 lines. 
 
C++: mrpt::poses::CPosePDFGaussian::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGaussian::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGaussian::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov
mean

Static methods inherited from CPosePDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPosePDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPosePDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool) -> None
 
3. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool, compute_df_du: bool) -> None
 
This static method computes the pose composition Jacobians, with these
           formulas:
                
 
 
 
 
 
 
 
 
 
 
 
          
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &, const bool, const bool) --> void
 
4. jacobiansPoseComposition(x: mrpt::poses::CPosePDFGaussian, u: mrpt::poses::CPosePDFGaussian, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose2D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceEntropy() const --> double
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, inf: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getMeanVal() const --> class mrpt::poses::CPose2D
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> bool
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::isInfType() const --> bool

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPosePDFGaussianInf(CPosePDF)
    A Probability Density  function (PDF) of a 2D pose 
 
 
as a Gaussian with a mean and the inverse of the covariance.
 
  This class implements a PDF as a mono-modal Gaussian distribution in its
information form, that is,
    keeping the inverse of the covariance matrix instead of the covariance
matrix itself.
 
 This class is the dual of CPosePDFGaussian.
 
 
CPose2DCPosePDFCPosePDFParticles
 
 
Method resolution order:
CPosePDFGaussianInf
CPosePDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGaussianInf::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated). 
 
C++: mrpt::poses::CPosePDFGaussianInf::operator+=(const class mrpt::poses::CPose2D &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, Ap: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF + Ap, where "+" is pose composition (both the
 mean, and the covariance matrix are updated) (see formulas in
 jacobiansPoseComposition ). 
 
C++: mrpt::poses::CPosePDFGaussianInf::operator+=(const class mrpt::poses::CPosePDFGaussianInf &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, init_Mean: mrpt.pymrpt.mrpt.poses.CPose2D, init_CovInv: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
__isub__(...)
__isub__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, ref: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
 
Makes: thisPDF = thisPDF - Ap, where "-" is pose inverse composition
 (both the mean, and the covariance matrix are updated) 
 
C++: mrpt::poses::CPosePDFGaussianInf::operator-=(const class mrpt::poses::CPosePDFGaussianInf &) --> void
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> str
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, : mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf
 
C++: mrpt::poses::CPosePDFGaussianInf::operator=(const class mrpt::poses::CPosePDFGaussianInf &) --> class mrpt::poses::CPosePDFGaussianInf &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of two points gauss. distributions, then save the result
in this object.
  The process is as follows:
                - (x1,S1): Mean and variance of the p1 distribution.
                - (x2,S2): Mean and variance of the p2 distribution.
                - (x,S): Mean and variance of the resulting distribution.
 
    
 
    
 
         
 
C++: mrpt::poses::CPosePDFGaussianInf::bayesianFusion(const class mrpt::poses::CPosePDF &, const class mrpt::poses::CPosePDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(*args, **kwargs)
Overloaded function.
 
1. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object 
 
C++: mrpt::poses::CPosePDFGaussianInf::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
 
2. changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPosePDFGaussianInf::changeCoordinatesReference(const class mrpt::poses::CPose2D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGaussianInf::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(*args, **kwargs)
Overloaded function.
 
1. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPosePDFGaussianInf::copyFrom(const class mrpt::poses::CPosePDF &) --> void
 
2. copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPosePDFGaussianInf::copyFrom(const class mrpt::poses::CPose3DPDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, outPart: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Draws a single sample from the distribution 
 
C++: mrpt::poses::CPosePDFGaussianInf::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
evaluateNormalizedPDF(...)
evaluateNormalizedPDF(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Evaluates the ratio PDF(x) / PDF(MEAN), that is, the normalized PDF in
 the range [0,1]. 
 
C++: mrpt::poses::CPosePDFGaussianInf::evaluateNormalizedPDF(const class mrpt::poses::CPose2D &) const --> double
evaluatePDF(...)
evaluatePDF(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPose2D) -> float
 
Evaluates the PDF at a given point 
 
C++: mrpt::poses::CPosePDFGaussianInf::evaluatePDF(const class mrpt::poses::CPose2D &) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPose2D]
 
C++: mrpt::poses::CPosePDFGaussianInf::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPose2D>
getInformationMatrix(...)
getInformationMatrix(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, inf: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
Returns the information (inverse covariance) matrix (a STATE_LEN x
 STATE_LEN matrix) 
 
 getMean, getCovarianceAndMean 
 
C++: mrpt::poses::CPosePDFGaussianInf::getInformationMatrix(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, mean_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Returns an estimate of the pose, (the mean, or mathematical expectation
 of the PDF).
 
 
 getCovariance 
 
C++: mrpt::poses::CPosePDFGaussianInf::getMean(class mrpt::poses::CPose2D &) const --> void
getPoseMean(...)
getPoseMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::poses::CPosePDFGaussianInf::getPoseMean() --> class mrpt::poses::CPose2D &
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPosePDFGaussianInf::inverse(class mrpt::poses::CPosePDF &) const --> void
inverseComposition(...)
inverseComposition(*args, **kwargs)
Overloaded function.
 
1. inverseComposition(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, x: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, ref: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> None
 
Set 
 , computing the mean using the "-"
 operator and the covariances through the corresponding Jacobians (For
 'x0' and 'x1' being independent variables!).  
 
C++: mrpt::poses::CPosePDFGaussianInf::inverseComposition(const class mrpt::poses::CPosePDFGaussianInf &, const class mrpt::poses::CPosePDFGaussianInf &) --> void
 
2. inverseComposition(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, x1: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, x0: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, COV_01: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
Set 
 , computing the mean using the "-"
 operator and the covariances through the corresponding Jacobians (Given
 the 3x3 cross-covariance matrix of variables x0 and x1). 
 
C++: mrpt::poses::CPosePDFGaussianInf::inverseComposition(const class mrpt::poses::CPosePDFGaussianInf &, const class mrpt::poses::CPosePDFGaussianInf &, const class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void
isInfType(...)
isInfType(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> bool
 
C++: mrpt::poses::CPosePDFGaussianInf::isInfType() const --> bool
mahalanobisDistanceTo(...)
mahalanobisDistanceTo(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, theOther: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf) -> float
 
Computes the Mahalanobis distance between the centers of two Gaussians.
 
C++: mrpt::poses::CPosePDFGaussianInf::mahalanobisDistanceTo(const class mrpt::poses::CPosePDFGaussianInf &) --> double
rotateCov(...)
rotateCov(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, ang: float) -> None
 
Rotate the covariance matrix by replacing it by 
 
 
, where 
 
 
 

 
C++: mrpt::poses::CPosePDFGaussianInf::rotateCov(const double) --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPosePDFGaussianInf, file: str) -> bool
 
Save PDF's particles to a text file, containing the 2D pose in the first
 line, then the covariance matrix in next 3 lines. 
 
C++: mrpt::poses::CPosePDFGaussianInf::saveToTextFile(const std::string &) const --> bool

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGaussianInf::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGaussianInf::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
cov_inv
mean

Static methods inherited from CPosePDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPosePDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPosePDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool) -> None
 
3. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool, compute_df_du: bool) -> None
 
This static method computes the pose composition Jacobians, with these
           formulas:
                
 
 
 
 
 
 
 
 
 
 
 
          
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &, const bool, const bool) --> void
 
4. jacobiansPoseComposition(x: mrpt::poses::CPosePDFGaussian, u: mrpt::poses::CPosePDFGaussian, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &) --> void

Methods inherited from mrpt.pymrpt.mrpt.rtti.CObject:
duplicateGetSmartPtr(...)
duplicateGetSmartPtr(self: mrpt.pymrpt.mrpt.rtti.CObject) -> mrpt.pymrpt.mrpt.rtti.CObject
 
Makes a deep copy of the object and returns a smart pointer to it 
 
C++: mrpt::rtti::CObject::duplicateGetSmartPtr() const --> class std::shared_ptr<class mrpt::rtti::CObject>

Methods inherited from mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t:
getCovariance(...)
getCovariance(*args, **kwargs)
Overloaded function.
 
1. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixDynamic<double> &) const --> void
 
2. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance(class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
 
3. getCovariance(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt::math::CMatrixFixed<double, 3ul, 3ul>
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovariance() const --> class mrpt::math::CMatrixFixed<double, 3, 3>
getCovarianceDynAndMean(...)
getCovarianceDynAndMean(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t, cov: mrpt::math::CMatrixDynamic<double>, mean_point: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceDynAndMean(class mrpt::math::CMatrixDynamic<double> &, class mrpt::poses::CPose2D &) const --> void
getCovarianceEntropy(...)
getCovarianceEntropy(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> float
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getCovarianceEntropy() const --> double
getMeanVal(...)
getMeanVal(self: mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t) -> mrpt.pymrpt.mrpt.poses.CPose2D
 
C++: mrpt::math::CProbabilityDensityFunction<mrpt::poses::CPose2D, 3>::getMeanVal() const --> class mrpt::poses::CPose2D

Static methods inherited from pybind11_builtins.pybind11_object:
__new__(*args, **kwargs) from pybind11_builtins.pybind11_type
Create and return a new object.  See help(type) for accurate signature.

 
class CPosePDFGrid(CPosePDF, CPose2DGridTemplate_double_t)
    Declares a class that represents a Probability Distribution
   function (PDF) of a 2D pose (x,y,phi).
  This class implements that PDF using a 3D grid.
 
 
CPose2DCPosePDF, CPose2DGridTemplate
 
 
Method resolution order:
CPosePDFGrid
CPosePDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t
CPose2DGridTemplate_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGrid::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float) -> None
 
doc
 
3. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float) -> None
 
doc
 
4. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float, arg2: float) -> None
 
doc
 
5. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float, arg2: float, arg3: float) -> None
 
doc
 
6. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float) -> None
 
doc
 
7. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float) -> None
 
doc
 
8. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: float, arg1: float, arg2: float, arg3: float, arg4: float, arg5: float, arg6: float) -> None
 
doc
 
9. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, xMin: float, xMax: float, yMin: float, yMax: float, resolutionXY: float, resolutionPhi: float, phiMin: float, phiMax: float) -> None
 
10. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> None
 
11. __init__(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, arg0: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, : mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> mrpt.pymrpt.mrpt.poses.CPosePDFGrid
 
C++: mrpt::poses::CPosePDFGrid::operator=(const class mrpt::poses::CPosePDFGrid &) --> class mrpt::poses::CPosePDFGrid &
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion of 2 densities (In the grid representation this becomes
 a pointwise multiplication) 
 
C++: mrpt::poses::CPosePDFGrid::bayesianFusion(const class mrpt::poses::CPosePDF &, const class mrpt::poses::CPosePDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, newReferenceBase: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
this = p (+) this. This can be used to convert a PDF from local
 coordinates to global, providing the point (newReferenceBase) from which
   "to project" the current pdf. Result PDF substituted the currently
 stored one in the object. 
 
C++: mrpt::poses::CPosePDFGrid::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGrid::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between particles
 and gaussian representations) 
 
C++: mrpt::poses::CPosePDFGrid::copyFrom(const class mrpt::poses::CPosePDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, outPart: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Draws a single sample from the distribution (WARNING: weights are
 assumed to be normalized!) 
 
C++: mrpt::poses::CPosePDFGrid::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> Tuple[mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t, mrpt.pymrpt.mrpt.poses.CPose2D]
 
C++: mrpt::poses::CPosePDFGrid::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPose2D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, mean_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPosePDFGrid::getMean(class mrpt::poses::CPose2D &) const --> void
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF 
 
C++: mrpt::poses::CPosePDFGrid::inverse(class mrpt::poses::CPosePDF &) const --> void
normalize(...)
normalize(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> None
 
Normalizes the PDF, such as all cells sum the unity. 
 
C++: mrpt::poses::CPosePDFGrid::normalize() --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid, dataFile: str) -> bool
 
Save the contents of the 3D grid in one file, as a vertical
 concatenation of rectangular matrix for the different "PHI" discrete
 levels, and the size in X,Y,and PHI in another file named
 "<filename>_dims.txt". 
 
 false on error 
 
C++: mrpt::poses::CPosePDFGrid::saveToTextFile(const std::string &) const --> bool
uniformDistribution(...)
uniformDistribution(self: mrpt.pymrpt.mrpt.poses.CPosePDFGrid) -> None
 
Assigns the same value to all the cells in the grid, so the sum 1. 
 
C++: mrpt::poses::CPosePDFGrid::uniformDistribution() --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFGrid::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFGrid::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Static methods inherited from CPosePDF:
is_3D(...) from builtins.PyCapsule
is_3D() -> bool
 
C++: mrpt::poses::CPosePDF::is_3D() --> bool
is_PDF(...) from builtins.PyCapsule
is_PDF() -> bool
 
C++: mrpt::poses::CPosePDF::is_PDF() --> bool
jacobiansPoseComposition(...) from builtins.PyCapsule
jacobiansPoseComposition(*args, **kwargs)
Overloaded function.
 
1. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
2. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool) -> None
 
3. jacobiansPoseComposition(x: mrpt.pymrpt.mrpt.poses.CPose2D, u: mrpt.pymrpt.mrpt.poses.CPose2D, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, compute_df_dx: bool, compute_df_du: bool) -> None
 
This static method computes the pose composition Jacobians, with these
           formulas:
                
 
 
 
 
 
 
 
 
 
 
 
          
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPose2D &, const class mrpt::poses::CPose2D &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3> &, const bool, const bool) --> void
 
4. jacobiansPoseComposition(x: mrpt::poses::CPosePDFGaussian, u: mrpt::poses::CPosePDFGaussian, df_dx: mrpt::math::CMatrixFixed<double, 3ul, 3ul>, df_du: mrpt::math::CMatrixFixed<double, 3ul, 3ul>) -> None
 
C++: mrpt::poses::CPosePDF::jacobiansPoseComposition(const class mrpt::poses::CPosePDFGaussian &, const class mrpt::poses::CPosePDFGaussian &, class mrpt::math::CMatrixFixed<double, 3, 3> &, class mrpt::math::CMatrixFixed<double, 3, 3>&n