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

Bindings for mrpt::slam namespace

 
Classes
       
mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t(pybind11_builtins.pybind11_object)
CRangeBearingKFSLAM2D
mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t(pybind11_builtins.pybind11_object)
CRangeBearingKFSLAM
mrpt.pymrpt.mrpt.bayes.CRejectionSamplingCapable_mrpt_poses_CPose2D_mrpt_bayes_particle_storage_mode_POINTER_t(pybind11_builtins.pybind11_object)
CRejectionSamplingRangeOnlyLocalization
mrpt.pymrpt.mrpt.config.CLoadableOptions(pybind11_builtins.pybind11_object)
TKLDParams
mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles(mrpt.pymrpt.mrpt.poses.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)
CMonteCarloLocalization3D(mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t)
mrpt.pymrpt.mrpt.poses.CPosePDFParticles(mrpt.pymrpt.mrpt.poses.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)
CMonteCarloLocalization2D(mrpt.pymrpt.mrpt.poses.CPosePDFParticles, PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t)
mrpt.pymrpt.mrpt.serialization.CSerializable(mrpt.pymrpt.mrpt.rtti.CObject)
CIncrementalMapPartitioner
mrpt.pymrpt.mrpt.system.CObserver(pybind11_builtins.pybind11_object)
COccupancyGridMapFeatureExtractor
pybind11_builtins.pybind11_object(builtins.object)
CMetricMapBuilder
CMetricMapBuilderICP
CMetricMapBuilderRBPF
CMetricMapsAlignmentAlgorithm
CGridMapAligner
CICP
PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t
PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t
CMonteCarloLocalization2D(mrpt.pymrpt.mrpt.poses.CPosePDFParticles, PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t)
PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t
CMonteCarloLocalization3D(mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t)
TDataAssociationMethod
TDataAssociationMetric
TDataAssociationResults
TICPAlgorithm
TICPCovarianceMethod
TMetricMapAlignmentResult
TMonteCarloLocalizationParams
map_keyframe_t
similarity_method_t

 
class CGridMapAligner(CMetricMapsAlignmentAlgorithm)
    A class for aligning two multi-metric maps (with an occupancy grid maps and
a points map, at least) based on features extraction and matching.
The matching pose is returned as a Sum of Gaussians (poses::CPosePDFSOG).
 
 This class can use three methods (see options.methodSelection):
  - amCorrelation: "Brute-force" correlation of the two maps over a
2D+orientation grid of possible 2D poses.
  - amRobustMatch: Detection of features + RANSAC matching
  - amModifiedRANSAC: Detection of features + modified multi-hypothesis
RANSAC matching as described in was reported in the paper
https://www.mrpt.org/Paper%3AOccupancy_Grid_Matching
 
See CGridMapAligner::Align for more instructions.
 
 
CMetricMapsAlignmentAlgorithm
 
 
Method resolution order:
CGridMapAligner
CMetricMapsAlignmentAlgorithm
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CGridMapAligner) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CGridMapAligner, arg0: mrpt.pymrpt.mrpt.slam.CGridMapAligner) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CGridMapAligner, arg0: mrpt.pymrpt.mrpt.slam.CGridMapAligner) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CGridMapAligner, : mrpt.pymrpt.mrpt.slam.CGridMapAligner) -> mrpt.pymrpt.mrpt.slam.CGridMapAligner
 
C++: mrpt::slam::CGridMapAligner::operator=(const class mrpt::slam::CGridMapAligner &) --> class mrpt::slam::CGridMapAligner &

Data descriptors defined here:
options

Data and other attributes defined here:
TAlignerMethod = <class 'mrpt.pymrpt.mrpt.slam.CGridMapAligner.TAlignerMethod'>
TConfigParams = <class 'mrpt.pymrpt.mrpt.slam.CGridMapAligner.TConfigParams'>
The ICP algorithm configuration data
TReturnInfo = <class 'mrpt.pymrpt.mrpt.slam.CGridMapAligner.TReturnInfo'>
The ICP algorithm return information.
amCorrelation = <TAlignerMethod.amCorrelation: 1>
amModifiedRANSAC = <TAlignerMethod.amModifiedRANSAC: 2>
amRobustMatch = <TAlignerMethod.amRobustMatch: 0>

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 CICP(CMetricMapsAlignmentAlgorithm)
    Several implementations of ICP (Iterative closest point) algorithms for
aligning two point maps or a point map wrt a grid map.
 
 CICP::AlignPDF() or CICP::Align() are the two main entry points of the
algorithm.
 
 To choose among existing ICP algorithms or customizing their parameters, see
CICP::TConfigParams and the member 
 
 There exists an extension of the original ICP algorithm that provides
multihypotheses-support for the correspondences, and which generates a
Sum-of-Gaussians (SOG)
   PDF as output. See mrpt::tfest::se2_l2_robust()
 
For further details on the implemented methods, check the web:
  https://www.mrpt.org/Iterative_Closest_Point_(ICP)_and_other_matching_algorithms
 
 For a paper explaining some of the basic equations, see for example:
  J. Martinez, J. Gonzalez, J. Morales, A. Mandow, A. Garcia-Cerezo,
  "Mobile robot motion estimation by 2D scan matching with genetic and
iterative closest point algorithms",
   Journal of Field Robotics, vol. 23, no. 1, pp. 21-34, 2006. (
http://babel.isa.uma.es/~jlblanco/papers/martinez2006gil.pdf )
 
 
CMetricMapsAlignmentAlgorithm
 
 
Method resolution order:
CICP
CMetricMapsAlignmentAlgorithm
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CICP) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CICP, icpParams: mrpt::slam::CICP::TConfigParams) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CICP, arg0: mrpt.pymrpt.mrpt.slam.CICP) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.slam.CICP, arg0: mrpt.pymrpt.mrpt.slam.CICP) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CICP, : mrpt.pymrpt.mrpt.slam.CICP) -> mrpt.pymrpt.mrpt.slam.CICP
 
C++: mrpt::slam::CICP::operator=(const class mrpt::slam::CICP &) --> class mrpt::slam::CICP &

Data descriptors defined here:
options

Data and other attributes defined here:
TConfigParams = <class 'mrpt.pymrpt.mrpt.slam.CICP.TConfigParams'>
The ICP algorithm configuration data
TReturnInfo = <class 'mrpt.pymrpt.mrpt.slam.CICP.TReturnInfo'>
The ICP algorithm return information

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 CIncrementalMapPartitioner(mrpt.pymrpt.mrpt.serialization.CSerializable)
    Finds partitions in metric maps based on N-cut graph partition theory.
 
 
Method resolution order:
CIncrementalMapPartitioner
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.slam.CIncrementalMapPartitioner) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::slam::CIncrementalMapPartitioner::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, arg0: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, arg0: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> None
addMapFrame(...)
addMapFrame(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, frame: mrpt.pymrpt.mrpt.obs.CSensoryFrame, robotPose3D: mrpt.pymrpt.mrpt.poses.CPose3DPDF) -> int
 
Insert a new keyframe to the graph.
 
 Call this method each time a new observation is added to the map/graph.
 Afterwards, call updatePartitions() to get the updated partitions.
 
 
 The sensed data
 
 
 An estimation of the robot global pose.
 
 
 The index of the new pose in the graph, which can be used to
 refer to this pose in the future.
 
 
 updatePartitions
 
C++: mrpt::slam::CIncrementalMapPartitioner::addMapFrame(const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3DPDF &) --> uint32_t
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, : mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner
 
C++: mrpt::slam::CIncrementalMapPartitioner::operator=(const class mrpt::slam::CIncrementalMapPartitioner &) --> class mrpt::slam::CIncrementalMapPartitioner &
changeCoordinatesOrigin(...)
changeCoordinatesOrigin(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, newOrigin: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Change the coordinate origin of all stored poses
 
 Used for consistency with future new poses to enter in the system.
 
C++: mrpt::slam::CIncrementalMapPartitioner::changeCoordinatesOrigin(const class mrpt::poses::CPose3D &) --> void
changeCoordinatesOriginPoseIndex(...)
changeCoordinatesOriginPoseIndex(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, newOriginPose: int) -> None
 
The new origin is given by the index of the pose that is to
 become the new origin.
 
C++: mrpt::slam::CIncrementalMapPartitioner::changeCoordinatesOriginPoseIndex(unsigned int) --> void
clear(...)
clear(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> None
 
C++: mrpt::slam::CIncrementalMapPartitioner::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::slam::CIncrementalMapPartitioner::clone() const --> class mrpt::rtti::CObject *
getAdjacencyMatrix(...)
getAdjacencyMatrix(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> mrpt.pymrpt.mrpt.math.CMatrixDynamic_double_t
 
Return a const ref to the internal adjacency matrix.  
 
C++: mrpt::slam::CIncrementalMapPartitioner::getAdjacencyMatrix() const --> const class mrpt::math::CMatrixDynamic<double> &
getNodesCount(...)
getNodesCount(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> int
 
Get the total node count currently in the internal map/graph. 
 
C++: mrpt::slam::CIncrementalMapPartitioner::getNodesCount() --> size_t
getSequenceOfFrames(...)
getSequenceOfFrames(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner) -> mrpt.pymrpt.mrpt.maps.CSimpleMap
 
Access to the sequence of Sensory Frames 
 
C++: mrpt::slam::CIncrementalMapPartitioner::getSequenceOfFrames() --> class mrpt::maps::CSimpleMap *
setSimilarityMethod(...)
setSimilarityMethod(*args, **kwargs)
Overloaded function.
 
1. setSimilarityMethod(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, method: mrpt.pymrpt.mrpt.slam.similarity_method_t) -> None
 
Select the similarity method to use for newly inserted keyframes 
 
C++: mrpt::slam::CIncrementalMapPartitioner::setSimilarityMethod(enum mrpt::slam::similarity_method_t) --> void
 
2. setSimilarityMethod(self: mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner, func: std::function<double (mrpt::slam::map_keyframe_t const&, mrpt::slam::map_keyframe_t const&, mrpt::poses::CPose3D const&)>) -> None
 
Sets a custom function for the similarity of new keyframes 
 
C++: mrpt::slam::CIncrementalMapPartitioner::setSimilarityMethod(class std::function<double (const struct mrpt::slam::map_keyframe_t &, const struct mrpt::slam::map_keyframe_t &, const class mrpt::poses::CPose3D &)>) --> void

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

Data descriptors defined here:
options

Data and other attributes defined here:
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner.TOptions'>
Configuration parameters

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 CMetricMapBuilder(pybind11_builtins.pybind11_object)
    This virtual class is the base for SLAM implementations. See derived classes
for more information.
 
 
CMetricMap
 
 
Method resolution order:
CMetricMapBuilder
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> None
clear(...)
clear(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> None
 
Clear all elements of the maps, and reset localization to (0,0,0deg). 
 
C++: mrpt::slam::CMetricMapBuilder::clear() --> void
enableMapUpdating(...)
enableMapUpdating(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, enable: bool) -> None
 
Enables or disables the map updating (default state is enabled) 
 
C++: mrpt::slam::CMetricMapBuilder::enableMapUpdating(bool) --> void
getCurrentPoseEstimation(...)
getCurrentPoseEstimation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
Returns a copy of the current best pose estimation as a pose PDF. 
 
C++: mrpt::slam::CMetricMapBuilder::getCurrentPoseEstimation() const --> class std::shared_ptr<class mrpt::poses::CPose3DPDF>
getCurrentlyBuiltMap(...)
getCurrentlyBuiltMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, out_map: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
Fills "out_map" with the set of "poses"-"sensory-frames", thus the so
 far built map. 
 
C++: mrpt::slam::CMetricMapBuilder::getCurrentlyBuiltMap(class mrpt::maps::CSimpleMap &) const --> void
getCurrentlyBuiltMapSize(...)
getCurrentlyBuiltMapSize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> int
 
Returns just how many sensory-frames are stored in the currently build
 map. 
 
C++: mrpt::slam::CMetricMapBuilder::getCurrentlyBuiltMapSize() --> unsigned int
getCurrentlyBuiltMetricMap(...)
getCurrentlyBuiltMetricMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> mrpt.pymrpt.mrpt.maps.CMultiMetricMap
 
Returns the map built so far. NOTE that for efficiency a pointer to the
 internal object is passed, DO NOT delete nor modify the object in any
 way, if desired, make a copy of ir with "clone()". 
 
C++: mrpt::slam::CMetricMapBuilder::getCurrentlyBuiltMetricMap() const --> const class mrpt::maps::CMultiMetricMap &
initialize(...)
initialize(*args, **kwargs)
Overloaded function.
 
1. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> None
 
2. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
3. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap, x0: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Initialize the method, starting with a known location PDF "x0"(if
 supplied, set to nullptr to left unmodified) and a given fixed, past map.
 
C++: mrpt::slam::CMetricMapBuilder::initialize(const class mrpt::maps::CSimpleMap &, const class mrpt::poses::CPosePDF *) --> void
loadCurrentMapFromFile(...)
loadCurrentMapFromFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
Load map (mrpt::maps::CSimpleMap) from a ".simplemap" file 
 
C++: mrpt::slam::CMetricMapBuilder::loadCurrentMapFromFile(const std::string &) --> void
processActionObservation(...)
processActionObservation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Process a new action and observations pair to update this map: See the
description of the class at the top of this page to see a more complete
description.
  
 
 The estimation of the incremental pose change in the robot
pose.
        
 
 The set of observations that robot senses at the new
pose.
 
C++: mrpt::slam::CMetricMapBuilder::processActionObservation(class mrpt::obs::CActionCollection &, class mrpt::obs::CSensoryFrame &) --> void
saveCurrentEstimationToImage(...)
saveCurrentEstimationToImage(*args, **kwargs)
Overloaded function.
 
1. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, file: str) -> None
 
2. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, file: str, formatEMF_BMP: bool) -> None
 
A useful method for debugging: the current map (and/or poses) estimation
 is dumped to an image file.
 
 
 The output file name
 
 
 Output format = true:EMF, false:BMP
 
C++: mrpt::slam::CMetricMapBuilder::saveCurrentEstimationToImage(const std::string &, bool) --> void
saveCurrentMapToFile(...)
saveCurrentMapToFile(*args, **kwargs)
Overloaded function.
 
1. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
2. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str, compressGZ: bool) -> None
 
Save map (mrpt::maps::CSimpleMap) to a ".simplemap" file. 
 
C++: mrpt::slam::CMetricMapBuilder::saveCurrentMapToFile(const std::string &, bool) const --> void

Data and other attributes defined here:
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilder.TOptions'>
Options for the algorithm

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 CMetricMapBuilderICP(CMetricMapBuilder)
    A class for very simple 2D SLAM based on ICP. This is a non-probabilistic
pose tracking algorithm.
   Map are stored as in files as binary dumps of "mrpt::maps::CSimpleMap"
objects. The methods are
         thread-safe.
 
 
Method resolution order:
CMetricMapBuilderICP
CMetricMapBuilder
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP) -> None
getCurrentPoseEstimation(...)
getCurrentPoseEstimation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
Returns a copy of the current best pose estimation as a pose PDF.
 
C++: mrpt::slam::CMetricMapBuilderICP::getCurrentPoseEstimation() const --> class std::shared_ptr<class mrpt::poses::CPose3DPDF>
getCurrentlyBuiltMap(...)
getCurrentlyBuiltMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, out_map: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
Fills "out_map" with the set of "poses"-"sensory-frames", thus the so
 far built map 
 
C++: mrpt::slam::CMetricMapBuilderICP::getCurrentlyBuiltMap(class mrpt::maps::CSimpleMap &) const --> void
getCurrentlyBuiltMapSize(...)
getCurrentlyBuiltMapSize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP) -> int
 
Returns just how many sensory-frames are stored in the currently build
 map 
 
C++: mrpt::slam::CMetricMapBuilderICP::getCurrentlyBuiltMapSize() --> unsigned int
getCurrentlyBuiltMetricMap(...)
getCurrentlyBuiltMetricMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP) -> mrpt.pymrpt.mrpt.maps.CMultiMetricMap
 
C++: mrpt::slam::CMetricMapBuilderICP::getCurrentlyBuiltMetricMap() const --> const class mrpt::maps::CMultiMetricMap &
initialize(...)
initialize(*args, **kwargs)
Overloaded function.
 
1. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP) -> None
 
2. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
3. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap, x0: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Initialize the method, starting with a known location PDF "x0"(if
 supplied, set to nullptr to left unmodified) and a given fixed, past map.
  This method MUST be called if using the default constructor, after
 loading the configuration into ICP_options. In particular,
 TConfigParams::mapInitializers
 
C++: mrpt::slam::CMetricMapBuilderICP::initialize(const class mrpt::maps::CSimpleMap &, const class mrpt::poses::CPosePDF *) --> void
processActionObservation(...)
processActionObservation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, action: mrpt.pymrpt.mrpt.obs.CActionCollection, in_SF: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Appends a new action and observations to update this map: See the
description of the class at the top of this page to see a more complete
description.
  
 
 The estimation of the incremental pose change in the robot
pose.
        
 
 The set of observations that robot senses at the new pose.
 See params in CMetricMapBuilder::options and
CMetricMapBuilderICP::ICP_options
 
 
 processObservation
 
C++: mrpt::slam::CMetricMapBuilderICP::processActionObservation(class mrpt::obs::CActionCollection &, class mrpt::obs::CSensoryFrame &) --> void
processObservation(...)
processObservation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, obs: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
The main method of this class: Process one odometry or sensor
         observation.
                The new entry point of the algorithm (the old one  was
         processActionObservation, which now is a wrapper to
          this method).
 See params in CMetricMapBuilder::options and
         CMetricMapBuilderICP::ICP_options
 
C++: mrpt::slam::CMetricMapBuilderICP::processObservation(const class std::shared_ptr<class mrpt::obs::CObservation> &) --> void
saveCurrentEstimationToImage(...)
saveCurrentEstimationToImage(*args, **kwargs)
Overloaded function.
 
1. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, file: str) -> None
 
2. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, file: str, formatEMF_BMP: bool) -> None
 
A useful method for debugging: the current map (and/or poses) estimation
 is dumped to an image file.
 
 
 The output file name
 
 
 Output format = true:EMF, false:BMP
 
C++: mrpt::slam::CMetricMapBuilderICP::saveCurrentEstimationToImage(const std::string &, bool) --> void
setCurrentMapFile(...)
setCurrentMapFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP, mapFile: str) -> None
 
Sets the "current map file", thus that map will be loaded if it exists
 or a new one will be created if it does not, and the updated map will be
 save to that file when destroying the object.
 
C++: mrpt::slam::CMetricMapBuilderICP::setCurrentMapFile(const char *) --> void

Data descriptors defined here:
ICP_options
ICP_params

Data and other attributes defined here:
TConfigParams = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilderICP.TConfigParams'>
Algorithm configuration params

Methods inherited from CMetricMapBuilder:
clear(...)
clear(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder) -> None
 
Clear all elements of the maps, and reset localization to (0,0,0deg). 
 
C++: mrpt::slam::CMetricMapBuilder::clear() --> void
enableMapUpdating(...)
enableMapUpdating(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, enable: bool) -> None
 
Enables or disables the map updating (default state is enabled) 
 
C++: mrpt::slam::CMetricMapBuilder::enableMapUpdating(bool) --> void
loadCurrentMapFromFile(...)
loadCurrentMapFromFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
Load map (mrpt::maps::CSimpleMap) from a ".simplemap" file 
 
C++: mrpt::slam::CMetricMapBuilder::loadCurrentMapFromFile(const std::string &) --> void
saveCurrentMapToFile(...)
saveCurrentMapToFile(*args, **kwargs)
Overloaded function.
 
1. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
2. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str, compressGZ: bool) -> None
 
Save map (mrpt::maps::CSimpleMap) to a ".simplemap" file. 
 
C++: mrpt::slam::CMetricMapBuilder::saveCurrentMapToFile(const std::string &, bool) const --> void

Data and other attributes inherited from CMetricMapBuilder:
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilder.TOptions'>
Options for the algorithm

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 CMetricMapBuilderRBPF(CMetricMapBuilder)
    This class implements a Rao-Blackwelized Particle Filter (RBPF) approach to
 map building (SLAM).
   Internally, the list of particles, each containing a hypothesis for the
 robot path plus its associated
    metric map, is stored in an object of class CMultiMetricMapPDF.
 
  This class processes robot actions and observations sequentially (through
 the method CMetricMapBuilderRBPF::processActionObservation)
   and exploits the generic design of metric map classes in MRPT to deal with
 any number and combination of maps simultaneously: the likelihood
   of observations is the product of the likelihood in the different maps,
 etc.
 
   A number of particle filter methods are implemented as well, by selecting
 the appropriate values in TConstructionOptions::PF_options.
   Not all the PF algorithms are implemented for all kinds of maps.
 
  For an example of usage, check the application "rbpf-slam", in
 "apps/RBPF-SLAM". See also the 
* href="http://www.mrpt.org/Application:RBPF-SLAM" >wiki page.
 
  
 Since MRPT 0.7.2, the new variables
 "localizeLinDistance,localizeAngDistance" are introduced to provide a way to
 update the robot pose at a different rate than the map is updated.
  
 
 Since MRPT 0.7.1 the semantics of the parameters
 "insertionLinDistance" and "insertionAngDistance" changes: the entire RBFP is
 now NOT updated unless odometry increments surpass the threshold (previously,
 only the map was NOT updated). This is done to gain efficiency.
  
 
 Since MRPT 0.6.2 this class implements full 6D SLAM. Previous versions
 worked in 2D + heading only.
 
 
 CMetricMap
 
 
Method resolution order:
CMetricMapBuilderRBPF
CMetricMapBuilder
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, initializationOptions: mrpt::slam::CMetricMapBuilderRBPF::TConstructionOptions) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, src: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF
 
Copy Operator. 
 
C++: mrpt::slam::CMetricMapBuilderRBPF::operator=(const class mrpt::slam::CMetricMapBuilderRBPF &) --> class mrpt::slam::CMetricMapBuilderRBPF &
clear(...)
clear(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> None
 
Clear all elements of the maps.
 
C++: mrpt::slam::CMetricMapBuilderRBPF::clear() --> void
drawCurrentEstimationToImage(...)
drawCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, img: mrpt.pymrpt.mrpt.img.CCanvas) -> None
 
A useful method for debugging: draws the current map and path hypotheses
 to a CCanvas  
 
C++: mrpt::slam::CMetricMapBuilderRBPF::drawCurrentEstimationToImage(class mrpt::img::CCanvas *) --> void
getCurrentJointEntropy(...)
getCurrentJointEntropy(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> float
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentJointEntropy() --> double
getCurrentMostLikelyPath(...)
getCurrentMostLikelyPath(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, outPath: List[mrpt.pymrpt.mrpt.math.TPose3D]) -> None
 
Returns the current most-likely path estimation (the path associated to
 the most likely particle).
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentMostLikelyPath(class std::deque<struct mrpt::math::TPose3D> &) const --> void
getCurrentPoseEstimation(...)
getCurrentPoseEstimation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> mrpt.pymrpt.mrpt.poses.CPose3DPDF
 
Returns a copy of the current best pose estimation as a pose PDF.
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentPoseEstimation() const --> class std::shared_ptr<class mrpt::poses::CPose3DPDF>
getCurrentlyBuiltMap(...)
getCurrentlyBuiltMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, out_map: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
Fills "out_map" with the set of "poses"-"sensory-frames", thus the so
 far built map.
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentlyBuiltMap(class mrpt::maps::CSimpleMap &) const --> void
getCurrentlyBuiltMapSize(...)
getCurrentlyBuiltMapSize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> int
 
Returns just how many sensory-frames are stored in the currently build
 map.
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentlyBuiltMapSize() --> unsigned int
getCurrentlyBuiltMetricMap(...)
getCurrentlyBuiltMetricMap(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> mrpt.pymrpt.mrpt.maps.CMultiMetricMap
 
Returns the map built so far. NOTE that for efficiency a pointer to the
 internal object is passed, DO NOT delete nor modify the object in any
 way, if desired, make a copy of ir with "clone()".
 
C++: mrpt::slam::CMetricMapBuilderRBPF::getCurrentlyBuiltMetricMap() const --> const class mrpt::maps::CMultiMetricMap &
initialize(...)
initialize(*args, **kwargs)
Overloaded function.
 
1. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF) -> None
 
2. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap) -> None
 
3. initialize(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, initialMap: mrpt.pymrpt.mrpt.maps.CSimpleMap, x0: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Initialize the method, starting with a known location PDF "x0"(if
 supplied, set to nullptr to left unmodified) and a given fixed, past map.
 
C++: mrpt::slam::CMetricMapBuilderRBPF::initialize(const class mrpt::maps::CSimpleMap &, const class mrpt::poses::CPosePDF *) --> void
processActionObservation(...)
processActionObservation(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Appends a new action and observations to update this map: See the
description of the class at the top of this page to see a more complete
description.
  
 
 The incremental 2D pose change in the robot pose. This
value is deterministic.
        
 
 The set of observations that robot senses at the new
pose.
  Statistics will be saved to statsLastIteration
 
C++: mrpt::slam::CMetricMapBuilderRBPF::processActionObservation(class mrpt::obs::CActionCollection &, class mrpt::obs::CSensoryFrame &) --> void
saveCurrentEstimationToImage(...)
saveCurrentEstimationToImage(*args, **kwargs)
Overloaded function.
 
1. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, file: str) -> None
 
2. saveCurrentEstimationToImage(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, file: str, formatEMF_BMP: bool) -> None
 
A useful method for debugging: the current map (and/or poses) estimation
 is dumped to an image file.
 
 
 The output file name
 
 
 Output format = true:EMF, false:BMP
 
C++: mrpt::slam::CMetricMapBuilderRBPF::saveCurrentEstimationToImage(const std::string &, bool) --> void
saveCurrentPathEstimationToTextFile(...)
saveCurrentPathEstimationToTextFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF, fil: str) -> None
 
A logging utility: saves the current path estimation for each particle
 in a text file (a row per particle, each 3-column-entry is a set
 [x,y,phi], respectively).
 
C++: mrpt::slam::CMetricMapBuilderRBPF::saveCurrentPathEstimationToTextFile(const std::string &) --> void

Data descriptors defined here:
m_statsLastIteration
mapPDF

Data and other attributes defined here:
TConstructionOptions = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF.TConstructionOptions'>
Options for building a CMetricMapBuilderRBPF object, passed to the
constructor.
TStats = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilderRBPF.TStats'>
This structure will hold stats after each execution of
processActionObservation

Methods inherited from CMetricMapBuilder:
enableMapUpdating(...)
enableMapUpdating(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, enable: bool) -> None
 
Enables or disables the map updating (default state is enabled) 
 
C++: mrpt::slam::CMetricMapBuilder::enableMapUpdating(bool) --> void
loadCurrentMapFromFile(...)
loadCurrentMapFromFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
Load map (mrpt::maps::CSimpleMap) from a ".simplemap" file 
 
C++: mrpt::slam::CMetricMapBuilder::loadCurrentMapFromFile(const std::string &) --> void
saveCurrentMapToFile(...)
saveCurrentMapToFile(*args, **kwargs)
Overloaded function.
 
1. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str) -> None
 
2. saveCurrentMapToFile(self: mrpt.pymrpt.mrpt.slam.CMetricMapBuilder, fileName: str, compressGZ: bool) -> None
 
Save map (mrpt::maps::CSimpleMap) to a ".simplemap" file. 
 
C++: mrpt::slam::CMetricMapBuilder::saveCurrentMapToFile(const std::string &, bool) const --> void

Data and other attributes inherited from CMetricMapBuilder:
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CMetricMapBuilder.TOptions'>
Options for the algorithm

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 CMetricMapsAlignmentAlgorithm(pybind11_builtins.pybind11_object)
    A base class for any algorithm able of maps alignment. There are two methods
  depending on an PDF or a single 2D Pose value is available as initial guess
for the methods.
 
 
CPointsMap
 
 
Method resolution order:
CMetricMapsAlignmentAlgorithm
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CMetricMapsAlignmentAlgorithm, : mrpt.pymrpt.mrpt.slam.CMetricMapsAlignmentAlgorithm) -> mrpt.pymrpt.mrpt.slam.CMetricMapsAlignmentAlgorithm
 
C++: mrpt::slam::CMetricMapsAlignmentAlgorithm::operator=(const class mrpt::slam::CMetricMapsAlignmentAlgorithm &) --> class mrpt::slam::CMetricMapsAlignmentAlgorithm &

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 CMonteCarloLocalization2D(mrpt.pymrpt.mrpt.poses.CPosePDFParticles, PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t)
    Declares a class that represents a Probability Density Function (PDF) over a
2D pose (x,y,phi), using a set of weighted samples.
 
 This class also implements particle filtering for robot localization. See
the MRPT
  application "app/pf-localization" for an example of usage.
 
 
CMonteCarloLocalization3D, CPose2D, CPosePDF, CPoseGaussianPDF,
CParticleFilterCapable
 
 
Method resolution order:
CMonteCarloLocalization2D
mrpt.pymrpt.mrpt.poses.CPosePDFParticles
mrpt.pymrpt.mrpt.poses.CPosePDF
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.math.CProbabilityDensityFunction_mrpt_poses_CPose2D_3UL_t
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.bayes.CParticleFilterCapable
mrpt.pymrpt.mrpt.Stringifyable
PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
PF_SLAM_computeObservationLikelihoodForParticle(...)
PF_SLAM_computeObservationLikelihoodForParticle(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, particleIndexForMap: int, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluate the observation likelihood for one particle at a given location
 
C++: mrpt::slam::CMonteCarloLocalization2D::PF_SLAM_computeObservationLikelihoodForParticle(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D &) const --> double
PF_SLAM_implementation_custom_update_particle_with_new_pose(...)
PF_SLAM_implementation_custom_update_particle_with_new_pose(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, particleData: mrpt.pymrpt.mrpt.math.TPose2D, newPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::slam::CMonteCarloLocalization2D::PF_SLAM_implementation_custom_update_particle_with_new_pose(struct mrpt::math::TPose2D *, const struct mrpt::math::TPose3D &) const --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, M: int) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, : mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D) -> mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D
 
C++: mrpt::slam::CMonteCarloLocalization2D::operator=(const class mrpt::slam::CMonteCarloLocalization2D &) --> class mrpt::slam::CMonteCarloLocalization2D &
getLastPose(...)
getLastPose(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, i: int, is_valid_pose: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
                @{ 
 
 Return the robot pose for the i'th particle. is_valid is
 always true in this class. 
 
C++: mrpt::slam::CMonteCarloLocalization2D::getLastPose(size_t, bool &) const --> struct mrpt::math::TPose3D
getVisualization(...)
getVisualization(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D) -> mrpt.pymrpt.mrpt.opengl.CSetOfObjects
 
Returns a 3D representation of this PDF.
 
 
 Needs the mrpt-opengl library, and using
 mrpt::opengl::CSetOfObjects::Ptr as template argument.
 
C++: mrpt::slam::CMonteCarloLocalization2D::getVisualization() const --> class std::shared_ptr<class mrpt::opengl::CSetOfObjects>
prediction_and_update_pfAuxiliaryPFOptimal(...)
prediction_and_update_pfAuxiliaryPFOptimal(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization2D::prediction_and_update_pfAuxiliaryPFOptimal(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
prediction_and_update_pfAuxiliaryPFStandard(...)
prediction_and_update_pfAuxiliaryPFStandard(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization2D::prediction_and_update_pfAuxiliaryPFStandard(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
prediction_and_update_pfStandardProposal(...)
prediction_and_update_pfStandardProposal(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization2D::prediction_and_update_pfStandardProposal(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
resetUniformFreeSpace(...)
resetUniformFreeSpace(*args, **kwargs)
Overloaded function.
 
1. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D) -> None
 
2. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float) -> None
 
3. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int) -> None
 
4. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float) -> None
 
5. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float, x_max: float) -> None
 
6. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float, x_max: float, y_min: float) -> None
 
7. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float, x_max: float, y_min: float, y_max: float) -> None
 
8. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float, x_max: float, y_min: float, y_max: float, phi_min: float) -> None
 
9. resetUniformFreeSpace(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization2D, theMap: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, freeCellsThreshold: float, particlesCount: int, x_min: float, x_max: float, y_min: float, y_max: float, phi_min: float, phi_max: float) -> None
 
Reset the PDF to an uniformly distributed one, but only in the
 free-space
   of a given 2D occupancy-grid-map. Orientation is randomly generated in
 the whole 2*PI range.
 
 
 The occupancy grid map
 
 
 The minimum free-probability to consider a
 cell as empty (default is 0.7)
 
 
 If set to -1 the number of m_particles remains
 unchanged.
 
 
 The limits of the area to look for free cells.
 
 
 The limits of the area to look for free cells.
 
 
 The limits of the area to look for free cells.
 
 
 The limits of the area to look for free cells.
 
 
 The limits of the area to look for free cells.
 
 
 The limits of the area to look for free cells.
  
 
 resetDeterm32inistic
 
 
 std::exception On any error (no free cell found in map,
 map=nullptr, etc...)
 
C++: mrpt::slam::CMonteCarloLocalization2D::resetUniformFreeSpace(class mrpt::maps::COccupancyGridMap2D *, const double, const int, const double, const double, const double, const double, const double, const double) --> void

Data descriptors defined here:
options

Methods inherited from mrpt.pymrpt.mrpt.poses.CPosePDFParticles:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::poses::CPosePDFParticles::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, Ap: mrpt.pymrpt.mrpt.math.TPose2D) -> None
 
Appends (pose-composition) a given pose "p" to each particle
 
C++: mrpt::poses::CPosePDFParticles::operator+=(const struct mrpt::math::TPose2D &) --> void
append(...)
append(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, o: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> None
 
Appends (add to the list) a set of m_particles to the existing ones, and
 then normalize weights.
 
C++: mrpt::poses::CPosePDFParticles::append(class mrpt::poses::CPosePDFParticles &) --> void
asString(...)
asString(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> str
 
C++: mrpt::poses::CPosePDFParticles::asString() const --> std::string
bayesianFusion(...)
bayesianFusion(*args, **kwargs)
Overloaded function.
 
1. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
2. bayesianFusion(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, p1: mrpt.pymrpt.mrpt.poses.CPosePDF, p2: mrpt.pymrpt.mrpt.poses.CPosePDF, minMahalanobisDistToDrop: float) -> None
 
Bayesian fusion.
 
C++: mrpt::poses::CPosePDFParticles::bayesianFusion(const class mrpt::poses::CPosePDF &, const class mrpt::poses::CPosePDF &, const double) --> void
changeCoordinatesReference(...)
changeCoordinatesReference(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, 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::CPosePDFParticles::changeCoordinatesReference(const class mrpt::poses::CPose3D &) --> void
clear(...)
clear(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> None
 
Free all the memory associated to m_particles, and set the number of
 parts = 0 
 
C++: mrpt::poses::CPosePDFParticles::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::poses::CPosePDFParticles::clone() const --> class mrpt::rtti::CObject *
copyFrom(...)
copyFrom(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Copy operator, translating if necesary (for example, between m_particles
 and gaussian representations)
 
C++: mrpt::poses::CPosePDFParticles::copyFrom(const class mrpt::poses::CPosePDF &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, outPart: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Draws a single sample from the distribution (WARNING: weights are
 assumed to be normalized!)
 
C++: mrpt::poses::CPosePDFParticles::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
evaluatePDF_parzen(...)
evaluatePDF_parzen(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, x: float, y: float, phi: float, stdXY: float, stdPhi: float) -> float
 
Evaluates the PDF at a given arbitrary point as reconstructed by a
 Parzen window.
 
 
 saveParzenPDFToTextFile
 
C++: mrpt::poses::CPosePDFParticles::evaluatePDF_parzen(const double, const double, const double, const double, const double) const --> double
getCovarianceAndMean(...)
getCovarianceAndMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> Tuple[mrpt::math::CMatrixFixed<double, 3ul, 3ul>, mrpt.pymrpt.mrpt.poses.CPose2D]
 
C++: mrpt::poses::CPosePDFParticles::getCovarianceAndMean() const --> class std::tuple<class mrpt::math::CMatrixFixed<double, 3, 3>, class mrpt::poses::CPose2D>
getMean(...)
getMean(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, mean_pose: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
C++: mrpt::poses::CPosePDFParticles::getMean(class mrpt::poses::CPose2D &) const --> void
getMostLikelyParticle(...)
getMostLikelyParticle(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> mrpt.pymrpt.mrpt.math.TPose2D
 
Returns the particle with the highest weight.
 
C++: mrpt::poses::CPosePDFParticles::getMostLikelyParticle() const --> struct mrpt::math::TPose2D
getParticlePose(...)
getParticlePose(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, i: int) -> mrpt.pymrpt.mrpt.math.TPose2D
 
Returns the pose of the i'th particle.
 
C++: mrpt::poses::CPosePDFParticles::getParticlePose(size_t) const --> struct mrpt::math::TPose2D
inverse(...)
inverse(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, o: mrpt.pymrpt.mrpt.poses.CPosePDF) -> None
 
Returns a new PDF such as: NEW_PDF = (0,0,0) - THIS_PDF
 
C++: mrpt::poses::CPosePDFParticles::inverse(class mrpt::poses::CPosePDF &) const --> void
resetDeterministic(...)
resetDeterministic(*args, **kwargs)
Overloaded function.
 
1. resetDeterministic(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, location: mrpt.pymrpt.mrpt.math.TPose2D) -> None
 
2. resetDeterministic(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, location: mrpt.pymrpt.mrpt.math.TPose2D, 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, CMonteCarloLocalization2D::resetUniformFreeSpace,
 resetAroundSetOfPoses
 
C++: mrpt::poses::CPosePDFParticles::resetDeterministic(const struct mrpt::math::TPose2D &, size_t) --> void
resetUniform(...)
resetUniform(*args, **kwargs)
Overloaded function.
 
1. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, x_min: float, x_max: float, y_min: float, y_max: float) -> None
 
2. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, x_min: float, x_max: float, y_min: float, y_max: float, phi_min: float) -> None
 
3. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, x_min: float, x_max: float, y_min: float, y_max: float, phi_min: float, phi_max: float) -> None
 
4. resetUniform(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, x_min: float, x_max: float, y_min: float, y_max: float, phi_min: float, phi_max: float, particlesCount: int) -> None
 
Reset the PDF to an uniformly distributed one, inside of the defined
 2D area `[x_min,x_max]x[y_min,y_max]` (in meters) and for
 orientations `[phi_min, phi_max]` (in radians).
 
 
 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, CMonteCarloLocalization2D::resetUniformFreeSpace,
 resetAroundSetOfPoses
 
C++: mrpt::poses::CPosePDFParticles::resetUniform(const double, const double, const double, const double, const double, const double, const int) --> void
saveParzenPDFToTextFile(...)
saveParzenPDFToTextFile(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, fileName: str, x_min: float, x_max: float, y_min: float, y_max: float, phi: float, stepSizeXY: float, stdXY: float, stdPhi: float) -> None
 
Save a text file (compatible with matlab) representing the 2D evaluation
 of the PDF as reconstructed by a Parzen window.
 
 
 evaluatePDF_parzen
 
C++: mrpt::poses::CPosePDFParticles::saveParzenPDFToTextFile(const char *, const double, const double, const double, const double, const double, const double, const double, const double) const --> void
saveToTextFile(...)
saveToTextFile(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles, file: str) -> bool
 
Save PDF's m_particles to a text file. In each line it will go: "x y phi
 weight"
 
C++: mrpt::poses::CPosePDFParticles::saveToTextFile(const std::string &) const --> bool
size(...)
size(self: mrpt.pymrpt.mrpt.poses.CPosePDFParticles) -> int
 
Get the m_particles count (equivalent to "particlesCount")
 
C++: mrpt::poses::CPosePDFParticles::size() const --> size_t

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

Static methods inherited from mrpt.pymrpt.mrpt.poses.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

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

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

Methods inherited from mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t:
ESS(...)
ESS(*args, **kwargs)
Overloaded function.
 
1. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE>>>::ESS() const --> double
 
2. ESS(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> mrpt::poses::CPosePDFParticles
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE>>>::derived() --> class mrpt::poses::CPosePDFParticles &
fastDrawSample(...)
fastDrawSample(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE>>>::getW(size_t) const --> double
 
2. getW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> float
 
2. normalizeWeights(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, out_max_log_w: float) -> float
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, 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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> int
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE>>>::particlesCount() const --> size_t
 
2. particlesCount(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int, w: float) -> None
 
C++: mrpt::bayes::CParticleFilterDataImpl<mrpt::poses::CPosePDFParticles, std::deque<mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE>>>::setW(size_t, double) --> void
 
2. setW(self: mrpt.pymrpt.mrpt.bayes.CParticleFilterDataImpl_mrpt_poses_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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_CPosePDFParticles_std_deque_mrpt_bayes_CProbabilityParticle_mrpt_math_TPose2D_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

Methods inherited from PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t:
PF_SLAM_implementation_doWeHaveValidObservations(...)
PF_SLAM_implementation_doWeHaveValidObservations(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, particles: List[mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, (mrpt::bayes::particle_storage_mode)0>], sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_doWeHaveValidObservations(const class std::deque<struct mrpt::bayes::CProbabilityParticle<struct mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE> > &, const class mrpt::obs::CSensoryFrame *) const --> bool
PF_SLAM_implementation_skipRobotMovement(...)
PF_SLAM_implementation_skipRobotMovement(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_skipRobotMovement() 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 CMonteCarloLocalization3D(mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles, PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t)
    Declares a class that represents a Probability Density Function (PDF) over a
3D pose (x,y,phi,yaw,pitch,roll), using a set of weighted samples.
 
 This class also implements particle filtering for robot localization. See
the MRPT
  application "app/pf-localization" for an example of usage.
 
 
CMonteCarloLocalization2D, CPose2D, CPosePDF, CPoseGaussianPDF,
CParticleFilterCapable
 
 
Method resolution order:
CMonteCarloLocalization3D
mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles
mrpt.pymrpt.mrpt.poses.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
PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
PF_SLAM_computeObservationLikelihoodForParticle(...)
PF_SLAM_computeObservationLikelihoodForParticle(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, particleIndexForMap: int, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Evaluate the observation likelihood for one particle at a given location
 
C++: mrpt::slam::CMonteCarloLocalization3D::PF_SLAM_computeObservationLikelihoodForParticle(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D &) const --> double
PF_SLAM_implementation_custom_update_particle_with_new_pose(...)
PF_SLAM_implementation_custom_update_particle_with_new_pose(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, particleData: mrpt.pymrpt.mrpt.math.TPose3D, newPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::slam::CMonteCarloLocalization3D::PF_SLAM_implementation_custom_update_particle_with_new_pose(struct mrpt::math::TPose3D *, const struct mrpt::math::TPose3D &) const --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D) -> None
 
doc
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, M: int) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, : mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D) -> mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D
 
C++: mrpt::slam::CMonteCarloLocalization3D::operator=(const class mrpt::slam::CMonteCarloLocalization3D &) --> class mrpt::slam::CMonteCarloLocalization3D &
getLastPose(...)
getLastPose(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, i: int, is_valid_pose: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
                @{ 
 
 Return the robot pose for the i'th particle. is_valid is
 always true in this class. 
 
C++: mrpt::slam::CMonteCarloLocalization3D::getLastPose(size_t, bool &) const --> struct mrpt::math::TPose3D
getVisualization(...)
getVisualization(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D) -> mrpt.pymrpt.mrpt.opengl.CSetOfObjects
 
Returns a 3D representation of this PDF.
 
 
 Needs the mrpt-opengl library, and using
 mrpt::opengl::CSetOfObjects::Ptr as template argument.
 
C++: mrpt::slam::CMonteCarloLocalization3D::getVisualization() const --> class std::shared_ptr<class mrpt::opengl::CSetOfObjects>
prediction_and_update_pfAuxiliaryPFOptimal(...)
prediction_and_update_pfAuxiliaryPFOptimal(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization3D::prediction_and_update_pfAuxiliaryPFOptimal(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
prediction_and_update_pfAuxiliaryPFStandard(...)
prediction_and_update_pfAuxiliaryPFStandard(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization3D::prediction_and_update_pfAuxiliaryPFStandard(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void
prediction_and_update_pfStandardProposal(...)
prediction_and_update_pfStandardProposal(self: mrpt.pymrpt.mrpt.slam.CMonteCarloLocalization3D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions) -> None
 
Update the m_particles, predicting the posterior of robot pose and map
 after a movement command.
  This method has additional configuration parameters in "options".
  Performs the update stage of the RBPF, using the sensed CSensoryFrame:
 
   
 This is a pointer to CActionCollection, containing the
 pose change the robot has been commanded.
   
 
 This must be a pointer to a CSensoryFrame object,
 with robot sensed observations.
 
 
 options
 
C++: mrpt::slam::CMonteCarloLocalization3D::prediction_and_update_pfStandardProposal(const class mrpt::obs::CActionCollection *, const class mrpt::obs::CSensoryFrame *, const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &) --> void

Data descriptors defined here:
options

Methods inherited from mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles:
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
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
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 inherited from mrpt.pymrpt.mrpt.poses.CPose3DPDFParticles:
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 mrpt.pymrpt.mrpt.poses.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

Methods inherited from PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t:
PF_SLAM_implementation_doWeHaveValidObservations(...)
PF_SLAM_implementation_doWeHaveValidObservations(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, particles: List[mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, (mrpt::bayes::particle_storage_mode)0>], sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_doWeHaveValidObservations(const class std::deque<struct mrpt::bayes::CProbabilityParticle<struct mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE> > &, const class mrpt::obs::CSensoryFrame *) const --> bool
PF_SLAM_implementation_skipRobotMovement(...)
PF_SLAM_implementation_skipRobotMovement(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_skipRobotMovement() 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 COccupancyGridMapFeatureExtractor(mrpt.pymrpt.mrpt.system.CObserver)
    A class for detecting features from occupancy grid maps.
  The main method is "COccupancyGridMapFeatureExtractor::extractFeatures()",
which makes use
   of an advanced cache mechanism to avoid redoing work when applied several
times on the same
   occupancy grid maps (unless they changed in the meanwhile).
 
 For an uncached version (which is a static method that can be called
without instantiating COccupancyGridMapFeatureExtractor)
 see COccupancyGridMapFeatureExtractor::uncached_extractFeatures()
 
 
Method resolution order:
COccupancyGridMapFeatureExtractor
mrpt.pymrpt.mrpt.system.CObserver
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor, arg0: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor, arg0: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor, : mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor) -> mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor
 
C++: mrpt::slam::COccupancyGridMapFeatureExtractor::operator=(const class mrpt::slam::COccupancyGridMapFeatureExtractor &) --> class mrpt::slam::COccupancyGridMapFeatureExtractor &
extractFeatures(...)
extractFeatures(self: mrpt.pymrpt.mrpt.slam.COccupancyGridMapFeatureExtractor, grid: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, outMap: mrpt.pymrpt.mrpt.maps.CLandmarksMap, number_of_features: int, descriptors: mrpt.pymrpt.mrpt.vision.TDescriptorType, feat_options: mrpt.pymrpt.mrpt.vision.CFeatureExtraction.TOptions) -> None
 
Computes a set of distinctive landmarks from an occupancy grid, and
 store them (previous content is not erased!) into the given landmarks
 map.
   Landmarks type can be any declared in
 mrpt::vision::CFeatureExtraction::TOptions
 
 
 See the paper "..."
 
 
 uncached_extractFeatures
 
C++: mrpt::slam::COccupancyGridMapFeatureExtractor::extractFeatures(const class mrpt::maps::COccupancyGridMap2D &, class mrpt::maps::CLandmarksMap &, size_t, const enum mrpt::vision::TDescriptorType, const struct mrpt::vision::CFeatureExtraction::TOptions &) --> void

Static methods defined here:
uncached_extractFeatures(...) from builtins.PyCapsule
uncached_extractFeatures(grid: mrpt.pymrpt.mrpt.maps.COccupancyGridMap2D, outMap: mrpt.pymrpt.mrpt.maps.CLandmarksMap, number_of_features: int, descriptors: mrpt.pymrpt.mrpt.vision.TDescriptorType, feat_options: mrpt.pymrpt.mrpt.vision.CFeatureExtraction.TOptions) -> None
 
Computes a set of distinctive landmarks from an occupancy grid, and
 store them (previous content is not erased!) into the given landmarks
 map.
   Landmarks type can be any declared in
 mrpt::vision::CFeatureExtraction::TOptions
 
 
 See the paper "..."
 
 
 uncached_extractFeatures
 
C++: mrpt::slam::COccupancyGridMapFeatureExtractor::uncached_extractFeatures(const class mrpt::maps::COccupancyGridMap2D &, class mrpt::maps::CLandmarksMap &, size_t, const enum mrpt::vision::TDescriptorType, const struct mrpt::vision::CFeatureExtraction::TOptions &) --> void

Methods inherited from mrpt.pymrpt.mrpt.system.CObserver:
observeBegin(...)
observeBegin(self: mrpt.pymrpt.mrpt.system.CObserver, obj: mrpt.pymrpt.mrpt.system.CObservable) -> None
 
Starts the subscription of this observer to the given object.  
 
 observeEnd  
 
C++: mrpt::system::CObserver::observeBegin(class mrpt::system::CObservable &) --> void
observeEnd(...)
observeEnd(self: mrpt.pymrpt.mrpt.system.CObserver, obj: mrpt.pymrpt.mrpt.system.CObservable) -> None
 
Ends the subscription of this observer to the given object (note that
           there is no need to call this method, since the destruction of the first
           of observer/observed will put an end to the process
                
 
 observeBegin  
 
C++: mrpt::system::CObserver::observeEnd(class mrpt::system::CObservable &) --> void

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 CRangeBearingKFSLAM(mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t)
    An implementation of EKF-based SLAM with range-bearing sensors, odometry, a
SE(3) robot pose, and 3D landmarks.
The main method is processActionObservation() which processes pairs of
actions/observations.
 
The state vector comprises: 3D robot position, a quaternion for its
attitude, and the 3D landmarks in the map.
 
The front-end application [kf-slam](page_app_kf-slam.html) is based on this
class.
 
For the theory behind this implementation, see the technical report:
 
 
 
An implementation for 2D and SE(2) is in CRangeBearingKFSLAM2D
 
 
Method resolution order:
CRangeBearingKFSLAM
mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, arg0: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, arg0: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> None
getAs3DObject(...)
getAs3DObject(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, outObj: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Returns a 3D representation of the landmarks in the map and the robot 3D
 position according to the current filter state.
  
 
 
         
 
C++: mrpt::slam::CRangeBearingKFSLAM::getAs3DObject(class std::shared_ptr<class mrpt::opengl::CSetOfObjects> &) const --> void
getCurrentRobotPose(...)
getCurrentRobotPose(*args, **kwargs)
Overloaded function.
 
1. getCurrentRobotPose(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, out_robotPose: mrpt.pymrpt.mrpt.poses.CPose3DQuatPDFGaussian) -> None
 
Returns the mean & the 7x7 covariance matrix of the robot 6D pose (with
 rotation as a quaternion).
 
 
 getCurrentState, getCurrentRobotPoseMean
 
C++: mrpt::slam::CRangeBearingKFSLAM::getCurrentRobotPose(class mrpt::poses::CPose3DQuatPDFGaussian &) const --> void
 
2. getCurrentRobotPose(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, out_robotPose: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> None
 
Returns the mean & the 6x6 covariance matrix of the robot 6D pose (with
 rotation as 3 angles).
 
 
 getCurrentState
 
C++: mrpt::slam::CRangeBearingKFSLAM::getCurrentRobotPose(class mrpt::poses::CPose3DPDFGaussian &) const --> void
getCurrentRobotPoseMean(...)
getCurrentRobotPoseMean(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> mrpt.pymrpt.mrpt.poses.CPose3DQuat
 
Get the current robot pose mean, as a 3D+quaternion pose.
 
 
 getCurrentRobotPose
 
C++: mrpt::slam::CRangeBearingKFSLAM::getCurrentRobotPoseMean() const --> class mrpt::poses::CPose3DQuat
getLastDataAssociation(...)
getLastDataAssociation(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> mrpt::slam::CRangeBearingKFSLAM::TDataAssocInfo
 
Returns a read-only reference to the information on the last
 data-association 
 
C++: mrpt::slam::CRangeBearingKFSLAM::getLastDataAssociation() const --> const struct mrpt::slam::CRangeBearingKFSLAM::TDataAssocInfo &
loadOptions(...)
loadOptions(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, ini: mrpt.pymrpt.mrpt.config.CConfigFileBase) -> None
 
Load options from a ini-like file/text
 
C++: mrpt::slam::CRangeBearingKFSLAM::loadOptions(const class mrpt::config::CConfigFileBase &) --> void
mapPartitionOptions(...)
mapPartitionOptions(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> mrpt.pymrpt.mrpt.slam.CIncrementalMapPartitioner.TOptions
 
Provides access to the parameters of the map partitioning algorithm.
 
C++: mrpt::slam::CRangeBearingKFSLAM::mapPartitionOptions() --> struct mrpt::slam::CIncrementalMapPartitioner::TOptions *
processActionObservation(...)
processActionObservation(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, action: mrpt.pymrpt.mrpt.obs.CActionCollection, SF: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Process one new action and observations to update the map and robot pose
estimate. See the description of the class at the top of this page.
  
 
 May contain odometry
        
 
 The set of observations, must contain at least one
CObservationBearingRange
 
C++: mrpt::slam::CRangeBearingKFSLAM::processActionObservation(class std::shared_ptr<class mrpt::obs::CActionCollection> &, class std::shared_ptr<class mrpt::obs::CSensoryFrame> &) --> void
reconsiderPartitionsNow(...)
reconsiderPartitionsNow(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> None
 
The partitioning of the entire map is recomputed again.
  Only when options.doPartitioningExperiment = true.
  This can be used after changing the parameters of the partitioning
 method.
  After this method, you can call getLastPartitionLandmarks.
 
 
 getLastPartitionLandmarks
 
C++: mrpt::slam::CRangeBearingKFSLAM::reconsiderPartitionsNow() --> void
reset(...)
reset(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM) -> None
 
Reset the state of the SLAM filter: The map is emptied and the robot put
 back to (0,0,0). 
 
C++: mrpt::slam::CRangeBearingKFSLAM::reset() --> void
saveMapAndPath2DRepresentationAsMATLABFile(...)
saveMapAndPath2DRepresentationAsMATLABFile(*args, **kwargs)
Overloaded function.
 
1. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, fil: str) -> None
 
2. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, fil: str, stdCount: float) -> None
 
3. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, fil: str, stdCount: float, styleLandmarks: str) -> None
 
4. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, fil: str, stdCount: float, styleLandmarks: str, stylePath: str) -> None
 
5. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM, fil: str, stdCount: float, styleLandmarks: str, stylePath: str, styleRobot: str) -> None
 
Save the current state of the filter (robot pose & map) to a MATLAB
 script which displays all the elements in 2D
 
C++: mrpt::slam::CRangeBearingKFSLAM::saveMapAndPath2DRepresentationAsMATLABFile(const std::string &, float, const std::string &, const std::string &, const std::string &) const --> void

Data descriptors defined here:
options

Data and other attributes defined here:
TDataAssocInfo = <class 'mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM.TDataAssocInfo'>
Information for data-association:
 
 
getLastDataAssociation
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM.TOptions'>
The options for the algorithm

Methods inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t:
OnNewLandmarkAddedToMap(...)
OnNewLandmarkAddedToMap(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t, in_obsIdx: int, in_idxNewFeat: int) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::OnNewLandmarkAddedToMap(size_t, size_t) --> void
OnNormalizeStateVector(...)
OnNormalizeStateVector(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::OnNormalizeStateVector() --> void
OnPostIteration(...)
OnPostIteration(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::OnPostIteration() --> void
getLandmarkCov(...)
getLandmarkCov(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t, idx: int, feat_cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_3UL_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::getLandmarkCov(size_t, class mrpt::math::CMatrixFixed<double, 3, 3> &) const --> void
getLandmarkMean(...)
getLandmarkMean(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t, idx: int, feat: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_3UL_1UL_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::getLandmarkMean(size_t, class mrpt::math::CMatrixFixed<double, 3, 1> &) const --> void
getNumberOfLandmarksInTheMap(...)
getNumberOfLandmarksInTheMap(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::getNumberOfLandmarksInTheMap() const --> size_t
getProfiler(...)
getProfiler(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> mrpt.pymrpt.mrpt.system.CTimeLogger
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::getProfiler() --> class mrpt::system::CTimeLogger &
getStateVectorLength(...)
getStateVectorLength(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::getStateVectorLength() const --> size_t
internal_getPkk(...)
internal_getPkk(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> mrpt.pymrpt.mrpt.math.CMatrixDynamic_double_t
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::internal_getPkk() --> class mrpt::math::CMatrixDynamic<double> &
internal_getXkk(...)
internal_getXkk(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> mrpt::math::CVectorDynamic<double>
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::internal_getXkk() --> class mrpt::math::CVectorDynamic<double> &
isMapEmpty(...)
isMapEmpty(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t) -> bool
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::isMapEmpty() const --> bool

Static methods inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t:
get_action_size(...) from builtins.PyCapsule
get_action_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::get_action_size() --> size_t
get_feature_size(...) from builtins.PyCapsule
get_feature_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::get_feature_size() --> size_t
get_observation_size(...) from builtins.PyCapsule
get_observation_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::get_observation_size() --> size_t
get_vehicle_size(...) from builtins.PyCapsule
get_vehicle_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<7, 3, 3, 7>::get_vehicle_size() --> size_t

Readonly properties inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_7UL_3UL_3UL_7UL_double_t:
KF_options

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 CRangeBearingKFSLAM2D(mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t)
    An implementation of EKF-based SLAM with range-bearing sensors, odometry,
SE(2) robot pose, and 2D landmarks.
The main method is processActionObservation() which processes pairs of
actions/observations.
 
The following front-end applications are based on this class:
       - [2d-slam-demo](app_2d-slam-demo.html)
       - [kf-slam](page_app_kf-slam.html)
 
 
CRangeBearingKFSLAM
 
 
Method resolution order:
CRangeBearingKFSLAM2D
mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, arg0: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, arg0: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D) -> None
getAs3DObject(...)
getAs3DObject(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, outObj: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Returns a 3D representation of the landmarks in the map and the robot 3D
 position according to the current filter state.
  
 
 
         
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::getAs3DObject(class std::shared_ptr<class mrpt::opengl::CSetOfObjects> &) const --> void
getCurrentRobotPose(...)
getCurrentRobotPose(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, out_robotPose: mrpt.pymrpt.mrpt.poses.CPosePDFGaussian) -> None
 
Returns the mean & 3x3 covariance matrix of the robot 2D pose.
 
 
 getCurrentState
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::getCurrentRobotPose(class mrpt::poses::CPosePDFGaussian &) const --> void
getLastDataAssociation(...)
getLastDataAssociation(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D) -> mrpt::slam::CRangeBearingKFSLAM2D::TDataAssocInfo
 
Returns a read-only reference to the information on the last
 data-association 
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::getLastDataAssociation() const --> const struct mrpt::slam::CRangeBearingKFSLAM2D::TDataAssocInfo &
loadOptions(...)
loadOptions(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, ini: mrpt.pymrpt.mrpt.config.CConfigFileBase) -> None
 
Load options from a ini-like file/text
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::loadOptions(const class mrpt::config::CConfigFileBase &) --> void
processActionObservation(...)
processActionObservation(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, action: mrpt.pymrpt.mrpt.obs.CActionCollection, SF: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Process one new action and observations to update the map and robot pose
estimate. See the description of the class at the top of this page.
  
 
 May contain odometry
        
 
 The set of observations, must contain at least one
CObservationBearingRange
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::processActionObservation(class std::shared_ptr<class mrpt::obs::CActionCollection> &, class std::shared_ptr<class mrpt::obs::CSensoryFrame> &) --> void
reset(...)
reset(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D) -> None
 
Reset the state of the SLAM filter: The map is emptied and the robot put
 back to (0,0,0). 
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::reset() --> void
saveMapAndPath2DRepresentationAsMATLABFile(...)
saveMapAndPath2DRepresentationAsMATLABFile(*args, **kwargs)
Overloaded function.
 
1. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, fil: str) -> None
 
2. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, fil: str, stdCount: float) -> None
 
3. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, fil: str, stdCount: float, styleLandmarks: str) -> None
 
4. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, fil: str, stdCount: float, styleLandmarks: str, stylePath: str) -> None
 
5. saveMapAndPath2DRepresentationAsMATLABFile(self: mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D, fil: str, stdCount: float, styleLandmarks: str, stylePath: str, styleRobot: str) -> None
 
Save the current state of the filter (robot pose & map) to a MATLAB
 script which displays all the elements in 2D
 
C++: mrpt::slam::CRangeBearingKFSLAM2D::saveMapAndPath2DRepresentationAsMATLABFile(const std::string &, float, const std::string &, const std::string &, const std::string &) const --> void

Data descriptors defined here:
options

Data and other attributes defined here:
TDataAssocInfo = <class 'mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D.TDataAssocInfo'>
Information for data-association:
 
 
getLastDataAssociation
TOptions = <class 'mrpt.pymrpt.mrpt.slam.CRangeBearingKFSLAM2D.TOptions'>
The options for the algorithm

Methods inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t:
OnNewLandmarkAddedToMap(...)
OnNewLandmarkAddedToMap(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t, in_obsIdx: int, in_idxNewFeat: int) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::OnNewLandmarkAddedToMap(size_t, size_t) --> void
OnNormalizeStateVector(...)
OnNormalizeStateVector(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::OnNormalizeStateVector() --> void
OnPostIteration(...)
OnPostIteration(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::OnPostIteration() --> void
getLandmarkCov(...)
getLandmarkCov(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t, idx: int, feat_cov: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_2UL_2UL_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::getLandmarkCov(size_t, class mrpt::math::CMatrixFixed<double, 2, 2> &) const --> void
getLandmarkMean(...)
getLandmarkMean(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t, idx: int, feat: mrpt.pymrpt.mrpt.math.CMatrixFixed_double_2UL_1UL_t) -> None
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::getLandmarkMean(size_t, class mrpt::math::CMatrixFixed<double, 2, 1> &) const --> void
getNumberOfLandmarksInTheMap(...)
getNumberOfLandmarksInTheMap(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::getNumberOfLandmarksInTheMap() const --> size_t
getProfiler(...)
getProfiler(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> mrpt.pymrpt.mrpt.system.CTimeLogger
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::getProfiler() --> class mrpt::system::CTimeLogger &
getStateVectorLength(...)
getStateVectorLength(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::getStateVectorLength() const --> size_t
internal_getPkk(...)
internal_getPkk(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> mrpt.pymrpt.mrpt.math.CMatrixDynamic_double_t
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::internal_getPkk() --> class mrpt::math::CMatrixDynamic<double> &
internal_getXkk(...)
internal_getXkk(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> mrpt::math::CVectorDynamic<double>
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::internal_getXkk() --> class mrpt::math::CVectorDynamic<double> &
isMapEmpty(...)
isMapEmpty(self: mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t) -> bool
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::isMapEmpty() const --> bool

Static methods inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t:
get_action_size(...) from builtins.PyCapsule
get_action_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::get_action_size() --> size_t
get_feature_size(...) from builtins.PyCapsule
get_feature_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::get_feature_size() --> size_t
get_observation_size(...) from builtins.PyCapsule
get_observation_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::get_observation_size() --> size_t
get_vehicle_size(...) from builtins.PyCapsule
get_vehicle_size() -> int
 
C++: mrpt::bayes::CKalmanFilterCapable<3, 2, 2, 3>::get_vehicle_size() --> size_t

Readonly properties inherited from mrpt.pymrpt.mrpt.bayes.CKalmanFilterCapable_3UL_2UL_2UL_3UL_double_t:
KF_options

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 CRejectionSamplingRangeOnlyLocalization(mrpt.pymrpt.mrpt.bayes.CRejectionSamplingCapable_mrpt_poses_CPose2D_mrpt_bayes_particle_storage_mode_POINTER_t)
    An implementation of rejection sampling for generating 2D robot pose from
range-only measurements within a landmarks (beacons) map.
   Before calling the method "rejectionSampling" to generate the samples, you
must call "setParams".
   It is assumed a planar scenario, where the robot is at a fixed height
(default=0).
 
 
bayes::CRejectionSamplingCapable
 
 
Method resolution order:
CRejectionSamplingRangeOnlyLocalization
mrpt.pymrpt.mrpt.bayes.CRejectionSamplingCapable_mrpt_poses_CPose2D_mrpt_bayes_particle_storage_mode_POINTER_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, arg0: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, arg0: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, : mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization) -> mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization
 
C++: mrpt::slam::CRejectionSamplingRangeOnlyLocalization::operator=(const class mrpt::slam::CRejectionSamplingRangeOnlyLocalization &) --> class mrpt::slam::CRejectionSamplingRangeOnlyLocalization &
setParams(...)
setParams(*args, **kwargs)
Overloaded function.
 
1. setParams(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, beaconsMap: mrpt.pymrpt.mrpt.maps.CLandmarksMap, observation: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, sigmaRanges: float, oldPose: mrpt.pymrpt.mrpt.poses.CPose2D) -> bool
 
2. setParams(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, beaconsMap: mrpt.pymrpt.mrpt.maps.CLandmarksMap, observation: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, sigmaRanges: float, oldPose: mrpt.pymrpt.mrpt.poses.CPose2D, robot_z: float) -> bool
 
3. setParams(self: mrpt.pymrpt.mrpt.slam.CRejectionSamplingRangeOnlyLocalization, beaconsMap: mrpt.pymrpt.mrpt.maps.CLandmarksMap, observation: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, sigmaRanges: float, oldPose: mrpt.pymrpt.mrpt.poses.CPose2D, robot_z: float, autoCheckAngleRanges: bool) -> bool
 
The parameters used in the generation of random samples:
 
 
 The map containing the N beacons (indexed by their
 "beacon ID"s). Only the mean 3D position of the beacons is used, the
 covariance is ignored.
 
 
 An observation with, at least ONE range measurement.
 
 
 The standard deviation of the "range measurement
 noise".
 
 
 The height of the robot on the floor (default=0). Note
 that the beacon sensor on the robot may be at a different height,
 according to data within the observation object.
 
 
 Whether to make a simple check for potential
 good angles from the beacons to generate samples (disable to speed-up the
 preparation vs. making slower the drawn).
  This method fills out the member "m_dataPerBeacon".
 
 
 true if at least ONE beacon has been successfully loaded, false
 otherwise. In this case do not call "rejectionSampling" or an exception
 will be launch, since there is no information to generate samples.
 
C++: mrpt::slam::CRejectionSamplingRangeOnlyLocalization::setParams(const class mrpt::maps::CLandmarksMap &, const class mrpt::obs::CObservationBeaconRanges &, float, const class mrpt::poses::CPose2D &, float, bool) --> 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 PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
PF_SLAM_computeObservationLikelihoodForParticle(...)
PF_SLAM_computeObservationLikelihoodForParticle(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, particleIndexForMap: int, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::PF_SLAM_computeObservationLikelihoodForParticle(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D &) const --> double
PF_SLAM_implementation_custom_update_particle_with_new_pose(...)
PF_SLAM_implementation_custom_update_particle_with_new_pose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, particleData: mrpt::maps::CRBPFParticleData, newPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::PF_SLAM_implementation_custom_update_particle_with_new_pose(class mrpt::maps::CRBPFParticleData *, const struct mrpt::math::TPose3D &) const --> void
PF_SLAM_implementation_doWeHaveValidObservations(...)
PF_SLAM_implementation_doWeHaveValidObservations(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, particles: List[mrpt::bayes::CProbabilityParticle<mrpt::maps::CRBPFParticleData, (mrpt::bayes::particle_storage_mode)1>], sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::PF_SLAM_implementation_doWeHaveValidObservations(const class std::deque<struct mrpt::bayes::CProbabilityParticle<class mrpt::maps::CRBPFParticleData, mrpt::bayes::particle_storage_mode::POINTER> > &, const class mrpt::obs::CSensoryFrame *) const --> bool
PF_SLAM_implementation_skipRobotMovement(...)
PF_SLAM_implementation_skipRobotMovement(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::PF_SLAM_implementation_skipRobotMovement() const --> bool
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, arg0: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, : mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t) -> mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::operator=(const class mrpt::slam::PF_implementation<class mrpt::maps::CRBPFParticleData, class mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER> &) --> class mrpt::slam::PF_implementation<class mrpt::maps::CRBPFParticleData, class mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER> &
getLastPose(...)
getLastPose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_maps_CRBPFParticleData_mrpt_maps_CMultiMetricMapPDF_mrpt_bayes_particle_storage_mode_POINTER_t, i: int, is_valid_pose: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::slam::PF_implementation<mrpt::maps::CRBPFParticleData, mrpt::maps::CMultiMetricMapPDF, mrpt::bayes::particle_storage_mode::POINTER>::getLastPose(size_t, bool &) const --> struct mrpt::math::TPose3D

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 PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
PF_SLAM_computeObservationLikelihoodForParticle(...)
PF_SLAM_computeObservationLikelihoodForParticle(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, particleIndexForMap: int, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_computeObservationLikelihoodForParticle(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D &) const --> double
PF_SLAM_implementation_custom_update_particle_with_new_pose(...)
PF_SLAM_implementation_custom_update_particle_with_new_pose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, particleData: mrpt.pymrpt.mrpt.math.TPose2D, newPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_custom_update_particle_with_new_pose(struct mrpt::math::TPose2D *, const struct mrpt::math::TPose3D &) const --> void
PF_SLAM_implementation_doWeHaveValidObservations(...)
PF_SLAM_implementation_doWeHaveValidObservations(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, particles: List[mrpt::bayes::CProbabilityParticle<mrpt::math::TPose2D, (mrpt::bayes::particle_storage_mode)0>], sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_doWeHaveValidObservations(const class std::deque<struct mrpt::bayes::CProbabilityParticle<struct mrpt::math::TPose2D, mrpt::bayes::particle_storage_mode::VALUE> > &, const class mrpt::obs::CSensoryFrame *) const --> bool
PF_SLAM_implementation_skipRobotMovement(...)
PF_SLAM_implementation_skipRobotMovement(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_skipRobotMovement() const --> bool
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, arg0: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, : mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t) -> mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::operator=(const class mrpt::slam::PF_implementation<struct mrpt::math::TPose2D, class mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE> &) --> class mrpt::slam::PF_implementation<struct mrpt::math::TPose2D, class mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE> &
getLastPose(...)
getLastPose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose2D_mrpt_slam_CMonteCarloLocalization2D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int, is_valid_pose: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose2D, mrpt::slam::CMonteCarloLocalization2D, mrpt::bayes::particle_storage_mode::VALUE>::getLastPose(size_t, bool &) const --> struct mrpt::math::TPose3D

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 PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
PF_SLAM_computeObservationLikelihoodForParticle(...)
PF_SLAM_computeObservationLikelihoodForParticle(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, PF_options: mrpt.pymrpt.mrpt.bayes.CParticleFilter.TParticleFilterOptions, particleIndexForMap: int, observation: mrpt.pymrpt.mrpt.obs.CSensoryFrame, x: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_computeObservationLikelihoodForParticle(const struct mrpt::bayes::CParticleFilter::TParticleFilterOptions &, size_t, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D &) const --> double
PF_SLAM_implementation_custom_update_particle_with_new_pose(...)
PF_SLAM_implementation_custom_update_particle_with_new_pose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, particleData: mrpt.pymrpt.mrpt.math.TPose3D, newPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_custom_update_particle_with_new_pose(struct mrpt::math::TPose3D *, const struct mrpt::math::TPose3D &) const --> void
PF_SLAM_implementation_doWeHaveValidObservations(...)
PF_SLAM_implementation_doWeHaveValidObservations(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, particles: List[mrpt::bayes::CProbabilityParticle<mrpt::math::TPose3D, (mrpt::bayes::particle_storage_mode)0>], sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_doWeHaveValidObservations(const class std::deque<struct mrpt::bayes::CProbabilityParticle<struct mrpt::math::TPose3D, mrpt::bayes::particle_storage_mode::VALUE> > &, const class mrpt::obs::CSensoryFrame *) const --> bool
PF_SLAM_implementation_skipRobotMovement(...)
PF_SLAM_implementation_skipRobotMovement(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> bool
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::PF_SLAM_implementation_skipRobotMovement() const --> bool
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, arg0: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, : mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t) -> mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::operator=(const class mrpt::slam::PF_implementation<struct mrpt::math::TPose3D, class mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE> &) --> class mrpt::slam::PF_implementation<struct mrpt::math::TPose3D, class mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE> &
getLastPose(...)
getLastPose(self: mrpt.pymrpt.mrpt.slam.PF_implementation_mrpt_math_TPose3D_mrpt_slam_CMonteCarloLocalization3D_mrpt_bayes_particle_storage_mode_VALUE_t, i: int, is_valid_pose: bool) -> mrpt.pymrpt.mrpt.math.TPose3D
 
C++: mrpt::slam::PF_implementation<mrpt::math::TPose3D, mrpt::slam::CMonteCarloLocalization3D, mrpt::bayes::particle_storage_mode::VALUE>::getLastPose(size_t, bool &) const --> struct mrpt::math::TPose3D

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 TDataAssociationMethod(pybind11_builtins.pybind11_object)
    
Method resolution order:
TDataAssociationMethod
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMethod) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMethod, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMethod) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMethod, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
assocJCBB = <TDataAssociationMethod.assocJCBB: 1>
assocNN = <TDataAssociationMethod.assocNN: 0>

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 TDataAssociationMetric(pybind11_builtins.pybind11_object)
    
Method resolution order:
TDataAssociationMetric
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMetric) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMetric, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMetric) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationMetric, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
metricML = <TDataAssociationMetric.metricML: 1>
metricMaha = <TDataAssociationMetric.metricMaha: 0>

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 TDataAssociationResults(pybind11_builtins.pybind11_object)
    The results from mrpt::slam::data_association_independent_predictions()
 
 
Method resolution order:
TDataAssociationResults
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationResults) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.TDataAssociationResults, arg0: mrpt.pymrpt.mrpt.slam.TDataAssociationResults) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.TDataAssociationResults, : mrpt.pymrpt.mrpt.slam.TDataAssociationResults) -> mrpt.pymrpt.mrpt.slam.TDataAssociationResults
 
C++: mrpt::slam::TDataAssociationResults::operator=(const struct mrpt::slam::TDataAssociationResults &) --> struct mrpt::slam::TDataAssociationResults &
clear(...)
clear(self: mrpt.pymrpt.mrpt.slam.TDataAssociationResults) -> None
 
C++: mrpt::slam::TDataAssociationResults::clear() --> void

Data descriptors defined here:
associations
distance
indiv_compatibility
indiv_compatibility_counts
indiv_distances
nNodesExploredInJCBB

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 TICPAlgorithm(pybind11_builtins.pybind11_object)
    
Method resolution order:
TICPAlgorithm
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.slam.TICPAlgorithm) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.TICPAlgorithm, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.slam.TICPAlgorithm) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.slam.TICPAlgorithm, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
icpClassic = <TICPAlgorithm.icpClassic: 0>
icpLevenbergMarquardt = <TICPAlgorithm.icpLevenbergMarquardt: 1>

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 TICPCovarianceMethod(pybind11_builtins.pybind11_object)
    
Method resolution order:
TICPCovarianceMethod
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.slam.TICPCovarianceMethod) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.TICPCovarianceMethod, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.slam.TICPCovarianceMethod) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.slam.TICPCovarianceMethod, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
icpCovFiniteDifferences = <TICPCovarianceMethod.icpCovFiniteDifferences: 1>
icpCovLinealMSE = <TICPCovarianceMethod.icpCovLinealMSE: 0>

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 TKLDParams(mrpt.pymrpt.mrpt.config.CLoadableOptions)
    Option set for KLD algorithm.
 
 
Method resolution order:
TKLDParams
mrpt.pymrpt.mrpt.config.CLoadableOptions
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.TKLDParams) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.TKLDParams, arg0: mrpt.pymrpt.mrpt.slam.TKLDParams) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.slam.TKLDParams, arg0: mrpt.pymrpt.mrpt.slam.TKLDParams) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.TKLDParams, : mrpt.pymrpt.mrpt.slam.TKLDParams) -> mrpt.pymrpt.mrpt.slam.TKLDParams
 
C++: mrpt::slam::TKLDParams::operator=(const class mrpt::slam::TKLDParams &) --> class mrpt::slam::TKLDParams &
loadFromConfigFile(...)
loadFromConfigFile(self: mrpt.pymrpt.mrpt.slam.TKLDParams, source: mrpt.pymrpt.mrpt.config.CConfigFileBase, section: str) -> None
 
C++: mrpt::slam::TKLDParams::loadFromConfigFile(const class mrpt::config::CConfigFileBase &, const std::string &) --> void

Data descriptors defined here:
KLD_binSize_PHI
KLD_binSize_XY
KLD_delta
KLD_epsilon
KLD_maxSampleSize
KLD_minSampleSize
KLD_minSamplesPerBin

Methods inherited from mrpt.pymrpt.mrpt.config.CLoadableOptions:
dumpToConsole(...)
dumpToConsole(self: mrpt.pymrpt.mrpt.config.CLoadableOptions) -> None
 
Just like  but sending the text to the console
 (std::cout) 
 
C++: mrpt::config::CLoadableOptions::dumpToConsole() const --> void
loadFromConfigFileName(...)
loadFromConfigFileName(self: mrpt.pymrpt.mrpt.config.CLoadableOptions, config_file: str, section: str) -> None
 
Behaves like loadFromConfigFile, but you can pass directly a file name
 and a temporary CConfigFile object will be created automatically to load
 the file.
 
 
 loadFromConfigFile
 
C++: mrpt::config::CLoadableOptions::loadFromConfigFileName(const std::string &, const std::string &) --> void
saveToConfigFile(...)
saveToConfigFile(self: mrpt.pymrpt.mrpt.config.CLoadableOptions, target: mrpt::config::CConfigFileBase, section: str) -> None
 
This method saves the options to a ".ini"-like file or memory-stored
 string list.
 
 
 loadFromConfigFile, saveToConfigFileName
 
C++: mrpt::config::CLoadableOptions::saveToConfigFile(class mrpt::config::CConfigFileBase &, const std::string &) const --> void
saveToConfigFileName(...)
saveToConfigFileName(self: mrpt.pymrpt.mrpt.config.CLoadableOptions, config_file: str, section: str) -> None
 
Behaves like saveToConfigFile, but you can pass directly a file name and
 a temporary CConfigFile object will be created automatically to save the
 file.
 
 
 saveToConfigFile, loadFromConfigFileName
 
C++: mrpt::config::CLoadableOptions::saveToConfigFileName(const std::string &, const std::string &) const --> void

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 TMetricMapAlignmentResult(pybind11_builtins.pybind11_object)
    Used as base class for other result structures of each particular algorithm
in CMetricMapsAlignmentAlgorithm derived classes.
 
 
Method resolution order:
TMetricMapAlignmentResult
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult, arg0: mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult, : mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult) -> mrpt.pymrpt.mrpt.slam.TMetricMapAlignmentResult
 
C++: mrpt::slam::TMetricMapAlignmentResult::operator=(const struct mrpt::slam::TMetricMapAlignmentResult &) --> struct mrpt::slam::TMetricMapAlignmentResult &

Data descriptors defined here:
executionTime

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 TMonteCarloLocalizationParams(pybind11_builtins.pybind11_object)
    The struct for passing extra simulation parameters to the prediction stage
when running a particle filter.
 
 
Method resolution order:
TMonteCarloLocalizationParams
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams, arg0: mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams, : mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams) -> mrpt.pymrpt.mrpt.slam.TMonteCarloLocalizationParams
 
C++: mrpt::slam::TMonteCarloLocalizationParams::operator=(const struct mrpt::slam::TMonteCarloLocalizationParams &) --> struct mrpt::slam::TMonteCarloLocalizationParams &

Data descriptors defined here:
KLD_params
metricMap
metricMaps

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 map_keyframe_t(pybind11_builtins.pybind11_object)
    Map keyframe, comprising raw observations and they as a metric map.
For use in CIncrementalMapPartitioner
 
 
Method resolution order:
map_keyframe_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.slam.map_keyframe_t) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.slam.map_keyframe_t, arg0: mrpt.pymrpt.mrpt.slam.map_keyframe_t) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.slam.map_keyframe_t, : mrpt.pymrpt.mrpt.slam.map_keyframe_t) -> mrpt.pymrpt.mrpt.slam.map_keyframe_t
 
C++: mrpt::slam::map_keyframe_t::operator=(const struct mrpt::slam::map_keyframe_t &) --> struct mrpt::slam::map_keyframe_t &

Data descriptors defined here:
kf_id
metric_map
raw_observations

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 similarity_method_t(pybind11_builtins.pybind11_object)
    
Method resolution order:
similarity_method_t
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__and__(...)
__and__(self: object, other: object) -> object
__eq__(...)
__eq__(self: object, other: object) -> bool
__ge__(...)
__ge__(self: object, other: object) -> bool
__getstate__(...)
__getstate__(self: object) -> int
__gt__(...)
__gt__(self: object, other: object) -> bool
__hash__(...)
__hash__(self: object) -> int
__index__(...)
__index__(self: mrpt.pymrpt.mrpt.slam.similarity_method_t) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.slam.similarity_method_t, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.slam.similarity_method_t) -> int
__invert__(...)
__invert__(self: object) -> object
__le__(...)
__le__(self: object, other: object) -> bool
__lt__(...)
__lt__(self: object, other: object) -> bool
__ne__(...)
__ne__(self: object, other: object) -> bool
__or__(...)
__or__(self: object, other: object) -> object
__rand__(...)
__rand__(self: object, other: object) -> object
__repr__(...)
__repr__(self: object) -> str
__ror__(...)
__ror__(self: object, other: object) -> object
__rxor__(...)
__rxor__(self: object, other: object) -> object
__setstate__(...)
__setstate__(self: mrpt.pymrpt.mrpt.slam.similarity_method_t, state: int) -> None
__str__ = name(...)
name(self: handle) -> str
__xor__(...)
__xor__(self: object, other: object) -> object

Readonly properties defined here:
__members__
name
name(self: handle) -> str
value

Data and other attributes defined here:
smCUSTOM_FUNCTION = <similarity_method_t.smCUSTOM_FUNCTION: 2>
smMETRIC_MAP_MATCHING = <similarity_method_t.smMETRIC_MAP_MATCHING: 0>
smOBSERVATION_OVERLAP = <similarity_method_t.smOBSERVATION_OVERLAP: 1>

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.

 
Functions
       
observationsOverlap(...) method of builtins.PyCapsule instance
observationsOverlap(*args, **kwargs)
Overloaded function.
 
1. observationsOverlap(o1: mrpt.pymrpt.mrpt.obs.CObservation, o2: mrpt.pymrpt.mrpt.obs.CObservation) -> float
 
2. observationsOverlap(o1: mrpt.pymrpt.mrpt.obs.CObservation, o2: mrpt.pymrpt.mrpt.obs.CObservation, pose_o2_wrt_o1: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Estimates the "overlap" or "matching ratio" of two observations (range
 [0,1]), possibly taking into account their relative positions.
  
 
 This is used in mrpt::slam::CIncrementalMapPartitioner
 
C++: mrpt::slam::observationsOverlap(const class mrpt::obs::CObservation *, const class mrpt::obs::CObservation *, const class mrpt::poses::CPose3D *) --> double
 
3. observationsOverlap(o1: mrpt.pymrpt.mrpt.obs.CObservation, o2: mrpt.pymrpt.mrpt.obs.CObservation) -> float
 
4. observationsOverlap(o1: mrpt.pymrpt.mrpt.obs.CObservation, o2: mrpt.pymrpt.mrpt.obs.CObservation, pose_o2_wrt_o1: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Estimates the "overlap" or "matching ratio" of two observations (range
 [0,1]), possibly taking into account their relative positions.
  
 
 This is used in mrpt::slam::CIncrementalMapPartitioner
 
C++: mrpt::slam::observationsOverlap(const class std::shared_ptr<class mrpt::obs::CObservation> &, const class std::shared_ptr<class mrpt::obs::CObservation> &, const class mrpt::poses::CPose3D *) --> double
 
5. observationsOverlap(sf1: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf2: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> float
 
6. observationsOverlap(sf1: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf2: mrpt.pymrpt.mrpt.obs.CSensoryFrame, pose_sf2_wrt_sf1: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Estimates the "overlap" or "matching ratio" of two set of observations
 (range [0,1]), possibly taking into account their relative positions.
   This method computes the average between each of the observations in each
 SF.
  
 
 This is used in mrpt::slam::CIncrementalMapPartitioner
 
C++: mrpt::slam::observationsOverlap(const class mrpt::obs::CSensoryFrame &, const class mrpt::obs::CSensoryFrame &, const class mrpt::poses::CPose3D *) --> double
 
7. observationsOverlap(sf1: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf2: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> float
 
8. observationsOverlap(sf1: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf2: mrpt.pymrpt.mrpt.obs.CSensoryFrame, pose_sf2_wrt_sf1: mrpt.pymrpt.mrpt.poses.CPose3D) -> float
 
Estimates the "overlap" or "matching ratio" of two set of observations
 (range [0,1]), possibly taking into account their relative positions.
   This method computes the average between each of the observations in each
 SF.
  
 
 This is used in mrpt::slam::CIncrementalMapPartitioner
 
C++: mrpt::slam::observationsOverlap(const class std::shared_ptr<class mrpt::obs::CSensoryFrame> &, const class std::shared_ptr<class mrpt::obs::CSensoryFrame> &, const class mrpt::poses::CPose3D *) --> double

 
Data
        assocJCBB = <TDataAssociationMethod.assocJCBB: 1>
assocNN = <TDataAssociationMethod.assocNN: 0>
icpClassic = <TICPAlgorithm.icpClassic: 0>
icpCovFiniteDifferences = <TICPCovarianceMethod.icpCovFiniteDifferences: 1>
icpCovLinealMSE = <TICPCovarianceMethod.icpCovLinealMSE: 0>
icpLevenbergMarquardt = <TICPAlgorithm.icpLevenbergMarquardt: 1>
metricML = <TDataAssociationMetric.metricML: 1>
metricMaha = <TDataAssociationMetric.metricMaha: 0>
smCUSTOM_FUNCTION = <similarity_method_t.smCUSTOM_FUNCTION: 2>
smMETRIC_MAP_MATCHING = <similarity_method_t.smMETRIC_MAP_MATCHING: 0>
smOBSERVATION_OVERLAP = <similarity_method_t.smOBSERVATION_OVERLAP: 1>