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

Bindings for mrpt::obs namespace

 
Modules
       
mrpt.pymrpt.mrpt.obs.gnss
mrpt.pymrpt.mrpt.obs.stock_observations

 
Classes
       
mrpt.pymrpt.mrpt.Stringifyable(pybind11_builtins.pybind11_object)
CObservation(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
CObservation2DRangeScan
CObservation3DRangeScan
CObservation3DScene(CObservation, mrpt.pymrpt.mrpt.opengl.Visualizable)
CObservation6DFeatures
CObservationBatteryState
CObservationBeaconRanges
CObservationBearingRange
CObservationCANBusJ1939
CObservationComment
CObservationGPS
CObservationGasSensors
CObservationIMU
CObservationImage
CObservationOdometry
CObservationPointCloud
CObservationRFID
CObservationRGBD360
CObservationRange
CObservationRawDAQ
CObservationReflectivity
CObservationRobotPose
CObservationRotatingScan
CObservationSkeleton
CObservationStereoImages
CObservationStereoImagesFeatures
CObservationVelodyneScan
CObservationWindSensor
CObservationWirelessPower
mrpt.pymrpt.mrpt.serialization.CSerializable(mrpt.pymrpt.mrpt.rtti.CObject)
CAction
CActionRobotMovement2D
CActionRobotMovement3D
CActionCollection
CObservation(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
CObservation2DRangeScan
CObservation3DRangeScan
CObservation3DScene(CObservation, mrpt.pymrpt.mrpt.opengl.Visualizable)
CObservation6DFeatures
CObservationBatteryState
CObservationBeaconRanges
CObservationBearingRange
CObservationCANBusJ1939
CObservationComment
CObservationGPS
CObservationGasSensors
CObservationIMU
CObservationImage
CObservationOdometry
CObservationPointCloud
CObservationRFID
CObservationRGBD360
CObservationRange
CObservationRawDAQ
CObservationReflectivity
CObservationRobotPose
CObservationRotatingScan
CObservationSkeleton
CObservationStereoImages
CObservationStereoImagesFeatures
CObservationVelodyneScan
CObservationWindSensor
CObservationWirelessPower
CRawlog
CSensoryFrame
pybind11_builtins.pybind11_object(builtins.object)
CObservation2DRangeScanWithUncertainty
CSinCosLookUpTableFor2DScans
T2DScanProperties
T3DPointsProjectionParams
T3DPointsTo2DScanParams
TIMUDataIndex
TPixelLabelInfoBase
TRangeImageFilter
TRangeImageFilterParams
TStereoImageFeatures
VelodyneCalibration
VisualizationParameters

 
class CAction(mrpt.pymrpt.mrpt.serialization.CSerializable)
    Declares a class for storing a robot action. It is used in
mrpt::obs::CRawlog,
   for logs storage and particle filter based simulations.
 See derived classes for implementations.
 
 
CActionCollectionCRawlog
 
 
Method resolution order:
CAction
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.obs.CAction) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CAction::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CAction) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CAction, arg0: mrpt.pymrpt.mrpt.obs.CAction) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CAction, : mrpt.pymrpt.mrpt.obs.CAction) -> mrpt.pymrpt.mrpt.obs.CAction
 
C++: mrpt::obs::CAction::operator=(const class mrpt::obs::CAction &) --> class mrpt::obs::CAction &
getDescriptionAsTextValue(...)
getDescriptionAsTextValue(self: mrpt.pymrpt.mrpt.obs.CAction) -> str
 
Return by value version of getDescriptionAsText(std::ostream&) 
 
C++: mrpt::obs::CAction::getDescriptionAsTextValue() const --> std::string

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CAction::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
timestamp

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

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 CActionCollection(mrpt.pymrpt.mrpt.serialization.CSerializable)
    Declares a class for storing a collection of robot actions. It is used in
mrpt::obs::CRawlog,
   for logs storage and particle filter based simulations.
 
 
CActionCRawlog
 
 
Method resolution order:
CActionCollection
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.obs.CActionCollection) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CActionCollection::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CActionCollection) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CActionCollection, a: mrpt.pymrpt.mrpt.obs.CAction) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CActionCollection, arg0: mrpt.pymrpt.mrpt.obs.CActionCollection) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.obs.CActionCollection, arg0: mrpt.pymrpt.mrpt.obs.CActionCollection) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CActionCollection, : mrpt.pymrpt.mrpt.obs.CActionCollection) -> mrpt.pymrpt.mrpt.obs.CActionCollection
 
C++: mrpt::obs::CActionCollection::operator=(const class mrpt::obs::CActionCollection &) --> class mrpt::obs::CActionCollection &
clear(...)
clear(self: mrpt.pymrpt.mrpt.obs.CActionCollection) -> None
 
Erase all actions from the list 
 
C++: mrpt::obs::CActionCollection::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CActionCollection) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CActionCollection::clone() const --> class mrpt::rtti::CObject *
eraseByIndex(...)
eraseByIndex(self: mrpt.pymrpt.mrpt.obs.CActionCollection, index: int) -> None
 
Remove an action from the list by its index.
 
 
 std::exception On index out of bounds.
 
C++: mrpt::obs::CActionCollection::eraseByIndex(size_t) --> void
get(...)
get(self: mrpt.pymrpt.mrpt.obs.CActionCollection, index: int) -> mrpt.pymrpt.mrpt.obs.CAction
 
Access the i'th action.DO NOT MODIFY the returned object, make a copy of
 ir with "CSerializable::duplicate" if desired.
  First element is 0.
 
 
 std::exception On index out of bounds.
 
C++: mrpt::obs::CActionCollection::get(size_t) --> class std::shared_ptr<class mrpt::obs::CAction>
getBestMovementEstimation(...)
getBestMovementEstimation(self: mrpt.pymrpt.mrpt.obs.CActionCollection) -> mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D
 
Returns the best pose increment estimator in the collection, based on
 the determinant of its pose change covariance matrix.
 
 
 The estimation, or nullptr if none is available.
 
C++: mrpt::obs::CActionCollection::getBestMovementEstimation() const --> class std::shared_ptr<class mrpt::obs::CActionRobotMovement2D>
getFirstMovementEstimation(...)
getFirstMovementEstimation(self: mrpt.pymrpt.mrpt.obs.CActionCollection, out_pose_increment: mrpt.pymrpt.mrpt.poses.CPose3DPDFGaussian) -> bool
 
Look for the first 2D or 3D "odometry" found in this collection of
 actions, and return the "mean" increment of the robot and its covariance
 according to it.
 
 
 true on success,false on no odometry found.
 
C++: mrpt::obs::CActionCollection::getFirstMovementEstimation(class mrpt::poses::CPose3DPDFGaussian &) const --> bool
getFirstMovementEstimationMean(...)
getFirstMovementEstimationMean(self: mrpt.pymrpt.mrpt.obs.CActionCollection, out_pose_increment: mrpt.pymrpt.mrpt.poses.CPose3D) -> bool
 
Look for the first 2D or 3D "odometry" found in this collection of
 actions, and return the "mean" increment of the robot according to it.
 
 
 true on success,false on no odometry found.
 
C++: mrpt::obs::CActionCollection::getFirstMovementEstimationMean(class mrpt::poses::CPose3D &) const --> bool
getMovementEstimationByType(...)
getMovementEstimationByType(self: mrpt.pymrpt.mrpt.obs.CActionCollection, method: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D.TEstimationMethod) -> mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D
 
Returns the pose increment estimator in the collection having the
 specified type.
 
 
 The estimation, or nullptr if none is available.
 
C++: mrpt::obs::CActionCollection::getMovementEstimationByType(enum mrpt::obs::CActionRobotMovement2D::TEstimationMethod) --> class std::shared_ptr<class mrpt::obs::CActionRobotMovement2D>
insert(...)
insert(self: mrpt.pymrpt.mrpt.obs.CActionCollection, action: mrpt.pymrpt.mrpt.obs.CAction) -> None
 
Add a new object to the list, making a deep copy. 
 
C++: mrpt::obs::CActionCollection::insert(const class mrpt::obs::CAction &) --> void
insertPtr(...)
insertPtr(self: mrpt.pymrpt.mrpt.obs.CActionCollection, action: mrpt.pymrpt.mrpt.obs.CAction) -> None
 
Add a new object to the list (no deep copy).
 
 
 (New in MRPT 2.3.1) 
 
C++: mrpt::obs::CActionCollection::insertPtr(const class std::shared_ptr<class mrpt::obs::CAction> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.obs.CActionCollection) -> int
 
Returns the actions count in the collection.
 
C++: mrpt::obs::CActionCollection::size() const --> size_t

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

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

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 CActionRobotMovement2D(CAction)
    Represents a probabilistic 2D movement of the robot mobile base
 
 See docs:
https://docs.mrpt.org/reference/latest/tutorial-motion-models.html
 
Velocity is encoded as mrpt::math::TTwist2D in the optional field
velocityLocal.
 
 
CAction
 
 
Method resolution order:
CActionRobotMovement2D
CAction
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.obs.CActionRobotMovement2D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CActionRobotMovement2D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, arg0: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, arg0: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, : mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D
 
C++: mrpt::obs::CActionRobotMovement2D::operator=(const class mrpt::obs::CActionRobotMovement2D &) --> class mrpt::obs::CActionRobotMovement2D &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CActionRobotMovement2D::clone() const --> class mrpt::rtti::CObject *
computeFromEncoders(...)
computeFromEncoders(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, K_left: float, K_right: float, D: float) -> None
 
If "hasEncodersInfo"=true, this method updates the pose estimation
 according to the ticks from both encoders and the passed parameters,
 which is passed internally to the method "computeFromOdometry" with the
 last used PDF options (or the defualt ones if not explicitly called by
 the user).
 
 
 The meters / tick ratio for the left encoder.
 
 
 The meters / tick ratio for the right encoder.
 
 
 The distance between both wheels, in meters.
 
C++: mrpt::obs::CActionRobotMovement2D::computeFromEncoders(double, double, double) --> void
computeFromOdometry(...)
computeFromOdometry(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, odometryIncrement: mrpt.pymrpt.mrpt.poses.CPose2D, options: mrpt::obs::CActionRobotMovement2D::TMotionModelOptions) -> None
 
Computes the PDF of the pose increment from an odometry reading and
 according to the given motion model (speed and encoder ticks information
 is not modified).
 According to the parameters in the passed struct, it will be called one
 the private sampling functions (see "see also" next).
 
 
 computeFromOdometry_modelGaussian, computeFromOdometry_modelThrun
 
C++: mrpt::obs::CActionRobotMovement2D::computeFromOdometry(const class mrpt::poses::CPose2D &, const struct mrpt::obs::CActionRobotMovement2D::TMotionModelOptions &) --> void
drawSingleSample(...)
drawSingleSample(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, outSample: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Using this method instead of "poseChange->drawSingleSample()" may be
 more efficient in most situations.
 
 
 CPosePDF::drawSingleSample
 
C++: mrpt::obs::CActionRobotMovement2D::drawSingleSample(class mrpt::poses::CPose2D &) const --> void
fastDrawSingleSample(...)
fastDrawSingleSample(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D, outSample: mrpt.pymrpt.mrpt.poses.CPose2D) -> None
 
Faster version than "drawSingleSample", but requires a previous call to
 "prepareFastDrawSingleSamples"
 
C++: mrpt::obs::CActionRobotMovement2D::fastDrawSingleSample(class mrpt::poses::CPose2D &) const --> void
prepareFastDrawSingleSamples(...)
prepareFastDrawSingleSamples(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> None
 
Call this before calling a high number of times "fastDrawSingleSample",
 which is much faster than "drawSingleSample"
 
C++: mrpt::obs::CActionRobotMovement2D::prepareFastDrawSingleSamples() const --> void
velocityAng(...)
velocityAng(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> float
 
C++: mrpt::obs::CActionRobotMovement2D::velocityAng() const --> double
velocityLin(...)
velocityLin(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D) -> float
 
C++: mrpt::obs::CActionRobotMovement2D::velocityLin() const --> double

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

Data descriptors defined here:
encoderLeftTicks
encoderRightTicks
estimationMethod
hasEncodersInfo
hasVelocities
motionModelConfiguration
poseChange
rawOdometryIncrementReading
velocityLocal

Data and other attributes defined here:
TDrawSampleMotionModel = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D.TDrawSampleMotionModel'>
TEstimationMethod = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D.TEstimationMethod'>
TMotionModelOptions = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement2D.TMotionModelOptions'>
The parameter to be passed to "computeFromOdometry".
emOdometry = <TEstimationMethod.emOdometry: 0>
emScan2DMatching = <TEstimationMethod.emScan2DMatching: 1>
mmGaussian = <TDrawSampleMotionModel.mmGaussian: 0>
mmThrun = <TDrawSampleMotionModel.mmThrun: 1>

Methods inherited from CAction:
getDescriptionAsTextValue(...)
getDescriptionAsTextValue(self: mrpt.pymrpt.mrpt.obs.CAction) -> str
 
Return by value version of getDescriptionAsText(std::ostream&) 
 
C++: mrpt::obs::CAction::getDescriptionAsTextValue() const --> std::string

Data descriptors inherited from CAction:
timestamp

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 CActionRobotMovement3D(CAction)
    Represents a probabilistic motion increment in SE(3).
 
Odometry increments might be determined from visual odometry for full 3D, or
from wheel encoders for 2D movements only.
 
The implemented model for creating a SE(3) Gaussian from an odometry
increment is based on 
 
 
 
 
CActionCActionRobotMovement3D,
 
 
Method resolution order:
CActionRobotMovement3D
CAction
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.obs.CActionRobotMovement3D) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CActionRobotMovement3D::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D, arg0: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D, arg0: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D, : mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D) -> mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D
 
C++: mrpt::obs::CActionRobotMovement3D::operator=(const class mrpt::obs::CActionRobotMovement3D &) --> class mrpt::obs::CActionRobotMovement3D &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CActionRobotMovement3D::clone() const --> class mrpt::rtti::CObject *
computeFromOdometry(...)
computeFromOdometry(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D, odometryIncrement: mrpt.pymrpt.mrpt.poses.CPose3D, options: mrpt::obs::CActionRobotMovement3D::TMotionModelOptions) -> None
 
Computes the PDF of the pose increment from an odometry reading and
 according to the given motion model (speed and encoder ticks information
 is not modified).
 According to the parameters in the passed struct, it will be called one
 the private sampling functions (see "see also" next).
 
 
 computeFromOdometry_model6DOF
 
C++: mrpt::obs::CActionRobotMovement3D::computeFromOdometry(const class mrpt::poses::CPose3D &, const struct mrpt::obs::CActionRobotMovement3D::TMotionModelOptions &) --> void
computeFromOdometry_model6DOF(...)
computeFromOdometry_model6DOF(self: mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D, odometryIncrement: mrpt.pymrpt.mrpt.poses.CPose3D, o: mrpt::obs::CActionRobotMovement3D::TMotionModelOptions) -> None
 
Computes the PDF of the pose increment from an odometry reading, using
 the motion model for 6 DOF.
 
 Based on: 
 
 
 computeFromOdometry
 
C++: mrpt::obs::CActionRobotMovement3D::computeFromOdometry_model6DOF(const class mrpt::poses::CPose3D &, const struct mrpt::obs::CActionRobotMovement3D::TMotionModelOptions &) --> void

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

Data descriptors defined here:
estimationMethod
hasVelocities
motionModelConfiguration
poseChange
rawOdometryIncrementReading
velocities

Data and other attributes defined here:
TDrawSampleMotionModel = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D.TDrawSampleMotionModel'>
TEstimationMethod = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D.TEstimationMethod'>
TMotionModelOptions = <class 'mrpt.pymrpt.mrpt.obs.CActionRobotMovement3D.TMotionModelOptions'>
The parameter to be passed to "computeFromOdometry".
See:
emOdometry = <TEstimationMethod.emOdometry: 0>
emVisualOdometry = <TEstimationMethod.emVisualOdometry: 1>
mm6DOF = <TDrawSampleMotionModel.mm6DOF: 1>
mmGaussian = <TDrawSampleMotionModel.mmGaussian: 0>

Methods inherited from CAction:
getDescriptionAsTextValue(...)
getDescriptionAsTextValue(self: mrpt.pymrpt.mrpt.obs.CAction) -> str
 
Return by value version of getDescriptionAsText(std::ostream&) 
 
C++: mrpt::obs::CAction::getDescriptionAsTextValue() const --> std::string

Data descriptors inherited from CAction:
timestamp

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 CObservation(mrpt.pymrpt.mrpt.serialization.CSerializable, mrpt.pymrpt.mrpt.Stringifyable)
    Generic sensor observation.
 
 This is a base virtual class for all types of sensor observations.
 Users can add new observation types creating a new class deriving from this
one, or reuse those provided in MRPT modules. Most observations are defined
in 
 
 
Observations do not include any information about the robot localization,
but just raw sensory data and, where aplicable, information about the
sensor position and orientation in the **local frame** (vehicle frame).
 
Datasets with large number of observations can be managed with
mrpt::obs::CRawLog.
 
 
CSensoryFrame, CMetricMap, mrpt::obs::CRawLog
 
 
Method resolution order:
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation, arg0: mrpt.pymrpt.mrpt.obs.CObservation) -> None
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservation, : mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.obs.CObservation
 
C++: mrpt::obs::CObservation::operator=(const class mrpt::obs::CObservation &) --> class mrpt::obs::CObservation &
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getSensorPose(...)
getSensorPose(*args, **kwargs)
Overloaded function.
 
1. getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
A general method to retrieve the sensor pose on the robot.
  Note that most sensors will return a full (6D) CPose3D, but see the
 derived classes for more details or special cases.
 
 
 setSensorPose
 
C++: mrpt::obs::CObservation::getSensorPose(class mrpt::poses::CPose3D &) const --> void
 
2. getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation, out_sensorPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
A general method to retrieve the sensor pose on the robot.
  Note that most sensors will return a full (6D) CPose3D, but see the
 derived classes for more details or special cases.
 
 
 setSensorPose
 
C++: mrpt::obs::CObservation::getSensorPose(struct mrpt::math::TPose3D &) const --> void
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
setSensorPose(...)
setSensorPose(*args, **kwargs)
Overloaded function.
 
1. setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
A general method to change the sensor pose on the robot.
  Note that most sensors will use the full (6D) CPose3D, but see the
 derived classes for more details or special cases.
 
 
 getSensorPose
 
C++: mrpt::obs::CObservation::setSensorPose(const class mrpt::poses::CPose3D &) --> void
 
2. setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation, newSensorPose: mrpt.pymrpt.mrpt.math.TPose3D) -> None
 
A general method to change the sensor pose on the robot.
  Note that most sensors will use the full (6D) CPose3D, but see the
 derived classes for more details or special cases.
 
 
 getSensorPose
 
C++: mrpt::obs::CObservation::setSensorPose(const struct mrpt::math::TPose3D &) --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Static methods defined here:
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
sensorLabel
timestamp

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

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 CObservation2DRangeScan(CObservation)
    A "CObservation"-derived class that represents a 2D range scan measurement
(typically from a laser scanner).
The data structures are generic enough to hold a wide variety of 2D
scanners and "3D" planar rotating 2D lasers.
 
These are the most important data fields:
- Scan ranges: A vector of float values with all the range measurements
[meters]. Access via `CObservation2DRangeScan::getScanRange()` and
`CObservation2DRangeScan::setScanRange()`.
- Range validity: A vector (of identical size to scan), it holds
`true` for those ranges than are valid (i.e. will be zero for non-reflected
rays, etc.), `false` for scan rays without a valid lidar return.
- Reflection intensity: A vector (of identical size to scan) a
unitless int values representing the relative strength of each return. Higher
values indicate a more intense return. This is useful for filtering out low
intensity (noisy) returns or detecting intense landmarks.
CObservation2DRangeScan::aperture: The field-of-view of the scanner,
in radians (typically, M_PI = 180deg).
CObservation2DRangeScan::sensorPose: The 6D location of the sensor on
the robot reference frame (default=at the origin), i.e. wrt `base_link`
following ROS conventions.
CObservation2DRangeScan::rightToLeft: The scanning direction:
true=counterclockwise (default), false=clockwise.
 
Note that the *angle of each range* in the vectors above is implicitly
defined by the index within the vector.
 
 
CObservation, CPointsMap, T2DScanProperties
 
 
Method resolution order:
CObservation2DRangeScan
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation2DRangeScan::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, arg0: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, arg0: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, : mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan
 
C++: mrpt::obs::CObservation2DRangeScan::operator=(const class mrpt::obs::CObservation2DRangeScan &) --> class mrpt::obs::CObservation2DRangeScan &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservation2DRangeScan::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> str
 
C++: mrpt::obs::CObservation2DRangeScan::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> str
 
C++: mrpt::obs::CObservation2DRangeScan::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> bool
 
C++: mrpt::obs::CObservation2DRangeScan::exportTxtSupported() const --> bool
getScanAngle(...)
getScanAngle(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, idx: int) -> float
 
Returns the computed direction (relative heading in radians, with
 0=forward) of the given ray index, following the following formula:
 
 
 
 
 
 
 
 
 
 
 
 
 Index of the ray, from `0` to `size()-1`.
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation2DRangeScan::getScanAngle(size_t) const --> float
getScanIntensity(...)
getScanIntensity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int) -> int
 
C++: mrpt::obs::CObservation2DRangeScan::getScanIntensity(size_t) --> int &
getScanProperties(...)
getScanProperties(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, p: mrpt.pymrpt.mrpt.obs.T2DScanProperties) -> None
 
Fill out a T2DScanProperties structure with the parameters of this scan
 
C++: mrpt::obs::CObservation2DRangeScan::getScanProperties(struct mrpt::obs::T2DScanProperties &) const --> void
getScanRange(...)
getScanRange(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int) -> float
 
C++: mrpt::obs::CObservation2DRangeScan::getScanRange(size_t) --> float &
getScanRangeValidity(...)
getScanRangeValidity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int) -> bool
 
It's false (=0) on no reflected rays, referenced to elements in 
         
 
C++: mrpt::obs::CObservation2DRangeScan::getScanRangeValidity(size_t) const --> bool
getScanSize(...)
getScanSize(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> int
 
Get number of scan rays 
 
C++: mrpt::obs::CObservation2DRangeScan::getScanSize() const --> size_t
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation2DRangeScan::getSensorPose(class mrpt::poses::CPose3D &) const --> void
hasIntensity(...)
hasIntensity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> bool
 
Return true if scan has intensity 
 
C++: mrpt::obs::CObservation2DRangeScan::hasIntensity() const --> bool
isPlanarScan(...)
isPlanarScan(*args, **kwargs)
Overloaded function.
 
1. isPlanarScan(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> bool
 
2. isPlanarScan(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, tolerance: float) -> bool
 
Return true if the laser scanner is "horizontal", so it has an absolute
 value of "pitch" and "roll" less or equal to the given tolerance (in
 rads, default=0) (with the normal vector either upwards or downwards).
 
C++: mrpt::obs::CObservation2DRangeScan::isPlanarScan(const double) const --> bool
loadFromVectors(...)
loadFromVectors(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, nRays: int, scanRanges: float, scanValidity: str) -> None
 
@} 
 
C++: mrpt::obs::CObservation2DRangeScan::loadFromVectors(size_t, const float *, const char *) --> void
resizeScan(...)
resizeScan(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, len: int) -> None
 
                @{ 
 
 Resizes all data vectors to allocate a given number of scan rays 
 
C++: mrpt::obs::CObservation2DRangeScan::resizeScan(size_t) --> void
resizeScanAndAssign(...)
resizeScanAndAssign(*args, **kwargs)
Overloaded function.
 
1. resizeScanAndAssign(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, len: int, rangeVal: float, rangeValidity: bool) -> None
 
2. resizeScanAndAssign(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, len: int, rangeVal: float, rangeValidity: bool, rangeIntensity: int) -> None
 
Resizes all data vectors to allocate a given number of scan rays and
 assign default values. 
 
C++: mrpt::obs::CObservation2DRangeScan::resizeScanAndAssign(size_t, const float, const bool, const int) --> void
setScanHasIntensity(...)
setScanHasIntensity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, setHasIntensityFlag: bool) -> None
 
Marks this scan as having or not intensity data. 
 
C++: mrpt::obs::CObservation2DRangeScan::setScanHasIntensity(bool) --> void
setScanIntensity(...)
setScanIntensity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int, val: int) -> None
 
C++: mrpt::obs::CObservation2DRangeScan::setScanIntensity(size_t, const int) --> void
setScanRange(...)
setScanRange(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int, val: float) -> None
 
C++: mrpt::obs::CObservation2DRangeScan::setScanRange(size_t, const float) --> void
setScanRangeValidity(...)
setScanRangeValidity(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, i: int, val: bool) -> None
 
C++: mrpt::obs::CObservation2DRangeScan::setScanRangeValidity(size_t, const bool) --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation2DRangeScan::setSensorPose(const class mrpt::poses::CPose3D &) --> void
truncateByDistanceAndAngle(...)
truncateByDistanceAndAngle(*args, **kwargs)
Overloaded function.
 
1. truncateByDistanceAndAngle(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, min_distance: float, max_angle: float) -> None
 
2. truncateByDistanceAndAngle(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, min_distance: float, max_angle: float, min_height: float) -> None
 
3. truncateByDistanceAndAngle(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, min_distance: float, max_angle: float, min_height: float, max_height: float) -> None
 
4. truncateByDistanceAndAngle(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, min_distance: float, max_angle: float, min_height: float, max_height: float, h: float) -> None
 
A general method to truncate the scan by defining a minimum valid
           distance and a maximum valid angle as well as minimun and maximum heights
           (NOTE: the laser z-coordinate must be provided).
 
C++: mrpt::obs::CObservation2DRangeScan::truncateByDistanceAndAngle(float, float, float, float, float) --> void

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

Data descriptors defined here:
aperture
beamAperture
deltaPitch
maxRange
rightToLeft
sensorPose
stdError

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservation2DRangeScanWithUncertainty(pybind11_builtins.pybind11_object)
    A 2D range scan plus an uncertainty model for each range.
 
 
mrpt::maps::COccupancyGridMap2D::laserScanSimulatorWithUncertainty()
 
 
Method resolution order:
CObservation2DRangeScanWithUncertainty
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty, arg0: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty, : mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty) -> mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty
 
C++: mrpt::obs::CObservation2DRangeScanWithUncertainty::operator=(const class mrpt::obs::CObservation2DRangeScanWithUncertainty &) --> class mrpt::obs::CObservation2DRangeScanWithUncertainty &
evaluateScanLikelihood(...)
evaluateScanLikelihood(self: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty, otherScan: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, params: mrpt::obs::CObservation2DRangeScanWithUncertainty::TEvalParams) -> float
 
Returns a measure of the likelihood of a given scan, compared to this
 scan variances 
 
C++: mrpt::obs::CObservation2DRangeScanWithUncertainty::evaluateScanLikelihood(const class mrpt::obs::CObservation2DRangeScan &, const struct mrpt::obs::CObservation2DRangeScanWithUncertainty::TEvalParams &) const --> double

Data descriptors defined here:
rangeScan
rangesCovar
rangesMean

Data and other attributes defined here:
TEvalParams = <class 'mrpt.pymrpt.mrpt.obs.CObservation2DRangeScanWithUncertainty.TEvalParams'>

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 CObservation3DRangeScan(CObservation)
    A depth or RGB+D image from a time-of-flight or structured-light sensor.
 
This kind of observations can carry one or more of these data fields:
 - 3D point cloud (as {x,y,z} `float` vectors).
 - Each 3D point has its associated `(u,v)` pixel coordinates in 
&  (New in MRPT 1.4.0)
 - 2D range image (as a matrix): Each entry in the matrix
   `rangeImage(ROW,COLUMN)` contains a distance or a depth, depending
   on  Ranges are stored as uint16_t for efficiency.
   The units of ranges are stored separately in `rangeUnits`.
 - 2D intensity (grayscale or RGB) image (as a mrpt::img::CImage).
 - 2D confidence image (as a mrpt::img::CImage): For each pixel, a 0x00
   and a 0xFF mean the lowest and highest confidence levels, respectively.
 - Semantic labels: Stored as a matrix of bitfields, each bit having a
   user-defined meaning.
 - For cameras supporting multiple returns per pixels, different layers of
   range images are available in the map 
 
The coordinates of the 3D point cloud are in meters with respect to the
depth camera origin of coordinates,
with the +X axis pointing forward, +Y pointing left-hand and +Z pointing
up. By convention, a 3D point with its coordinates set to (0,0,0), will be
considered as invalid.
 
The field CObservation3DRangeScan::relativePoseIntensityWRTDepth describes
the change of coordinates from the depth camera to the intensity
(RGB or grayscale) camera. In some cameras both cameras coincide,
so this pose would be just a rotation (0,0,0,-90deg,0,-90deg).
In Kinect-like cameras there is also an offset, as shown in this figure:
 
![CObservation3DRangeScan axes](CObservation3DRangeScan_figRefSystem.png)
 
In any case, check the field  or the method
 to determine if both frames of
reference coincide, since even for Kinect cameras both can coincide if the
images have been rectified.
 
The 2D images and matrices are stored as common images, with an up->down
rows order and left->right, as usual.
Optionally, the intensity and confidence channels can be set to
delayed-load images for off-rawlog storage so it saves
memory by having loaded in memory just the needed images. See the methods
load() and unload().
Due to the intensive storage requirements of this kind of observations, this
observation is the only one in MRPT
for which it's recommended to always call "load()" and "unload()" before
and after using the observation, *ONLY* when
the observation was read from a rawlog dataset, in order to make sure that
all the externally stored data fields are
loaded and ready in memory.
 
Some classes that grab observations of this type are:
 - mrpt::hwdrivers::CSwissRanger3DCamera
 - mrpt::hwdrivers::CKinect
 - mrpt::hwdrivers::COpenNI2Sensor
 
There are two sets of calibration parameters (see
mrpt::vision::checkerBoardStereoCalibration() or the ready-to-use GUI program
[kinect-calibrate](https://www.mrpt.org/list-of-mrpt-apps/application-kinect-stereo-calib/):
 - cameraParams: Intrinsics of the depth camera.
 - cameraParamsIntensity: Intrinsics of the intensity (RGB) camera.
 
In some cameras, like SwissRanger, both are the same. It is possible in
Kinect to rectify the range images such both cameras
seem to coincide and then both sets of camera parameters will be identical.
 
Range data can be interpreted in two different ways depending on the 3D
camera (this field is already set to the correct setting when grabbing
observations from an mrpt::hwdrivers sensor):
 - `range_is_depth==true`: Kinect-like ranges: entries of 
   are distances along the +X (front-facing) axis.
 - `range_is_depth==false`: Ranges in  are actual distances
   in 3D, i.e. a bit larger than the depth.
 
The `intensity` channel may come from different channels in sensors as
Kinect. Look at field `intensityImageChannel` to find out if the image was
grabbed from the visible (RGB) or IR channels.
 
3D point clouds can be generated at any moment after grabbing with
CObservation3DRangeScan::unprojectInto(), provided the correct calibration
parameters. Note that unprojectInto() will store the point cloud in
sensor-centric local coordinates by default, but changing its parameters you
can obtain a vehicle-centric, or world-frame point cloud instead.
 
Examples of how to assign labels to pixels (for object segmentation, semantic
information, etc.):
 
 
 
 
 
 
 
 
 
 
 
Since MRPT 1.5.0, external files format can be selected at runtime
      with `CObservation3DRangeScan::EXTERNALS_AS_TEXT`
 
 
mrpt::hwdrivers::CSwissRanger3DCamera, mrpt::hwdrivers::CKinect,
    mrpt::hwdrivers::COpenNI2Sensor, mrpt::obs::CObservation
 
 
Method resolution order:
CObservation3DRangeScan
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation3DRangeScan::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, arg0: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, arg0: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, : mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan
 
C++: mrpt::obs::CObservation3DRangeScan::operator=(const class mrpt::obs::CObservation3DRangeScan &) --> class mrpt::obs::CObservation3DRangeScan &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservation3DRangeScan::clone() const --> class mrpt::rtti::CObject *
convertTo2DScan(...)
convertTo2DScan(*args, **kwargs)
Overloaded function.
 
1. convertTo2DScan(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_scan2d: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, scanParams: mrpt.pymrpt.mrpt.obs.T3DPointsTo2DScanParams) -> None
 
2. convertTo2DScan(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_scan2d: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, scanParams: mrpt.pymrpt.mrpt.obs.T3DPointsTo2DScanParams, filterParams: mrpt.pymrpt.mrpt.obs.TRangeImageFilterParams) -> None
 
Convert this 3D observation into an "equivalent 2D fake laser scan",
 with a configurable vertical FOV.
 
  The result is a 2D laser scan with more "rays" (N) than columns has the
 3D observation (W), exactly: N = W * oversampling_ratio.
  This oversampling is required since laser scans sample the space at
 evenly-separated angles, while
  a range camera follows a tangent-like distribution. By oversampling we
 make sure we don't leave "gaps" unseen by the virtual "2D laser".
 
  All obstacles within a frustum are considered and the minimum distance
 is kept in each direction.
  The horizontal FOV of the frustum is automatically computed from the
 intrinsic parameters, but the
  vertical FOV must be provided by the user, and can be set to be
 assymetric which may be useful
  depending on the zone of interest where to look for obstacles.
 
  All spatial transformations are riguorosly taken into account in this
 class, using the depth camera
  intrinsic calibration parameters.
 
  The timestamp of the new object is copied from the 3D object.
  Obviously, a requisite for calling this method is the 3D observation
 having range data,
  i.e. hasRangeImage must be true. It's not needed to have RGB data nor
 the raw 3D point clouds
  for this method to work.
 
  If `scanParams.use_origin_sensor_pose` is `true`, the points will be
 projected to 3D and then reprojected
  as seen from a different sensorPose at the vehicle frame origin.
 Otherwise (the default), the output 2D observation will share the
 sensorPose of the input 3D scan
  (using a more efficient algorithm that avoids trigonometric functions).
 
  
 The resulting 2D equivalent scan.
 
 
 The example in
 https://www.mrpt.org/tutorials/mrpt-examples/example-kinect-to-2d-laser-demo/
 
C++: mrpt::obs::CObservation3DRangeScan::convertTo2DScan(class mrpt::obs::CObservation2DRangeScan &, const struct mrpt::obs::T3DPointsTo2DScanParams &, const struct mrpt::obs::TRangeImageFilterParams &) --> void
doDepthAndIntensityCamerasCoincide(...)
doDepthAndIntensityCamerasCoincide(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> bool
 
Return true if  equals the pure rotation
 (0,0,0,-90deg,0,-90deg) (with a small comparison epsilon)
 
 
 relativePoseIntensityWRTDepth
 
C++: mrpt::obs::CObservation3DRangeScan::doDepthAndIntensityCamerasCoincide() const --> bool
getScanSize(...)
getScanSize(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> int
 
Get the size of the scan pointcloud. 
 Method is added for
 compatibility with its CObservation2DRangeScan counterpart 
 
C++: mrpt::obs::CObservation3DRangeScan::getScanSize() const --> size_t
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation3DRangeScan::getSensorPose(class mrpt::poses::CPose3D &) const --> void
getZoneAsObs(...)
getZoneAsObs(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, obs: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, r1: int, r2: int, c1: int, c2: int) -> None
 
Extract a ROI of the 3D observation as a new one. 
 PixelLabels are
 *not* copied to the output subimage. 
 
C++: mrpt::obs::CObservation3DRangeScan::getZoneAsObs(class mrpt::obs::CObservation3DRangeScan &, const unsigned int &, const unsigned int &, const unsigned int &, const unsigned int &) --> void
get_unproj_lut(...)
get_unproj_lut(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> mrpt::obs::CObservation3DRangeScan::unproject_LUT_t
 
Gets (or generates upon first request) the 3D point cloud projection
 look-up-table for the current depth camera intrinsics & distortion
 parameters.
 Returns a const reference to a global variable. Multithread safe.
 
 
 unprojectInto 
 
C++: mrpt::obs::CObservation3DRangeScan::get_unproj_lut() const --> const struct mrpt::obs::CObservation3DRangeScan::unproject_LUT_t &
hasPixelLabels(...)
hasPixelLabels(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> bool
 
@{ 
 
 Returns true if the field CObservation3DRangeScan::pixelLabels contains
 a non-NULL smart pointer.
 To enhance a 3D point cloud with labeling info, just assign an
 appropiate object to 
         
 
C++: mrpt::obs::CObservation3DRangeScan::hasPixelLabels() const --> bool
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
                @{ 
 
 Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation3DRangeScan::load() const --> void
points3D_convertToExternalStorage(...)
points3D_convertToExternalStorage(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, fileName: str, use_this_base_dir: str) -> None
 
Users won't normally want to call this, it's only used from internal
 MRPT programs. 
 
 EXTERNALS_AS_TEXT 
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_convertToExternalStorage(const std::string &, const std::string &) --> void
points3D_getExternalStorageFile(...)
points3D_getExternalStorageFile(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> str
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_getExternalStorageFile() const --> std::string
points3D_getExternalStorageFileAbsolutePath(...)
points3D_getExternalStorageFileAbsolutePath(*args, **kwargs)
Overloaded function.
 
1. points3D_getExternalStorageFileAbsolutePath(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_path: str) -> None
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_getExternalStorageFileAbsolutePath(std::string &) const --> void
 
2. points3D_getExternalStorageFileAbsolutePath(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> str
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_getExternalStorageFileAbsolutePath() const --> std::string
points3D_isExternallyStored(...)
points3D_isExternallyStored(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> bool
 
@{ 
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_isExternallyStored() const --> bool
points3D_overrideExternalStoredFlag(...)
points3D_overrideExternalStoredFlag(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, isExternal: bool) -> None
 
Users normally won't need to use this 
 
C++: mrpt::obs::CObservation3DRangeScan::points3D_overrideExternalStoredFlag(bool) --> void
rangeImage_convertToExternalStorage(...)
rangeImage_convertToExternalStorage(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, fileName: str, use_this_base_dir: str) -> None
 
Users won't normally want to call this, it's only used from internal
 MRPT programs. 
 
 EXTERNALS_AS_TEXT 
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_convertToExternalStorage(const std::string &, const std::string &) --> void
rangeImage_forceResetExternalStorage(...)
rangeImage_forceResetExternalStorage(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
Forces marking this observation as non-externally stored - it doesn't
 anything else apart from reseting the corresponding flag (Users won't
 normally want to call this, it's only used from internal MRPT programs)
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_forceResetExternalStorage() --> void
rangeImage_getExternalStorageFile(...)
rangeImage_getExternalStorageFile(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, rangeImageLayer: str) -> str
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_getExternalStorageFile(const std::string &) const --> std::string
rangeImage_getExternalStorageFileAbsolutePath(...)
rangeImage_getExternalStorageFileAbsolutePath(*args, **kwargs)
Overloaded function.
 
1. rangeImage_getExternalStorageFileAbsolutePath(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_path: str, rangeImageLayer: str) -> None
 
rangeImageLayer: Empty for the main rangeImage matrix, otherwise, a key
 of rangeImageOtherLayers 
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_getExternalStorageFileAbsolutePath(std::string &, const std::string &) const --> void
 
2. rangeImage_getExternalStorageFileAbsolutePath(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, rangeImageLayer: str) -> str
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_getExternalStorageFileAbsolutePath(const std::string &) const --> std::string
rangeImage_isExternallyStored(...)
rangeImage_isExternallyStored(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> bool
 
@{ 
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_isExternallyStored() const --> bool
rangeImage_setSize(...)
rangeImage_setSize(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, HEIGHT: int, WIDTH: int) -> None
 
Similar to calling "rangeImage.setSize(H,W)" but this method provides
 memory pooling to speed-up the memory allocation. 
 
C++: mrpt::obs::CObservation3DRangeScan::rangeImage_setSize(const int, const int) --> void
resizePoints3DVectors(...)
resizePoints3DVectors(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, nPoints: int) -> None
 
Use this method instead of resizing all three  
 &  to allow the usage of the internal memory
 pool. 
 
C++: mrpt::obs::CObservation3DRangeScan::resizePoints3DVectors(size_t) --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation3DRangeScan::setSensorPose(const class mrpt::poses::CPose3D &) --> void
swap(...)
swap(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, o: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
Very efficient method to swap the contents of two observations. 
 
C++: mrpt::obs::CObservation3DRangeScan::swap(class mrpt::obs::CObservation3DRangeScan &) --> void
undistort(...)
undistort(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
Removes the distortion in both, depth and intensity images. Intrinsics
 (fx,fy,cx,cy) remains the same for each image after undistortion.
 
C++: mrpt::obs::CObservation3DRangeScan::undistort() --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation3DRangeScan::unload() const --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservation3DRangeScan::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
EXTERNALS_AS_TEXT(...) from builtins.PyCapsule
EXTERNALS_AS_TEXT(*args, **kwargs)
Overloaded function.
 
1. EXTERNALS_AS_TEXT(value: bool) -> None
 
Whether external files (3D points, range and confidence) are to be
 saved as `.txt` text files (MATLAB compatible) or `*.bin` binary
(faster).
 Loading always will determine the type by inspecting the file extension.
 
 
 Default=false
 
C++: mrpt::obs::CObservation3DRangeScan::EXTERNALS_AS_TEXT(bool) --> void
 
2. EXTERNALS_AS_TEXT() -> bool
 
C++: mrpt::obs::CObservation3DRangeScan::EXTERNALS_AS_TEXT() --> bool
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation3DRangeScan::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
recoverCameraCalibrationParameters(...) from builtins.PyCapsule
recoverCameraCalibrationParameters(*args, **kwargs)
Overloaded function.
 
1. recoverCameraCalibrationParameters(in_obs: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_camParams: mrpt.pymrpt.mrpt.img.TCamera) -> float
 
2. recoverCameraCalibrationParameters(in_obs: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, out_camParams: mrpt.pymrpt.mrpt.img.TCamera, camera_offset: float) -> float
 
A Levenberg-Marquart-based optimizer to recover the calibration
 parameters of a 3D camera given a range (depth) image and the
 corresponding 3D point cloud.
 
 
 The offset (in meters) in the +X direction of the
 point cloud.
 
 
 The final average reprojection error per pixel (typ <0.05 px)
 
C++: mrpt::obs::CObservation3DRangeScan::recoverCameraCalibrationParameters(const class mrpt::obs::CObservation3DRangeScan &, class mrpt::img::TCamera &, const double) --> double

Data descriptors defined here:
cameraParams
cameraParamsIntensity
confidenceImage
hasConfidenceImage
hasIntensityImage
hasPoints3D
hasRangeImage
intensityImage
intensityImageChannel
maxRange
pixelLabels
points3D_idxs_x
points3D_idxs_y
points3D_x
points3D_y
points3D_z
rangeImage
rangeImageOtherLayers
rangeUnits
range_is_depth
relativePoseIntensityWRTDepth
sensorPose
stdError

Data and other attributes defined here:
CH_IR = <TIntensityChannelID.CH_IR: 1>
CH_VISIBLE = <TIntensityChannelID.CH_VISIBLE: 0>
TIntensityChannelID = <class 'mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan.TIntensityChannelID'>
unproject_LUT_t = <class 'mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan.unproject_LUT_t'>
Look-up-table struct for unprojectInto()

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservation3DScene(CObservation, mrpt.pymrpt.mrpt.opengl.Visualizable)
    Not a real sensor observation, it stores a 3D scene which can be used for
debugging or any other logging purposes.
If stored in a .rawlog file, RawLogViewer will show the contents of
the scene's main viewport when selecting it on the tree view.
 
 
CObservation
 
 
 
 
(New in MRPT 2.3.1)
 
 
Method resolution order:
CObservation3DScene
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
mrpt.pymrpt.mrpt.opengl.Visualizable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservation3DScene::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, arg0: mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, arg0: mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, : mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> mrpt.pymrpt.mrpt.obs.CObservation3DScene
 
C++: mrpt::obs::CObservation3DScene::operator=(const class mrpt::obs::CObservation3DScene &) --> class mrpt::obs::CObservation3DScene &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservation3DScene::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation3DScene::getSensorPose(class mrpt::poses::CPose3D &) const --> void
getVisualizationInto(...)
getVisualizationInto(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, o: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
C++: mrpt::obs::CObservation3DScene::getVisualizationInto(class mrpt::opengl::CSetOfObjects &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation3DScene, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservation3DScene::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
scene
sensorPose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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.opengl.Visualizable:
getVisualization(...)
getVisualization(self: mrpt.pymrpt.mrpt.opengl.Visualizable) -> mrpt::opengl::CSetOfObjects
 
Creates 3D primitives representing this objects.
 This is equivalent to getVisualizationInto() but creating, and returning
 by value, a new rpt::opengl::CSetOfObjects::Ptr shared pointer.
 
 
 getVisualizationInto()
 
C++: mrpt::opengl::Visualizable::getVisualization() const --> class std::shared_ptr<class mrpt::opengl::CSetOfObjects>

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 CObservation6DFeatures(CObservation)
    An observation of one or more "features" or "objects", possibly identified
with a unique ID, whose relative SE(3) pose is observed with respect to the
sensor.
The list of features is stored in 
 
 
CObservation
 
 
Method resolution order:
CObservation6DFeatures
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

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

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

Data descriptors defined here:
maxSensorDistance
minSensorDistance
sensedFeatures
sensorPose

Data and other attributes defined here:
TMeasurement = <class 'mrpt.pymrpt.mrpt.obs.CObservation6DFeatures.TMeasurement'>
Each one of the measurements

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationBatteryState(CObservation)
    This represents a measurement of the batteries on the robot.
  The battery levels are in volts in the form of the public members:
        - voltageMainRobotBattery
        - voltageMainRobotComputer
  - voltageOtherBatteries
 
  There are boolean flags for signaling when the corresponding values have
been filled out or not.
 
 
 CObservation
 
 
Method resolution order:
CObservationBatteryState
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationBatteryState::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState, arg0: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState, arg0: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState, : mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> mrpt.pymrpt.mrpt.obs.CObservationBatteryState
 
C++: mrpt::obs::CObservationBatteryState::operator=(const class mrpt::obs::CObservationBatteryState &) --> class mrpt::obs::CObservationBatteryState &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationBatteryState::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> str
 
C++: mrpt::obs::CObservationBatteryState::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> str
 
C++: mrpt::obs::CObservationBatteryState::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState) -> bool
 
C++: mrpt::obs::CObservationBatteryState::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBatteryState::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBatteryState, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBatteryState::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
voltageMainRobotBattery
voltageMainRobotBatteryIsValid
voltageMainRobotComputer
voltageMainRobotComputerIsValid
voltageOtherBatteries
voltageOtherBatteriesValid

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationBeaconRanges(CObservation)
    Declares a class derived from "CObservation" that represents one (or more)
range measurements to labeled beacons.
 
 
CObservation
 
 
Method resolution order:
CObservationBeaconRanges
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationBeaconRanges::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, arg0: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, arg0: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, : mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges
 
C++: mrpt::obs::CObservationBeaconRanges::operator=(const class mrpt::obs::CObservationBeaconRanges &) --> class mrpt::obs::CObservationBeaconRanges &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationBeaconRanges::clone() const --> class mrpt::rtti::CObject *
debugPrintOut(...)
debugPrintOut(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> None
 
Prints out the contents of the object  
 
C++: mrpt::obs::CObservationBeaconRanges::debugPrintOut() --> void
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> str
 
C++: mrpt::obs::CObservationBeaconRanges::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> str
 
C++: mrpt::obs::CObservationBeaconRanges::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges) -> bool
 
C++: mrpt::obs::CObservationBeaconRanges::exportTxtSupported() const --> bool
getSensedRangeByBeaconID(...)
getSensedRangeByBeaconID(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, beaconID: int) -> float
 
Easy look-up into the vector sensedData, returns the range for a given
 beacon, or 0 if the beacon is not observed 
 
C++: mrpt::obs::CObservationBeaconRanges::getSensedRangeByBeaconID(int32_t) --> float
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBeaconRanges::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBeaconRanges::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
auxEstimatePose
maxSensorDistance
minSensorDistance
sensedData
stdError

Data and other attributes defined here:
TMeasurement = <class 'mrpt.pymrpt.mrpt.obs.CObservationBeaconRanges.TMeasurement'>
Each one of the measurements

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationBearingRange(CObservation)
    This observation represents a number of range-bearing value pairs, each one
for a detected landmark, which optionally can have identification IDs.
 This class can manage sensors that detect landmarks in a 2D plane (e.g. a
laser scanner) or in the 3D space (e.g. a camera). There are
 two direction angles: yaw (azimuth) and pitch (negative elevation). For 2D
sensors, the pitch must be always set to 0.
See CObservationBearingRange::validCovariances for the instructions to fill
the uncertainty covariances.
 
 
CObservation
 
 
Method resolution order:
CObservationBearingRange
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationBearingRange::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange, arg0: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange, arg0: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange, : mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> mrpt.pymrpt.mrpt.obs.CObservationBearingRange
 
C++: mrpt::obs::CObservationBearingRange::operator=(const class mrpt::obs::CObservationBearingRange &) --> class mrpt::obs::CObservationBearingRange &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationBearingRange::clone() const --> class mrpt::rtti::CObject *
debugPrintOut(...)
debugPrintOut(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange) -> None
 
Prints out the contents of the object.
 
C++: mrpt::obs::CObservationBearingRange::debugPrintOut() --> void
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBearingRange::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationBearingRange, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationBearingRange::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
fieldOfView_pitch
fieldOfView_yaw
maxSensorDistance
minSensorDistance
sensedData
sensorLocationOnRobot
sensor_std_pitch
sensor_std_range
sensor_std_yaw
validCovariances

Data and other attributes defined here:
TMeasurement = <class 'mrpt.pymrpt.mrpt.obs.CObservationBearingRange.TMeasurement'>
Each one of the measurements:

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationCANBusJ1939(CObservation)
    This class stores a message from a CAN BUS with the protocol J1939
 
 
CObservation
 
 
Method resolution order:
CObservationCANBusJ1939
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

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

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

Data descriptors defined here:
m_data
m_data_length
m_pdu_format
m_pdu_spec
m_pgn
m_priority
m_raw_frame
m_src_address

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationComment(CObservation)
    This "observation" is actually a placeholder for a text block with comments
or additional parameters attached to a given rawlog file.
  There should be only one of this observations in a rawlog file, and it's
recommended to insert/modify them from the application RawlogViewer.
 
 
CObservation
 
 
Method resolution order:
CObservationComment
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

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

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

Data descriptors defined here:
text

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationGPS(CObservation)
    This class stores messages from GNSS or GNSS+IMU devices, from
consumer-grade inexpensive GPS receivers to Novatel/Topcon/... advanced RTK
solutions.
 
 See mrpt::hwdrivers::CGPSInterface for a class capable of reading from a
serial port or any input stream and  the ASCII/binary stream into
 indivual messages  in mrpt::obs::CObservationGPS objects.
 
 Supported message types are:
 - NMEA 0183 (ASCII): GGA, RMC
 - Topcon GRIL (Binary): PZS, SATS
 - Novatel GNSS/SPAN OEM6 (Binary): See list of log packets under namespace
mrpt::obs::gnss and in enum type mrpt::obs::gnss::gnss_message_type_t
 
 Note that this object has  timestamp fields:
 - The standard CObservation::timestamp field in the base class, which should
contain the accurate satellite-based UTC timestamp, and
 - the field CObservationGPS::originalReceivedTimestamp, with the local
computer-based timestamp based on the reception of the message in the
computer.
 
Normally, users read and write messages by means of these methods:
 - CObservationGPS::getMsgByClass()
 - CObservationGPS::setMsg()
 - CObservationGPS::hasMsgType()
 - CObservationGPS::hasMsgClass()
 
Example access to GPS datum:
 
 
 
 
 
 
 
 
 
 
 
[API changed in MRPT 1.4.0] mrpt::obs::CObservationGPS now
stores message objects in a more flexible way. API clean-up and extended so
the number of GNSS message types is larger and more scalable.
 
 
Porting old code: For example, replace `observation.GGA_datum.XXX` with
`observation.getMsgByClass<gnss::Message_NMEA_GGA>().fields.XXX`, etc.
 
 
CObservation
 
 
Method resolution order:
CObservationGPS
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationGPS::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, arg0: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, arg0: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, : mrpt.pymrpt.mrpt.obs.CObservationGPS) -> mrpt.pymrpt.mrpt.obs.CObservationGPS
 
C++: mrpt::obs::CObservationGPS::operator=(const class mrpt::obs::CObservationGPS &) --> class mrpt::obs::CObservationGPS &
clear(...)
clear(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> None
 
Empties this observation, clearing the container  
 
C++: mrpt::obs::CObservationGPS::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationGPS::clone() const --> class mrpt::rtti::CObject *
getMsgByType(...)
getMsgByType(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, type_id: mrpt.pymrpt.mrpt.obs.gnss.gnss_message_type_t) -> mrpt.pymrpt.mrpt.obs.gnss.gnss_message
 
Returns a pointer to the message in the list CObservationGPS::messages
 of the requested type. Users normally would prefer using
 CObservationGPS::getMsgByClass()
 to avoid having to perform a dynamic_cast<>() on the returned pointer.
 
 
 std::runtime_error If there is no such a message in the list.
 Please, check existence before calling this method with
 CObservationGPS::hasMsgType()
 
 
 mrpt::obs::gnss::gnss_message_type_t,
 CObservationGPS::getMsgByClass(), CObservationGPS::hasMsgType() 
 
C++: mrpt::obs::CObservationGPS::getMsgByType(const enum mrpt::obs::gnss::gnss_message_type_t) --> struct mrpt::obs::gnss::gnss_message *
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
C++: mrpt::obs::CObservationGPS::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationGPS::getSensorPose(class mrpt::poses::CPose3D &) const --> void
hasMsgType(...)
hasMsgType(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, type_id: mrpt.pymrpt.mrpt.obs.gnss.gnss_message_type_t) -> bool
 
Returns true if the list  contains one of
 the requested type. 
 
 mrpt::obs::gnss::gnss_message_type_t,
 CObservationGPS::getMsgByType() 
 
C++: mrpt::obs::CObservationGPS::hasMsgType(const enum mrpt::obs::gnss::gnss_message_type_t) const --> bool
has_GGA_datum(...)
has_GGA_datum(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> bool
 
true if the corresponding field exists in  
 
C++: mrpt::obs::CObservationGPS::has_GGA_datum() const --> bool
has_RMC_datum(...)
has_RMC_datum(self: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> bool
 
true if the corresponding field exists in  
 
C++: mrpt::obs::CObservationGPS::has_RMC_datum() const --> bool
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationGPS::setSensorPose(const class mrpt::poses::CPose3D &) --> void
swap(...)
swap(self: mrpt.pymrpt.mrpt.obs.CObservationGPS, o: mrpt.pymrpt.mrpt.obs.CObservationGPS) -> None
 
C++: mrpt::obs::CObservationGPS::swap(class mrpt::obs::CObservationGPS &) --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationGPS::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GPS_time_to_UTC(...) from builtins.PyCapsule
GPS_time_to_UTC(*args, **kwargs)
Overloaded function.
 
1. GPS_time_to_UTC(gps_week: int, gps_sec: float, leap_seconds_count: int, utc_out: mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t) -> bool
 
@{ 
 
C++: mrpt::obs::CObservationGPS::GPS_time_to_UTC(uint16_t, double, const int, mrpt::Clock::time_point &) --> bool
 
2. GPS_time_to_UTC(gps_week: int, gps_sec: float, leap_seconds_count: int, utc_out: mrpt.pymrpt.mrpt.system.TTimeParts) -> bool
 
C++: mrpt::obs::CObservationGPS::GPS_time_to_UTC(uint16_t, double, const int, struct mrpt::system::TTimeParts &) --> bool
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationGPS::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &

Data descriptors defined here:
has_satellite_timestamp
messages
originalReceivedTimestamp
sensorPose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationGasSensors(CObservation)
    Declares a class derived from "CObservation" that represents a set of
readings from gas sensors.
 
 
CObservation
 
 
Method resolution order:
CObservationGasSensors
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

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

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

Data descriptors defined here:
m_readings

Data and other attributes defined here:
CMOSmodel = <class 'mrpt.pymrpt.mrpt.obs.CObservationGasSensors.CMOSmodel'>
Declares a class within "CObservationGasSensors" that represents a set
of gas concentration readings from the modelation of a MOS gas sensor
readings.
This class provides the parameters and functions to simulate the inverse
model of a MOS gas sensor.
 
 
CObservationGasSensors
TObservationENose = <class 'mrpt.pymrpt.mrpt.obs.CObservationGasSensors.TObservationENose'>
The structure for each e-nose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationIMU(CObservation)
    This class stores measurements from an Inertial Measurement Unit (IMU)
(attitude estimation, raw gyroscope and accelerometer values), altimeters or
magnetometers.
 
 The order of the values in each entry of
mrpt::obs::CObservationIMU::rawMeasurements is defined as symbolic names in
the enum mrpt::obs::TIMUDataIndex.
 Check it out also for reference on the unit and the coordinate frame used
for each value.
 
 
CObservation
 
 
Method resolution order:
CObservationIMU
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationIMU::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, : mrpt.pymrpt.mrpt.obs.CObservationIMU) -> mrpt.pymrpt.mrpt.obs.CObservationIMU
 
C++: mrpt::obs::CObservationIMU::operator=(const class mrpt::obs::CObservationIMU &) --> class mrpt::obs::CObservationIMU &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationIMU::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> str
 
C++: mrpt::obs::CObservationIMU::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> str
 
C++: mrpt::obs::CObservationIMU::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationIMU) -> bool
 
C++: mrpt::obs::CObservationIMU::exportTxtSupported() const --> bool
get(...)
get(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, idx: mrpt.pymrpt.mrpt.obs.TIMUDataIndex) -> float
 
Gets a given data type, throws if not set. 
 has(), get() 
 
C++: mrpt::obs::CObservationIMU::get(enum mrpt::obs::TIMUDataIndex) const --> double
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationIMU::getSensorPose(class mrpt::poses::CPose3D &) const --> void
has(...)
has(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, idx: mrpt.pymrpt.mrpt.obs.TIMUDataIndex) -> bool
 
Returns true if the given data type is set. 
 set(), get() 
 
C++: mrpt::obs::CObservationIMU::has(enum mrpt::obs::TIMUDataIndex) const --> bool
set(...)
set(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, idx: mrpt.pymrpt.mrpt.obs.TIMUDataIndex, value: float) -> None
 
Sets a given data type, and mark it as present. 
 has(), set() 
 
C++: mrpt::obs::CObservationIMU::set(enum mrpt::obs::TIMUDataIndex, double) --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationIMU, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationIMU::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
dataIsPresent
rawMeasurements
sensorPose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationImage(CObservation)
    Declares a class derived from "CObservation" that encapsules an image from a
camera, whose relative pose to robot is also stored.
        The next figure illustrate the coordinates reference systems involved in
this class:
        <center>
        
        </center>
 
 
CObservationCObservationStereoImages
 
 
Method resolution order:
CObservationImage
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationImage) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationImage::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationImage) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationImage, : mrpt.pymrpt.mrpt.obs.CObservationImage) -> mrpt.pymrpt.mrpt.obs.CObservationImage
 
C++: mrpt::obs::CObservationImage::operator=(const class mrpt::obs::CObservationImage &) --> class mrpt::obs::CObservationImage &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationImage) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationImage::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationImage, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationImage::getSensorPose(class mrpt::poses::CPose3D &) const --> void
getUndistortedImage(...)
getUndistortedImage(self: mrpt.pymrpt.mrpt.obs.CObservationImage, out_img: mrpt.pymrpt.mrpt.img.CImage) -> None
 
Computes the un-distorted image, using the embeded camera
 intrinsic & distortion parameters.
 
C++: mrpt::obs::CObservationImage::getUndistortedImage(class mrpt::img::CImage &) const --> void
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservationImage) -> None
 
Makes sure the image, which may be externally stored, are loaded in
 memory. 
 
 unload
 
C++: mrpt::obs::CObservationImage::load() const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationImage, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationImage::setSensorPose(const class mrpt::poses::CPose3D &) --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservationImage) -> None
 
Unload image, for the case of it being stored in lazy-load mode
  (othewise, the method has no effect).
 
 
 load
 
C++: mrpt::obs::CObservationImage::unload() const --> void

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

Data descriptors defined here:
cameraParams
cameraPose
image

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationOdometry(CObservation)
    An observation of the current (cumulative) odometry for a wheeled robot.
This provides the relative pose of the robot with respect to the `odom`
frame of reference, in "ROS parlance".
 
This kind of observation more naturally fits the "observation-only" rawlog
format, since odometry increments are normally used in "sensory-frame based"
datasets. However, the user is free to use them whenever it is useful. Refer
to the [rawlog format description](rawlog_format.html).
 
 
CObservationCActionRobotMovement2D
 
 
Method resolution order:
CObservationOdometry
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationOdometry::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry, : mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> mrpt.pymrpt.mrpt.obs.CObservationOdometry
 
C++: mrpt::obs::CObservationOdometry::operator=(const class mrpt::obs::CObservationOdometry &) --> class mrpt::obs::CObservationOdometry &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationOdometry::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> str
 
C++: mrpt::obs::CObservationOdometry::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> str
 
C++: mrpt::obs::CObservationOdometry::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry) -> bool
 
C++: mrpt::obs::CObservationOdometry::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationOdometry::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationOdometry, : mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationOdometry::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
encoderLeftTicks
encoderRightTicks
hasEncodersInfo
hasVelocities
odometry
velocityLocal

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationPointCloud(CObservation)
    An observation from any sensor that can be summarized as a pointcloud.
The cloud can comprise plain XYZ points, or can include intensity, or RGB
data; in particular, the point cloud can be any of the derived classes of
mrpt::maps::CPointsMap.
 
The pointcloud has as frame of coordinates the `sensorPose` field, which
may match the origin of the vehicle/robot or not.
 
 
This is a mrpt::obs::CObservation class, but it is defined in the
mrpt_maps_grp library, so it can use mrpt::maps::CPointsMap.
 
 
CObservation, mrpt::maps::CPointsMap
 
 
Method resolution order:
CObservationPointCloud
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationPointCloud::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, o: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, arg0: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, arg0: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, : mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> mrpt.pymrpt.mrpt.obs.CObservationPointCloud
 
C++: mrpt::obs::CObservationPointCloud::operator=(const class mrpt::obs::CObservationPointCloud &) --> class mrpt::obs::CObservationPointCloud &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationPointCloud::clone() const --> class mrpt::rtti::CObject *
getExternalStorageFile(...)
getExternalStorageFile(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> str
 
C++: mrpt::obs::CObservationPointCloud::getExternalStorageFile() const --> const std::string &
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationPointCloud::getSensorPose(class mrpt::poses::CPose3D &) const --> void
isExternallyStored(...)
isExternallyStored(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> bool
 
@{ 
 
C++: mrpt::obs::CObservationPointCloud::isExternallyStored() const --> bool
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
 
                @{ 
 
C++: mrpt::obs::CObservationPointCloud::load() const --> void
overrideExternalStorageFormatFlag(...)
overrideExternalStorageFormatFlag(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, fmt: mrpt.pymrpt.mrpt.obs.CObservationPointCloud.ExternalStorageFormat) -> None
 
C++: mrpt::obs::CObservationPointCloud::overrideExternalStorageFormatFlag(const enum mrpt::obs::CObservationPointCloud::ExternalStorageFormat) --> void
setAsExternalStorage(...)
setAsExternalStorage(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, fileName: str, fmt: mrpt.pymrpt.mrpt.obs.CObservationPointCloud.ExternalStorageFormat) -> None
 
C++: mrpt::obs::CObservationPointCloud::setAsExternalStorage(const std::string &, const enum mrpt::obs::CObservationPointCloud::ExternalStorageFormat) --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, p: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationPointCloud::setSensorPose(const class mrpt::poses::CPose3D &) --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
 
C++: mrpt::obs::CObservationPointCloud::unload() const --> void

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

Data descriptors defined here:
pointcloud
sensorPose

Data and other attributes defined here:
ExternalStorageFormat = <class 'mrpt.pymrpt.mrpt.obs.CObservationPointCloud.ExternalStorageFormat'>

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRFID(CObservation)
    This represents one or more RFID tags observed by a receiver.
 
 
CObservation, mrpt::hwdrivers::CImpinjRFID for a software sensor capable
of reading this kind of observations.
 
 
Method resolution order:
CObservationRFID
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationRFID::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRFID, arg0: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRFID, arg0: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationRFID, : mrpt.pymrpt.mrpt.obs.CObservationRFID) -> mrpt.pymrpt.mrpt.obs.CObservationRFID
 
C++: mrpt::obs::CObservationRFID::operator=(const class mrpt::obs::CObservationRFID &) --> class mrpt::obs::CObservationRFID &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationRFID::clone() const --> class mrpt::rtti::CObject *
getNtags(...)
getNtags(self: mrpt.pymrpt.mrpt.obs.CObservationRFID) -> int
 
C++: mrpt::obs::CObservationRFID::getNtags() const --> uint32_t
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRFID, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::obs::CObservationRFID::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRFID, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
A general method to change the sensor pose on the robot.
  It has no effects in this class
 
 
 getSensorPose  
 
C++: mrpt::obs::CObservationRFID::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
sensorPoseOnRobot
tag_readings

Data and other attributes defined here:
TTagReading = <class 'mrpt.pymrpt.mrpt.obs.CObservationRFID.TTagReading'>
Each of the individual readings of a RFID tag

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRGBD360(CObservation)
    Declares a class derived from "CObservation" that
      encapsules an omnidirectional RGBD measurement from a set of RGBD
sensors.
  This kind of observations can carry one or more of these data fields:
    - 3D point cloud (as float's).
    - 2D range image (as a matrix): Each entry in the matrix
"rangeImage(ROW,COLUMN)" contains a distance or a depth (in meters), depending
on 
    - 2D intensity (grayscale or RGB) image (as a mrpt::img::CImage): For
SwissRanger cameras, a logarithmic A-law compression is used to convert the
original 16bit intensity to a more standard 8bit graylevel.
 
  The coordinates of the 3D point cloud are in millimeters with respect to the
RGB camera origin of coordinates
 
  The 2D images and matrices are stored as common images, with an up->down
rows order and left->right, as usual.
   Optionally, the intensity and confidence channels can be set to
delayed-load images for off-rawlog storage so it saves
   memory by having loaded in memory just the needed images. See the methods
load() and unload().
  Due to the intensive storage requirements of this kind of observations, this
observation is the only one in MRPT
   for which it's recommended to always call "load()" and "unload()" before
and after using the observation, *ONLY* when
   the observation was read from a rawlog dataset, in order to make sure that
all the externally stored data fields are
   loaded and ready in memory.
 
  Classes that grab observations of this type are:
                - mrpt::hwdrivers::CSwissRanger3DCamera
                - mrpt::hwdrivers::CKinect
 
  3D point clouds can be generated at any moment after grabbing with
CObservationRGBD360::unprojectInto() and
CObservationRGBD360::unprojectInto(), provided the correct
   calibration parameters.
 
  
 Starting at serialization version 3 (MRPT 0.9.1+), the 3D point cloud
and the rangeImage can both be stored externally to save rawlog space.
  
 
 Starting at serialization version 5 (MRPT 0.9.5+), the new field 
  
 
 Starting at serialization version 6 (MRPT 0.9.5+), the new field 
 
 
 mrpt::hwdrivers::CSwissRanger3DCamera, mrpt::hwdrivers::COpenNI2_RGBD360,
CObservation
 
 
Method resolution order:
CObservationRGBD360
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationRGBD360::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, arg0: mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, arg0: mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, : mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> mrpt.pymrpt.mrpt.obs.CObservationRGBD360
 
C++: mrpt::obs::CObservationRGBD360::operator=(const class mrpt::obs::CObservationRGBD360 &) --> class mrpt::obs::CObservationRGBD360 &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationRGBD360::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRGBD360::getSensorPose(class mrpt::poses::CPose3D &) const --> void
rangeImage_setSize(...)
rangeImage_setSize(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, HEIGHT: int, WIDTH: int, sensor_id: int) -> None
 
Similar to calling "rangeImage.setSize(H,W)" but this method provides
 memory pooling to speed-up the memory allocation. 
 
C++: mrpt::obs::CObservationRGBD360::rangeImage_setSize(const int, const int, const unsigned int) --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRGBD360, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRGBD360::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
hasIntensityImage
hasRangeImage
maxRange
rangeUnits
sensorPose
stdError

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRange(CObservation)
    Declares a class derived from "CObservation" that
          encapsules a single range measurement, and associated parameters. This
can be used
    for example to store measurements from infrared proximity sensors (IR) or
ultrasonic sensors (sonars).
 
 
CObservation
 
 
Method resolution order:
CObservationRange
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

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

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

Data descriptors defined here:
maxSensorDistance
minSensorDistance
sensedData
sensorConeApperture

Data and other attributes defined here:
TMeasurement = <class 'mrpt.pymrpt.mrpt.obs.CObservationRange.TMeasurement'>

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRawDAQ(CObservation)
    Store raw data from a Data Acquisition (DAQ) device, such that input or
output analog and digital channels, counters from encoders, etc. at one
sampling instant.
 All analog values are assumed to be volts.
On timing:
CObservation::timestamp corresponds to the time of the first samples in
each of the vectors.
CObservationRawDAQ::sample_rate is the sampling rate, in samples per second
per channel, as stored by the source driver.
 
 
CObservation
 
 
Method resolution order:
CObservationRawDAQ
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationRawDAQ::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ, arg0: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ, arg0: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ, : mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> mrpt.pymrpt.mrpt.obs.CObservationRawDAQ
 
C++: mrpt::obs::CObservationRawDAQ::operator=(const class mrpt::obs::CObservationRawDAQ &) --> class mrpt::obs::CObservationRawDAQ &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationRawDAQ::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ, : mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Not used in this class 
 
C++: mrpt::obs::CObservationRawDAQ::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRawDAQ, : mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
Not used in this class 
 
C++: mrpt::obs::CObservationRawDAQ::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
AIN_16bits
AIN_32bits
AIN_8bits
AIN_channel_count
AIN_double
AIN_float
AIN_interleaved
AOUT_16bits
AOUT_8bits
AOUT_double
AOUT_float
CNTRIN_32bits
CNTRIN_double
DIN
DOUT
sample_rate

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationReflectivity(CObservation)
    Declares a class derived from "CObservation" that encapsules a single
short-range reflectivity measurement.
   This can be used for example to store readings from IR sensors (Lego
Mindstorm NXT, etc...).
 
 
mrpt::obs::CReflectivityGridMap2D, CObservation
 
 
Method resolution order:
CObservationReflectivity
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationReflectivity::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity, : mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> mrpt.pymrpt.mrpt.obs.CObservationReflectivity
 
C++: mrpt::obs::CObservationReflectivity::operator=(const class mrpt::obs::CObservationReflectivity &) --> class mrpt::obs::CObservationReflectivity &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationReflectivity::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> str
 
C++: mrpt::obs::CObservationReflectivity::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> str
 
C++: mrpt::obs::CObservationReflectivity::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity) -> bool
 
C++: mrpt::obs::CObservationReflectivity::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationReflectivity::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationReflectivity, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationReflectivity::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
channel
reflectivityLevel
sensorPose
sensorStdNoise

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRobotPose(CObservation)
    An observation providing an alternative robot pose from an external source.
 
 
CObservation
 
 
Method resolution order:
CObservationRobotPose
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationRobotPose::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose, : mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> mrpt.pymrpt.mrpt.obs.CObservationRobotPose
 
C++: mrpt::obs::CObservationRobotPose::operator=(const class mrpt::obs::CObservationRobotPose &) --> class mrpt::obs::CObservationRobotPose &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationRobotPose::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> str
 
C++: mrpt::obs::CObservationRobotPose::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> str
 
C++: mrpt::obs::CObservationRobotPose::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose) -> bool
 
C++: mrpt::obs::CObservationRobotPose::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRobotPose::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRobotPose, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRobotPose::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
pose
sensorPose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationRotatingScan(CObservation)
    A `CObservation`-derived class for raw range data from a 2D or 3D
rotating scanner. This class is the preferred alternative to
CObservationVelodyneScan and CObservation2DRangeScan in MRPT 2.x, since it
exposes range data as an organized matrix, more convenient for feature
detection directly on "range images".
This class can also import data from KITTI dataset-like binary files
containing unorganized (non "undistorted", i.e. without compensation for
lidar motion) point clouds, which get organized into a 2D range image for
easier filtering and postprocessing.
 
Check out the main data fields in the list of members below.
 
 Note that this object has  timestamp fields:
 - The standard `CObservation::timestamp` field in the base class, which
should contain the accurate satellite-based UTC timestamp if available,
and
 - the field originalReceivedTimestamp, with the
local computer-based timestamp based on the reception of the message in
the computer.
 
 Both timestamps correspond to the firing of the first laser in
the first CObservationRotatingScan::scan_packets packet.
 
   
 
API for accurate reconstruction of point clouds from raw range images:
 - generatePointCloud()
 - generatePointCloudAlongSE3Trajectory()
 
 
New in MRPT 2.0.0
 
 
CObservation, mrpt::hwdrivers::CVelodyneScanner
 
 
Method resolution order:
CObservationRotatingScan
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationRotatingScan::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, arg0: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, arg0: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, : mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> mrpt.pymrpt.mrpt.obs.CObservationRotatingScan
 
C++: mrpt::obs::CObservationRotatingScan::operator=(const class mrpt::obs::CObservationRotatingScan &) --> class mrpt::obs::CObservationRotatingScan &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationRotatingScan::clone() const --> class mrpt::rtti::CObject *
fromGeneric(...)
fromGeneric(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, o: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
Will convert from another observation if it's any of the supported
 source types (see fromVelodyne(), fromScan2D(), fromPointCloud()) and
 return true, or will return false otherwise if there is no known way to
 convert from the passed object. 
 
C++: mrpt::obs::CObservationRotatingScan::fromGeneric(const class mrpt::obs::CObservation &) --> bool
fromPointCloud(...)
fromPointCloud(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, o: mrpt.pymrpt.mrpt.obs.CObservationPointCloud) -> None
 
C++: mrpt::obs::CObservationRotatingScan::fromPointCloud(const class mrpt::obs::CObservationPointCloud &) --> void
fromScan2D(...)
fromScan2D(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, o: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan) -> None
 
C++: mrpt::obs::CObservationRotatingScan::fromScan2D(const class mrpt::obs::CObservation2DRangeScan &) --> void
fromVelodyne(...)
fromVelodyne(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, o: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> None
 
@{ 
 
C++: mrpt::obs::CObservationRotatingScan::fromVelodyne(const class mrpt::obs::CObservationVelodyneScan &) --> void
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
@} 
 
C++: mrpt::obs::CObservationRotatingScan::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRotatingScan::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationRotatingScan, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationRotatingScan::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
azimuthSpan
columnCount
has_satellite_timestamp
intensityImage
lidarModel
maxRange
minRange
originalReceivedTimestamp
rangeImage
rangeOtherLayers
rangeResolution
rowCount
sensorPose
startAzimuth
sweepDuration

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationSkeleton(CObservation)
    This class stores a skeleton as tracked by OPENNI2 & NITE2 libraries from
PrimeSense sensors
 
 
CObservation
 
 
Class introduced in MRPT 1.3.1
 
 
Method resolution order:
CObservationSkeleton
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationSkeleton::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton, : mrpt.pymrpt.mrpt.obs.CObservationSkeleton) -> mrpt.pymrpt.mrpt.obs.CObservationSkeleton
 
C++: mrpt::obs::CObservationSkeleton::operator=(const class mrpt::obs::CObservationSkeleton &) --> class mrpt::obs::CObservationSkeleton &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationSkeleton::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationSkeleton::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationSkeleton, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationSkeleton::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
head
left_elbow
left_foot
left_hand
left_hip
left_knee
left_shoulder
neck
right_elbow
right_foot
right_hand
right_hip
right_knee
right_shoulder
sensorPose
torso

Data and other attributes defined here:
TSkeletonJoint = <class 'mrpt.pymrpt.mrpt.obs.CObservationSkeleton.TSkeletonJoint'>
A generic joint for the skeleton observation

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationStereoImages(CObservation)
    Observation class for either a pair of left+right or left+disparity images
from a stereo camera.
 
  To find whether the observation contains a right image and/or a disparity
image, see the fields hasImageDisparity and hasImageRight, respectively.
   This figure illustrates the coordinate frames involved in this class:
 
         <center>
   
  </center>
 
 
 The images stored in this class can be raw or undistorted images. In
the latter case, the "distortion" params of the corresponding "leftCamera" and
"rightCamera" fields should be all zeros.
 
 
 CObservation
 
 
Method resolution order:
CObservationStereoImages
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationStereoImages::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, arg0: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, arg0: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> None
areImagesRectified(...)
areImagesRectified(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> bool
 
This method only checks whether ALL the distortion parameters in 
 are set to zero, which is
 the convention in MRPT to denote that this pair of stereo images has
 been rectified.
 
C++: mrpt::obs::CObservationStereoImages::areImagesRectified() const --> bool
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, : mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> mrpt.pymrpt.mrpt.obs.CObservationStereoImages
 
C++: mrpt::obs::CObservationStereoImages::operator=(const class mrpt::obs::CObservationStereoImages &) --> class mrpt::obs::CObservationStereoImages &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationStereoImages::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::obs::CObservationStereoImages::getSensorPose(class mrpt::poses::CPose3D &) const --> void
getStereoCameraParams(...)
getStereoCameraParams(*args, **kwargs)
Overloaded function.
 
1. getStereoCameraParams(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, out_params: mrpt.pymrpt.mrpt.img.TStereoCamera) -> None
 
Populates a TStereoCamera structure with the parameters in 
  and  
 
 
 areImagesRectified() 
 
C++: mrpt::obs::CObservationStereoImages::getStereoCameraParams(class mrpt::img::TStereoCamera &) const --> void
 
2. getStereoCameraParams(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> mrpt.pymrpt.mrpt.img.TStereoCamera
 
C++: mrpt::obs::CObservationStereoImages::getStereoCameraParams() const --> class mrpt::img::TStereoCamera
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> None
 
C++: mrpt::obs::CObservationStereoImages::load() const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationStereoImages::setSensorPose(const class mrpt::poses::CPose3D &) --> void
setStereoCameraParams(...)
setStereoCameraParams(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, in_params: mrpt.pymrpt.mrpt.img.TStereoCamera) -> None
 
Sets   and  from a
 TStereoCamera structure 
 
C++: mrpt::obs::CObservationStereoImages::setStereoCameraParams(const class mrpt::img::TStereoCamera &) --> void
swap(...)
swap(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImages, o: mrpt.pymrpt.mrpt.obs.CObservationStereoImages) -> None
 
Do an efficient swap of all data members of this object with "o". 
 
C++: mrpt::obs::CObservationStereoImages::swap(class mrpt::obs::CObservationStereoImages &) --> void

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

Data descriptors defined here:
cameraPose
hasImageDisparity
hasImageRight
imageDisparity
imageLeft
imageRight
leftCamera
rightCamera
rightCameraPose

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationStereoImagesFeatures(CObservation)
    Declares a class derived from "CObservation" that encapsules a pair of
cameras and a set of matched image features extracted from them.
 
NOTE: The image features stored in this class are NOT supposed to be
UNDISTORTED, but the TCamera members must provide their distortion params.
A zero-vector of distortion params means a set of UNDISTORTED pixels.
 
 
CObservation
 
 
Method resolution order:
CObservationStereoImagesFeatures
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationStereoImagesFeatures::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, cLeft: mrpt.pymrpt.mrpt.img.TCamera, cRight: mrpt.pymrpt.mrpt.img.TCamera, rCPose: mrpt.pymrpt.mrpt.poses.CPose3DQuat, cPORobot: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, arg0: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> None
 
4. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, arg0: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, : mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures
 
C++: mrpt::obs::CObservationStereoImagesFeatures::operator=(const class mrpt::obs::CObservationStereoImagesFeatures &) --> class mrpt::obs::CObservationStereoImagesFeatures &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationStereoImagesFeatures::clone() const --> class mrpt::rtti::CObject *
getSensorPose(...)
getSensorPose(*args, **kwargs)
Overloaded function.
 
1. getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationStereoImagesFeatures::getSensorPose(class mrpt::poses::CPose3D &) const --> void
 
2. getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
C++: mrpt::obs::CObservationStereoImagesFeatures::getSensorPose(class mrpt::poses::CPose3DQuat &) const --> void
saveFeaturesToTextFile(...)
saveFeaturesToTextFile(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, filename: str) -> None
 
A method for storing the set of observed features in a text file in the
 format: 
 ID ul vl ur vr 
 being (ul,vl) and (ur,vr) the "x" and "y" coordinates for the left and
 right feature, respectively.
 
C++: mrpt::obs::CObservationStereoImagesFeatures::saveFeaturesToTextFile(const std::string &) --> void
setSensorPose(...)
setSensorPose(*args, **kwargs)
Overloaded function.
 
1. setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
A general method to change the sensor pose on the robot in a
 mrpt::poses::CPose3D form.
  Note that most sensors will use the full (6D) CPose3DQuat, but see the
 derived classes for more details or special cases.
 
 
 getSensorPose
 
C++: mrpt::obs::CObservationStereoImagesFeatures::setSensorPose(const class mrpt::poses::CPose3D &) --> void
 
2. setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationStereoImagesFeatures, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3DQuat) -> None
 
A general method to change the sensor pose on the robot in a CPose3DQuat
 form.
  Note that most sensors will use the full (6D) CPose3DQuat, but see the
 derived classes for more details or special cases.
 
 
 getSensorPose
 
C++: mrpt::obs::CObservationStereoImagesFeatures::setSensorPose(const class mrpt::poses::CPose3DQuat &) --> void

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

Data descriptors defined here:
cameraLeft
cameraPoseOnRobot
cameraRight
rightCameraPose
theFeatures

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationVelodyneScan(CObservation)
    A `CObservation`-derived class for RAW DATA (and optionally, point cloud) of
scans from 3D Velodyne LIDAR scanners.
A scan comprises one or more "velodyne packets" (refer to Velodyne user
manual). Normally, a full 360 degrees sweep is included in one observation
object. Note that if a pointcloud is generated inside this class, each point
is annotated with per-point information about its exact azimuth and laser_id
(ring number), an information that is loss when inserting the observation in
a regular mrpt::maps::CPointsMap.
 
Main data fields:
CObservationVelodyneScan::scan_packets with raw data packets.
CObservationVelodyneScan::point_cloud normally empty after grabbing for
efficiency, can be generated calling 
 
Dual return mode is supported (see mrpt::hwdrivers::CVelodyneScanner).
 
Axes convention for point cloud (x,y,z) coordinates:
 
   
 
If it can be assumed that the sensor moves SLOWLY through the environment
(i.e. its pose can be approximated to be the same since the beginning to the
end of one complete scan)
then this observation can be converted / loaded into the following other
classes:
 - Maps of points (these require first generating the pointcloud in this
observation object with
mrpt::obs::CObservationVelodyneScan::generatePointCloud() ):
   - mrpt::maps::CPointsMap::loadFromVelodyneScan() (available in all
derived classes)
   - and the generic method:mrpt::maps::CPointsMap::insertObservation()
 - mrpt::opengl::CPointCloud and mrpt::opengl::CPointCloudColoured is
supported by first converting
   this scan to a mrpt::maps::CPointsMap-derived class, then loading it into
the opengl object.
 
Otherwise, the following API exists for accurate reconstruction of the
sensor path in SE(3) over time:
 - CObservationVelodyneScan::generatePointCloudAlongSE3Trajectory()
 
 Note that this object has  timestamp fields:
 - The standard CObservation::timestamp field in the base class, which
should contain the accurate satellite-based UTC timestamp, and
 - the field CObservationVelodyneScan::originalReceivedTimestamp, with the
local computer-based timestamp based on the reception of the message in the
computer.
 Both timestamps correspond to the firing of the first laser in the
first CObservationVelodyneScan::scan_packets packet.
 
 
New in MRPT 1.4.0
 
 
CObservation, mrpt::maps::CPointsMap, mrpt::hwdrivers::CVelodyneScanner
 
 
Method resolution order:
CObservationVelodyneScan
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationVelodyneScan::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, arg0: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, arg0: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, : mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan
 
C++: mrpt::obs::CObservationVelodyneScan::operator=(const class mrpt::obs::CObservationVelodyneScan &) --> class mrpt::obs::CObservationVelodyneScan &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationVelodyneScan::clone() const --> class mrpt::rtti::CObject *
generatePointCloud(...)
generatePointCloud(*args, **kwargs)
Overloaded function.
 
1. generatePointCloud(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> None
 
2. generatePointCloud(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, params: mrpt::obs::CObservationVelodyneScan::TGeneratePointCloudParameters) -> None
 
Generates the point cloud into the point cloud data fields in 
 where it is stored in local coordinates wrt the sensor (neither the
 vehicle nor the world).
 So, this method does not take into account the possible motion of the
 sensor through the world as it collects LIDAR scans.
 For high dynamics, see the more costly API
 generatePointCloudAlongSE3Trajectory()
 
 
 Points with ranges out of [minRange,maxRange] are discarded; as
 well, other filters are available in 
 
 
 generatePointCloudAlongSE3Trajectory(),
 TGeneratePointCloudParameters
 
C++: mrpt::obs::CObservationVelodyneScan::generatePointCloud(const struct mrpt::obs::CObservationVelodyneScan::TGeneratePointCloudParameters &) --> void
 
3. generatePointCloud(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, dest: mrpt::obs::CObservationVelodyneScan::PointCloudStorageWrapper) -> None
 
4. generatePointCloud(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, dest: mrpt::obs::CObservationVelodyneScan::PointCloudStorageWrapper, params: mrpt::obs::CObservationVelodyneScan::TGeneratePointCloudParameters) -> None
 
C++: mrpt::obs::CObservationVelodyneScan::generatePointCloud(struct mrpt::obs::CObservationVelodyneScan::PointCloudStorageWrapper &, const struct mrpt::obs::CObservationVelodyneScan::TGeneratePointCloudParameters &) --> void
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
C++: mrpt::obs::CObservationVelodyneScan::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::obs::CObservationVelodyneScan::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationVelodyneScan::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
calibration
has_satellite_timestamp
maxRange
minRange
originalReceivedTimestamp
point_cloud
scan_packets
sensorPose

Data and other attributes defined here:
PointCloudStorageWrapper = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.PointCloudStorageWrapper'>
Derive from this class to generate pointclouds into custom containers.
 
 
generatePointCloud()
TGeneratePointCloudParameters = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.TGeneratePointCloudParameters'>
@{
TGeneratePointCloudSE3Results = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.TGeneratePointCloudSE3Results'>
Results for generatePointCloudAlongSE3Trajectory()
TPointCloud = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.TPointCloud'>
See  and
TVelodynePositionPacket = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.TVelodynePositionPacket'>
Payload of one POSITION packet
TVelodyneRawPacket = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.TVelodyneRawPacket'>
One unit of data from the scanner (the payload of one UDP DATA packet)
laser_return_t = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.laser_return_t'>
raw_block_t = <class 'mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan.raw_block_t'>
Raw Velodyne data block.
Each block contains data from either the upper or lower laser
bank.  The device returns three times as many upper bank blocks.

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns one row of data with the data stored in this particular object.
 Do not include newlines. 
 
C++: mrpt::obs::CObservation::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Returns the description of the data columns. Timestamp is automatically
 included as the first column, do not list it. See example implementations
 if interested in enabling this in custom CObservation classes.
 Do not include newlines.
 
C++: mrpt::obs::CObservation::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservation) -> bool
 
                @{ 
 
 Must return true if the class is exportable to TXT/CSV files, in which
 case the other virtual methods in this group must be redefined too.
 
C++: mrpt::obs::CObservation::exportTxtSupported() const --> bool
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationWindSensor(CObservation)
    Declares a class derived from "CObservation" that represents the wind
measurements taken on the robot by an anemometer.
The observation is composed by two magnitudes:
wind speed (m/s)
wind direction (deg)
 
 
CObservation
 
 
Method resolution order:
CObservationWindSensor
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationWindSensor::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor, : mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> mrpt.pymrpt.mrpt.obs.CObservationWindSensor
 
C++: mrpt::obs::CObservationWindSensor::operator=(const class mrpt::obs::CObservationWindSensor &) --> class mrpt::obs::CObservationWindSensor &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationWindSensor::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> str
 
C++: mrpt::obs::CObservationWindSensor::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> str
 
C++: mrpt::obs::CObservationWindSensor::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor) -> bool
 
C++: mrpt::obs::CObservationWindSensor::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::obs::CObservationWindSensor::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationWindSensor, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationWindSensor::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
direction
sensorPoseOnRobot
speed

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CObservationWirelessPower(CObservation)
    This represents a measurement of the wireless strength perceived by the
robot.
 The signal level is given as a percentage.
 
 
CObservation, mrpt::hwdrivers::CWirelessPower for a software sensor
capable of reading this kind of observations.
 
 
Method resolution order:
CObservationWirelessPower
CObservation
mrpt.pymrpt.mrpt.serialization.CSerializable
mrpt.pymrpt.mrpt.rtti.CObject
mrpt.pymrpt.mrpt.Stringifyable
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
GetRuntimeClass(...)
GetRuntimeClass(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CObservationWirelessPower::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower, : mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> mrpt.pymrpt.mrpt.obs.CObservationWirelessPower
 
C++: mrpt::obs::CObservationWirelessPower::operator=(const class mrpt::obs::CObservationWirelessPower &) --> class mrpt::obs::CObservationWirelessPower &
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CObservationWirelessPower::clone() const --> class mrpt::rtti::CObject *
exportTxtDataRow(...)
exportTxtDataRow(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> str
 
C++: mrpt::obs::CObservationWirelessPower::exportTxtDataRow() const --> std::string
exportTxtHeader(...)
exportTxtHeader(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> str
 
C++: mrpt::obs::CObservationWirelessPower::exportTxtHeader() const --> std::string
exportTxtSupported(...)
exportTxtSupported(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower) -> bool
 
C++: mrpt::obs::CObservationWirelessPower::exportTxtSupported() const --> bool
getSensorPose(...)
getSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower, out_sensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
@} 
 
C++: mrpt::obs::CObservationWirelessPower::getSensorPose(class mrpt::poses::CPose3D &) const --> void
setSensorPose(...)
setSensorPose(self: mrpt.pymrpt.mrpt.obs.CObservationWirelessPower, newSensorPose: mrpt.pymrpt.mrpt.poses.CPose3D) -> None
 
C++: mrpt::obs::CObservationWirelessPower::setSensorPose(const class mrpt::poses::CPose3D &) --> void

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

Data descriptors defined here:
power
sensorPoseOnRobot

Methods inherited from CObservation:
asString(...)
asString(self: mrpt.pymrpt.mrpt.obs.CObservation) -> str
 
Return by value version of getDescriptionAsText(std::ostream&).
 
C++: mrpt::obs::CObservation::asString() const --> std::string
getOriginalReceivedTimeStamp(...)
getOriginalReceivedTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
By default, returns CObservation::timestamp but in sensors capable of
 satellite (or otherwise) accurate UTC timing of readings, this contains
 the computer-based timestamp of reception, which may be slightly
 different than  
 
 getTimeStamp()  
 
C++: mrpt::obs::CObservation::getOriginalReceivedTimeStamp() const --> mrpt::Clock::time_point
getTimeStamp(...)
getTimeStamp(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.std.chrono.time_point_mrpt_Clock_std_chrono_duration_long_std_ratio_1_10000000_t
 
Returns CObservation::timestamp for all kind of observations 
 
 getOriginalReceivedTimeStamp() 
 
C++: mrpt::obs::CObservation::getTimeStamp() const --> mrpt::Clock::time_point
load(...)
load(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Makes sure all images and other fields which may be externally stored
 are loaded in memory.
  Note that for all CImages, calling load() is not required since the
 images will be automatically loaded upon first access, so load()
 shouldn't be needed to be called in normal cases by the user.
  If all the data were alredy loaded or this object has no externally
 stored data fields, calling this method has no effects.
 
 
 unload
 
C++: mrpt::obs::CObservation::load() const --> void
sensorPose(...)
sensorPose(self: mrpt.pymrpt.mrpt.obs.CObservation) -> mrpt.pymrpt.mrpt.math.TPose3D
 
synonym with getSensorPose()
 
 
 getSensorPose
 
 
 (New in MRPT 2.3.1)
 
C++: mrpt::obs::CObservation::sensorPose() const --> struct mrpt::math::TPose3D
unload(...)
unload(self: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Unload all images, for the case they being delayed-load images stored in
 external files (othewise, has no effect).
 
 
 load
 
C++: mrpt::obs::CObservation::unload() const --> void

Data descriptors inherited from CObservation:
sensorLabel
timestamp

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 CRawlog(mrpt.pymrpt.mrpt.serialization.CSerializable)
    The main class for loading and processing robotics datasets, or "rawlogs".
 
 Please, refer to the [rawlog format specification](rawlog_format.html).
 
 In short, this class stores a sequence of objects, in one of two possible
formats:
  - Format #1: A sequence of actions and observations. There is a sequence
of objects, where each one can be of one type:
    - An action:        Implemented as a CActionCollection object, the
actuation
of the robot (i.e. odometry increment).
    - Observations: Implemented as a CSensoryFrame, refering to a set of
robot observations from the same pose.
  - Format #2: A sequence of actions and observations. There is a sequence
of objects, where each one can be of one type:
 
 See also [RawLogViewer](app_RawLogViewer.html) for a GUI application for
 quick inspection and analysis of rawlogs.
 
 There is a field for dataset plain-text comments (human-friendly description,
 blocks of parameters, etc.) accessible through CRawlog::getCommentText() and
 CRawlog::setCommentText().
 
 This container provides a STL container-like interface (see CRawlog::begin,
 CRawlog::iterator, ...).
 
 
 There is a static helper method CRawlog::detectImagesDirectory() to
       identify the directory where external images are stored.
 
 
 CSensoryFrame,
     [Dataset file format](robotics_file_formats.html#datasets).
 
 
Method resolution order:
CRawlog
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.obs.CRawlog) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CRawlog::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CRawlog, arg0: mrpt.pymrpt.mrpt.obs.CRawlog) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CRawlog, arg0: mrpt.pymrpt.mrpt.obs.CRawlog) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CRawlog, : mrpt.pymrpt.mrpt.obs.CRawlog) -> mrpt.pymrpt.mrpt.obs.CRawlog
 
C++: mrpt::obs::CRawlog::operator=(const class mrpt::obs::CRawlog &) --> class mrpt::obs::CRawlog &
clear(...)
clear(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> None
 
Clear the sequence of actions/observations. Smart pointers to objects
 previously in the rawlog will remain being valid. 
 
C++: mrpt::obs::CRawlog::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CRawlog::clone() const --> class mrpt::rtti::CObject *
empty(...)
empty(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> bool
 
Returns true if the rawlog is empty 
 
C++: mrpt::obs::CRawlog::empty() const --> bool
getActionObservationPair(...)
getActionObservationPair(self: mrpt.pymrpt.mrpt.obs.CRawlog, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame, rawlogEntry: int) -> bool
 
Gets the next consecutive pair action / observation from the rawlog
 loaded into this object.
 Previous contents of action and observations are discarded, and
 upon return they contain smart pointers to the next objects read from
 the rawlog dataset.
 The input/output variable "rawlogEntry" is just a counter of the last
 rawlog entry read, for logging or monitoring purposes.
 
 
 false if there was some error, true otherwise.
 
 
 readActionObservationPair
 
C++: mrpt::obs::CRawlog::getActionObservationPair(class std::shared_ptr<class mrpt::obs::CActionCollection> &, class std::shared_ptr<class mrpt::obs::CSensoryFrame> &, unsigned long &) const --> bool
getAsAction(...)
getAsAction(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> mrpt.pymrpt.mrpt.obs.CActionCollection
 
Returns the i'th element in the sequence, as being actions, where
 index=0 is the first object.
  If it is not a CActionCollection, it throws an exception. Do neighter
 modify nor delete the returned pointer.
 
 
 size, isAction, getAsObservations, getAsObservation
 
 
 std::exception If index is out of bounds
 
C++: mrpt::obs::CRawlog::getAsAction(size_t) const --> class std::shared_ptr<class mrpt::obs::CActionCollection>
getAsGeneric(...)
getAsGeneric(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> mrpt.pymrpt.mrpt.serialization.CSerializable
 
Returns the i'th element in the sequence, being its class whatever.
 
 
 size, isAction, getAsAction, getAsObservations
 
 
 std::exception If index is out of bounds
 
C++: mrpt::obs::CRawlog::getAsGeneric(size_t) const --> class std::shared_ptr<class mrpt::serialization::CSerializable>
getAsObservation(...)
getAsObservation(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> mrpt.pymrpt.mrpt.obs.CObservation
 
Returns the i'th element in the sequence, as being an observation, where
 index=0 is the first object.
  If it is not an CObservation, it throws an exception. Do neighter
 modify nor delete the returned pointer.
  This is the proper method to obtain the objects stored in a "only
 observations"-rawlog file (named "format #2" above.
 
 
 size, isAction, getAsAction
 
 
 std::exception If index is out of bounds
 
C++: mrpt::obs::CRawlog::getAsObservation(size_t) const --> class std::shared_ptr<class mrpt::obs::CObservation>
getAsObservations(...)
getAsObservations(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> mrpt.pymrpt.mrpt.obs.CSensoryFrame
 
Returns the i'th element in the sequence, as being an action, where
 index=0 is the first object.
  If it is not an CSensoryFrame, it throws an exception.
 
 
 size, isAction, getAsAction, getAsObservation
 
 
 std::exception If index is out of bounds
 
C++: mrpt::obs::CRawlog::getAsObservations(size_t) const --> class std::shared_ptr<class mrpt::obs::CSensoryFrame>
getCommentText(...)
getCommentText(*args, **kwargs)
Overloaded function.
 
1. getCommentText(self: mrpt.pymrpt.mrpt.obs.CRawlog, t: str) -> None
 
Returns the block of comment text for the rawlog 
 
C++: mrpt::obs::CRawlog::getCommentText(std::string &) const --> void
 
2. getCommentText(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> str
 
Returns the block of comment text for the rawlog 
 
C++: mrpt::obs::CRawlog::getCommentText() const --> std::string
getCommentTextAsConfigFile(...)
getCommentTextAsConfigFile(self: mrpt.pymrpt.mrpt.obs.CRawlog, memCfg: mrpt.pymrpt.mrpt.config.CConfigFileMemory) -> None
 
Saves the block of comment text for the rawlog into the passed config
 file object. 
 
C++: mrpt::obs::CRawlog::getCommentTextAsConfigFile(class mrpt::config::CConfigFileMemory &) const --> void
getType(...)
getType(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> mrpt.pymrpt.mrpt.obs.CRawlog.TEntryType
 
Returns the type of a given element.
 
 
 isAction, isObservation
 
C++: mrpt::obs::CRawlog::getType(size_t) const --> enum mrpt::obs::CRawlog::TEntryType
insert(...)
insert(*args, **kwargs)
Overloaded function.
 
1. insert(self: mrpt.pymrpt.mrpt.obs.CRawlog, action: mrpt.pymrpt.mrpt.obs.CAction) -> None
 
Add an action to the sequence: a collection of just one element is
 created.
   The object is duplicated, so the original one can be freed if desired.
 
C++: mrpt::obs::CRawlog::insert(class mrpt::obs::CAction &) --> void
 
2. insert(self: mrpt.pymrpt.mrpt.obs.CRawlog, action: mrpt.pymrpt.mrpt.obs.CActionCollection) -> None
 
Add a set of actions to the sequence; the object is duplicated, so the
 original one can be freed if desired.
 
 
 insert, insert
 
C++: mrpt::obs::CRawlog::insert(class mrpt::obs::CActionCollection &) --> void
 
3. insert(self: mrpt.pymrpt.mrpt.obs.CRawlog, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Add a set of observations to the sequence; the object is duplicated, so
 the original one can be free if desired.
 
C++: mrpt::obs::CRawlog::insert(class mrpt::obs::CSensoryFrame &) --> void
 
4. insert(self: mrpt.pymrpt.mrpt.obs.CRawlog, obj: mrpt.pymrpt.mrpt.serialization.CSerializable) -> None
 
Generic add for a smart pointer to a CSerializable object:
 
C++: mrpt::obs::CRawlog::insert(const class std::shared_ptr<class mrpt::serialization::CSerializable> &) --> void
loadFromRawLogFile(...)
loadFromRawLogFile(*args, **kwargs)
Overloaded function.
 
1. loadFromRawLogFile(self: mrpt.pymrpt.mrpt.obs.CRawlog, fileName: str) -> bool
 
2. loadFromRawLogFile(self: mrpt.pymrpt.mrpt.obs.CRawlog, fileName: str, non_obs_objects_are_legal: bool) -> bool
 
Load the contents from a file containing one of these possibilities:
  - A "CRawlog" object.
  - Directly the sequence of objects (pairs
 `CSensoryFrame`/`CActionCollection` or `CObservation*` objects). In this
 case the method stops reading on EOF of an unrecogniced class name.
  - Only if `non_obs_objects_are_legal` is true, any `CSerializable`
 object is allowed in the log file. Otherwise, the read stops on classes
 different from the ones listed in the item above.
 
 
 It returns false upon error reading or accessing the file.
 
C++: mrpt::obs::CRawlog::loadFromRawLogFile(const std::string &, bool) --> bool
remove(...)
remove(*args, **kwargs)
Overloaded function.
 
1. remove(self: mrpt.pymrpt.mrpt.obs.CRawlog, index: int) -> None
 
Delete the action or observation stored in the given index.
 
 
 std::exception If index is out of bounds
 
C++: mrpt::obs::CRawlog::remove(size_t) --> void
 
2. remove(self: mrpt.pymrpt.mrpt.obs.CRawlog, first_index: int, last_index: int) -> None
 
Delete the elements stored in the given range of indices (including both
 the first and last one).
 
 
 std::exception If any index is out of bounds
 
C++: mrpt::obs::CRawlog::remove(size_t, size_t) --> void
saveToRawLogFile(...)
saveToRawLogFile(self: mrpt.pymrpt.mrpt.obs.CRawlog, fileName: str) -> bool
 
Saves the contents to a rawlog-file, compatible with RawlogViewer (As
 the sequence of internal objects).
  The file is saved with gz-commpressed if MRPT has gz-streams.
 
 
 It returns false if any error is found while writing/creating
 the target file.
 
C++: mrpt::obs::CRawlog::saveToRawLogFile(const std::string &) const --> bool
setCommentText(...)
setCommentText(self: mrpt.pymrpt.mrpt.obs.CRawlog, t: str) -> None
 
Changes the block of comment text for the rawlog 
 
C++: mrpt::obs::CRawlog::setCommentText(const std::string &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.obs.CRawlog) -> int
 
Returns the number of actions / observations object in the sequence. 
 
C++: mrpt::obs::CRawlog::size() const --> size_t
swap(...)
swap(self: mrpt.pymrpt.mrpt.obs.CRawlog, obj: mrpt.pymrpt.mrpt.obs.CRawlog) -> None
 
Efficiently swap the contents of two existing objects.
 
C++: mrpt::obs::CRawlog::swap(class mrpt::obs::CRawlog &) --> void

Static methods defined here:
CreateObject(...) from builtins.PyCapsule
CreateObject() -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CRawlog::CreateObject() --> class std::shared_ptr<class mrpt::rtti::CObject>
GetRuntimeClassIdStatic(...) from builtins.PyCapsule
GetRuntimeClassIdStatic() -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CRawlog::GetRuntimeClassIdStatic() --> const struct mrpt::rtti::TRuntimeClassId &
ReadFromArchive(...) from builtins.PyCapsule
ReadFromArchive(inStream: mrpt.pymrpt.mrpt.serialization.CArchive, rawlogEntryIndex: int) -> Tuple[bool, int, mrpt.pymrpt.mrpt.obs.CActionCollection, mrpt.pymrpt.mrpt.obs.CSensoryFrame, mrpt.pymrpt.mrpt.obs.CObservation]
 
Alternative to getActionObservationPairOrObservation() returning the
 tuple [readOk, rawlogEntryIndex, action,sf, obs], with either (action,sf)
 or (obs) as empty smart pointers depending on the rawlog file format.
 readOk is false on EOF or any other error.
 
C++: mrpt::obs::CRawlog::ReadFromArchive(class mrpt::serialization::CArchive &, const unsigned long) --> class std::tuple<bool, unsigned long, class std::shared_ptr<class mrpt::obs::CActionCollection>, class std::shared_ptr<class mrpt::obs::CSensoryFrame>, class std::shared_ptr<class mrpt::obs::CObservation> >
detectImagesDirectory(...) from builtins.PyCapsule
detectImagesDirectory(rawlogFilename: str) -> str
 
Tries to auto-detect the external-images directory of the given rawlog
file.
  This searches for the existence of the directories:
                - "<rawlog_file_path>/<rawlog_filename>_Images"
                - "<rawlog_file_path>/<rawlog_filename>_images"
                - "<rawlog_file_path>/<rawlog_filename>_IMAGES"
                - "<rawlog_file_path>/Images"  (This one is returned if none of the
choices actually exists).
 
  The results from this function should be written into
mrpt::img::CImage::getImagesPathBase() to enable automatic
  loading of extenrnally-stored images in rawlogs.
 
C++: mrpt::obs::CRawlog::detectImagesDirectory(const std::string &) --> std::string
getActionObservationPairOrObservation(...) from builtins.PyCapsule
getActionObservationPairOrObservation(inStream: mrpt.pymrpt.mrpt.serialization.CArchive, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame, observation: mrpt.pymrpt.mrpt.obs.CObservation, rawlogEntry: int) -> bool
 
Reads a consecutive pair action/sensory_frame OR an observation,
 depending of the rawlog format, from the rawlog opened at some input
 stream.
 Previous contents of action and observations are discarded, and
 upon return they contain smart pointers to the new objects read from
 the rawlog file.
 
 Depending on the rawlog file format, at return either:
  - action/observations contain objects, or
  - observation contains an object.
 
 The input/output variable "rawlogEntry" is just a counter of the last
 rawlog entry read, for logging or monitoring purposes.
 
 
 false if there was some error, true otherwise.
 
 
 getActionObservationPair
 
C++: mrpt::obs::CRawlog::getActionObservationPairOrObservation(class mrpt::serialization::CArchive &, class std::shared_ptr<class mrpt::obs::CActionCollection> &, class std::shared_ptr<class mrpt::obs::CSensoryFrame> &, class std::shared_ptr<class mrpt::obs::CObservation> &, unsigned long &) --> bool
readActionObservationPair(...) from builtins.PyCapsule
readActionObservationPair(inStream: mrpt.pymrpt.mrpt.serialization.CArchive, action: mrpt.pymrpt.mrpt.obs.CActionCollection, observations: mrpt.pymrpt.mrpt.obs.CSensoryFrame, rawlogEntry: int) -> bool
 
Reads a consecutive pair action / observation from the rawlog opened at
 some input stream.
 Previous contents of action and observations are discarded, and
 upon exit they contain smart pointers to the new objects read from the
 rawlog file.
 The input/output variable "rawlogEntry" is just a counter of the last
 rawlog entry read, for logging or monitoring purposes.
 
 
 false if there was some error, true otherwise.
 
 
 getActionObservationPair, getActionObservationPairOrObservation
 
C++: mrpt::obs::CRawlog::readActionObservationPair(class mrpt::serialization::CArchive &, class std::shared_ptr<class mrpt::obs::CActionCollection> &, class std::shared_ptr<class mrpt::obs::CSensoryFrame> &, unsigned long &) --> bool

Data and other attributes defined here:
TEntryType = <class 'mrpt.pymrpt.mrpt.obs.CRawlog.TEntryType'>
const_iterator = <class 'mrpt.pymrpt.mrpt.obs.CRawlog.const_iterator'>
A normal iterator, plus the extra method "getType" to determine the type
of each entry in the sequence.
etActionCollection = <TEntryType.etActionCollection: 1>
etObservation = <TEntryType.etObservation: 2>
etOther = <TEntryType.etOther: 3>
etSensoryFrame = <TEntryType.etSensoryFrame: 0>
iterator = <class 'mrpt.pymrpt.mrpt.obs.CRawlog.iterator'>
A normal iterator, plus the extra method "getType" to determine the
type of each entry in the sequence.

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 CSensoryFrame(mrpt.pymrpt.mrpt.serialization.CSerializable)
    A "sensory frame" is a set of observations taken by the robot
 approximately at the same time, so they can be considered as a multi-sensor
 "snapshot" of the environment.
It can contain "observations" of many different kinds.
 
 New observations can be added using:
 
 
 
 
 
 
 
 
The following methods are equivalent for adding new observations to a
"sensory frame":
CSensoryFrame::operator +=
CSensoryFrame::push_back
CSensoryFrame::insert
 
To examine the objects within a sensory frame, the following methods exist:
CSensoryFrame::getObservationByClass : Looks for some specific observation
class.
CSensoryFrame::begin : To iterate over all observations.
CSensoryFrame::getObservationByIndex : To query by index.
 
Note that `shared_ptr<>`s to the observations are stored, so
a copy of a CSensoryFrame will contain references to the **same** objects,
i.e. copies are shallows copies, not deep copies.
 
 
CObservation
 
 
Method resolution order:
CSensoryFrame
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.obs.CSensoryFrame) -> mrpt.pymrpt.mrpt.rtti.TRuntimeClassId
 
C++: mrpt::obs::CSensoryFrame::GetRuntimeClass() const --> const struct mrpt::rtti::TRuntimeClassId *
__iadd__(...)
__iadd__(*args, **kwargs)
Overloaded function.
 
1. __iadd__(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
You can use "sf1+=sf2;" to add all observations in sf2 to sf1.
 
C++: mrpt::obs::CSensoryFrame::operator+=(const class mrpt::obs::CSensoryFrame &) --> void
 
2. __iadd__(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, obs: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
You can use "sf+=obs;" to add the observation "obs" to the "sf1".
 
C++: mrpt::obs::CSensoryFrame::operator+=(const class std::shared_ptr<class mrpt::obs::CObservation> &) --> void
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, arg0: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, arg0: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, : mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> mrpt.pymrpt.mrpt.obs.CSensoryFrame
 
C++: mrpt::obs::CSensoryFrame::operator=(const class mrpt::obs::CSensoryFrame &) --> class mrpt::obs::CSensoryFrame &
clear(...)
clear(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Clear the container, so it holds no observations. 
 
C++: mrpt::obs::CSensoryFrame::clear() --> void
clone(...)
clone(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> mrpt.pymrpt.mrpt.rtti.CObject
 
C++: mrpt::obs::CSensoryFrame::clone() const --> class mrpt::rtti::CObject *
empty(...)
empty(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> bool
 
Returns true if there are no observations in the list. 
 
C++: mrpt::obs::CSensoryFrame::empty() const --> bool
eraseByIndex(...)
eraseByIndex(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, idx: int) -> None
 
Removes the i'th observation in the list (0=first). 
 
C++: mrpt::obs::CSensoryFrame::eraseByIndex(size_t) --> void
eraseByLabel(...)
eraseByLabel(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, label: str) -> None
 
Removes all the observations that match a given sensorLabel.
 
C++: mrpt::obs::CSensoryFrame::eraseByLabel(const std::string &) --> void
getObservationByIndex(...)
getObservationByIndex(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, idx: int) -> mrpt.pymrpt.mrpt.obs.CObservation
 
C++: mrpt::obs::CSensoryFrame::getObservationByIndex(size_t) --> class std::shared_ptr<class mrpt::obs::CObservation> &
getObservationBySensorLabel(...)
getObservationBySensorLabel(*args, **kwargs)
Overloaded function.
 
1. getObservationBySensorLabel(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, label: str) -> mrpt.pymrpt.mrpt.obs.CObservation
 
2. getObservationBySensorLabel(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, label: str, idx: int) -> mrpt.pymrpt.mrpt.obs.CObservation
 
Returns the i'th observation in the list with the given "sensorLabel"
 (0=first).
 
 
 The observation, or nullptr if not found.
 
 
 begin, size
 
C++: mrpt::obs::CSensoryFrame::getObservationBySensorLabel(const std::string &, size_t) const --> class std::shared_ptr<class mrpt::obs::CObservation>
insert(...)
insert(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, obs: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Synonym with push_back()
 
C++: mrpt::obs::CSensoryFrame::insert(const class std::shared_ptr<class mrpt::obs::CObservation> &) --> void
push_back(...)
push_back(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, obs: mrpt.pymrpt.mrpt.obs.CObservation) -> None
 
Insert a new observation to the sensory frame. 
 
C++: mrpt::obs::CSensoryFrame::push_back(const class std::shared_ptr<class mrpt::obs::CObservation> &) --> void
size(...)
size(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> int
 
Returns the number of observations in the list. 
 
C++: mrpt::obs::CSensoryFrame::size() const --> size_t
swap(...)
swap(self: mrpt.pymrpt.mrpt.obs.CSensoryFrame, sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame) -> None
 
Efficiently swaps the contents of two objects.
 
C++: mrpt::obs::CSensoryFrame::swap(class mrpt::obs::CSensoryFrame &) --> void

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

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

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 CSinCosLookUpTableFor2DScans(pybind11_builtins.pybind11_object)
    A smart look-up-table (LUT) of sin/cos values for 2D laser scans.
Refer to the main method CSinCosLookUpTableFor2DScans::getSinCosForScan()
 
This class is used in mrpt::maps::CPointsMap
 
 
Method resolution order:
CSinCosLookUpTableFor2DScans
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans, arg0: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans, : mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans) -> mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans
 
C++: mrpt::obs::CSinCosLookUpTableFor2DScans::operator=(const class mrpt::obs::CSinCosLookUpTableFor2DScans &) --> class mrpt::obs::CSinCosLookUpTableFor2DScans &
getSinCosForScan(...)
getSinCosForScan(*args, **kwargs)
Overloaded function.
 
1. getSinCosForScan(self: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans, scan: mrpt::obs::CObservation2DRangeScan) -> mrpt::obs::CSinCosLookUpTableFor2DScans::TSinCosValues
 
Return two vectors with the cos and the sin of the angles for each of
 the
 rays in a scan, computing them only the first time and returning a
 cached copy the rest.
  Usage:
 
 
 
 
 
 
 
         
 
C++: mrpt::obs::CSinCosLookUpTableFor2DScans::getSinCosForScan(const class mrpt::obs::CObservation2DRangeScan &) const --> const struct mrpt::obs::CSinCosLookUpTableFor2DScans::TSinCosValues &
 
2. getSinCosForScan(self: mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans, scan_prop: mrpt.pymrpt.mrpt.obs.T2DScanProperties) -> mrpt::obs::CSinCosLookUpTableFor2DScans::TSinCosValues
 
C++: mrpt::obs::CSinCosLookUpTableFor2DScans::getSinCosForScan(const struct mrpt::obs::T2DScanProperties &) const --> const struct mrpt::obs::CSinCosLookUpTableFor2DScans::TSinCosValues &

Data and other attributes defined here:
TSinCosValues = <class 'mrpt.pymrpt.mrpt.obs.CSinCosLookUpTableFor2DScans.TSinCosValues'>
A pair of vectors with the cos and sin values.

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 T2DScanProperties(pybind11_builtins.pybind11_object)
    Auxiliary struct that holds all the relevant *geometry* information about a
2D scan.
This class is used in CSinCosLookUpTableFor2DScans
 
 
 
 
CObservation2DRangeScanCObservation2DRangeScan::getScanProperties,
CSinCosLookUpTableFor2DScans
 
 
Method resolution order:
T2DScanProperties
pybind11_builtins.pybind11_object
builtins.object

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

Data descriptors defined here:
aperture
nRays
rightToLeft

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 T3DPointsProjectionParams(pybind11_builtins.pybind11_object)
    Used in CObservation3DRangeScan::unprojectInto()
 
 
Method resolution order:
T3DPointsProjectionParams
pybind11_builtins.pybind11_object
builtins.object

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

Data descriptors defined here:
MAKE_ORGANIZED
USE_SSE2
decimation
layer
onlyPointsWithIntensityColor
robotPoseInTheWorld
takeIntoAccountSensorPoseOnRobot

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 T3DPointsTo2DScanParams(pybind11_builtins.pybind11_object)
    Used in CObservation3DRangeScan::convertTo2DScan()
 
 
Method resolution order:
T3DPointsTo2DScanParams
pybind11_builtins.pybind11_object
builtins.object

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

Data descriptors defined here:
angle_inf
angle_sup
oversampling_ratio
sensorLabel
use_origin_sensor_pose
z_max
z_min

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 TIMUDataIndex(pybind11_builtins.pybind11_object)
    
Method resolution order:
TIMUDataIndex
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.obs.TIMUDataIndex) -> int
__init__(...)
__init__(self: mrpt.pymrpt.mrpt.obs.TIMUDataIndex, value: int) -> None
__int__(...)
__int__(self: mrpt.pymrpt.mrpt.obs.TIMUDataIndex) -> 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.obs.TIMUDataIndex, 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:
COUNT_IMU_DATA_FIELDS = <TIMUDataIndex.COUNT_IMU_DATA_FIELDS: 31>
IMU_ALTITUDE = <TIMUDataIndex.IMU_ALTITUDE: 19>
IMU_MAG_X = <TIMUDataIndex.IMU_MAG_X: 15>
IMU_MAG_Y = <TIMUDataIndex.IMU_MAG_Y: 16>
IMU_MAG_Z = <TIMUDataIndex.IMU_MAG_Z: 17>
IMU_ORI_QUAT_W = <TIMUDataIndex.IMU_ORI_QUAT_W: 24>
IMU_ORI_QUAT_X = <TIMUDataIndex.IMU_ORI_QUAT_X: 21>
IMU_ORI_QUAT_Y = <TIMUDataIndex.IMU_ORI_QUAT_Y: 22>
IMU_ORI_QUAT_Z = <TIMUDataIndex.IMU_ORI_QUAT_Z: 23>
IMU_PITCH = <TIMUDataIndex.IMU_PITCH: 10>
IMU_PITCH_VEL = <TIMUDataIndex.IMU_PITCH_VEL: 4>
IMU_PITCH_VEL_GLOBAL = <TIMUDataIndex.IMU_PITCH_VEL_GLOBAL: 26>
IMU_PRESSURE = <TIMUDataIndex.IMU_PRESSURE: 18>
IMU_ROLL = <TIMUDataIndex.IMU_ROLL: 11>
IMU_ROLL_VEL = <TIMUDataIndex.IMU_ROLL_VEL: 5>
IMU_ROLL_VEL_GLOBAL = <TIMUDataIndex.IMU_ROLL_VEL_GLOBAL: 27>
IMU_TEMPERATURE = <TIMUDataIndex.IMU_TEMPERATURE: 20>
IMU_WX = <TIMUDataIndex.IMU_ROLL_VEL: 5>
IMU_WY = <TIMUDataIndex.IMU_PITCH_VEL: 4>
IMU_WZ = <TIMUDataIndex.IMU_YAW_VEL: 3>
IMU_X = <TIMUDataIndex.IMU_X: 12>
IMU_X_ACC = <TIMUDataIndex.IMU_X_ACC: 0>
IMU_X_ACC_GLOBAL = <TIMUDataIndex.IMU_X_ACC_GLOBAL: 28>
IMU_X_VEL = <TIMUDataIndex.IMU_X_VEL: 6>
IMU_Y = <TIMUDataIndex.IMU_Y: 13>
IMU_YAW = <TIMUDataIndex.IMU_YAW: 9>
IMU_YAW_VEL = <TIMUDataIndex.IMU_YAW_VEL: 3>
IMU_YAW_VEL_GLOBAL = <TIMUDataIndex.IMU_YAW_VEL_GLOBAL: 25>
IMU_Y_ACC = <TIMUDataIndex.IMU_Y_ACC: 1>
IMU_Y_ACC_GLOBAL = <TIMUDataIndex.IMU_Y_ACC_GLOBAL: 29>
IMU_Y_VEL = <TIMUDataIndex.IMU_Y_VEL: 7>
IMU_Z = <TIMUDataIndex.IMU_Z: 14>
IMU_Z_ACC = <TIMUDataIndex.IMU_Z_ACC: 2>
IMU_Z_ACC_GLOBAL = <TIMUDataIndex.IMU_Z_ACC_GLOBAL: 30>
IMU_Z_VEL = <TIMUDataIndex.IMU_Z_VEL: 8>

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 TPixelLabelInfoBase(pybind11_builtins.pybind11_object)
    Virtual interface to all pixel-label semantic information structs.
 
See CObservation3DRangeScan::pixelLabels
 
 
Method resolution order:
TPixelLabelInfoBase
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(self, /, *args, **kwargs)
Initialize self.  See help(type(self)) for accurate signature.
__str__(...)
__str__(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase) -> str
checkLabel(...)
checkLabel(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, row: int, col: int, label_idx: int) -> bool
 
Checks whether pixel(row,col) has been clasified into category 
 which may be in the range 0 to 7
 
 
 unsetLabel, unsetAll 
 
C++: mrpt::obs::TPixelLabelInfoBase::checkLabel(const int, const int, uint8_t) const --> bool
checkLabelNameExistence(...)
checkLabelNameExistence(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, name: str) -> int
 
Check the existence of a label by returning its associated index.
 -1 if it does not exist. 
 
C++: mrpt::obs::TPixelLabelInfoBase::checkLabelNameExistence(const std::string &) const --> int
getLabelName(...)
getLabelName(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, label_idx: int) -> str
 
C++: mrpt::obs::TPixelLabelInfoBase::getLabelName(unsigned int) const --> const std::string &
getLabels(...)
getLabels(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, row: int, col: int, labels: int) -> None
 
C++: mrpt::obs::TPixelLabelInfoBase::getLabels(const int, const int, unsigned char &) --> void
setLabel(...)
setLabel(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, row: int, col: int, label_idx: int) -> None
 
Mark the pixel(row,col) as classified in the category 
 which may be in the range 0 to MAX_NUM_LABELS-1
 Note that 0 is a valid label index, it does not mean "no label" 
 
 
 unsetLabel, unsetAll 
 
C++: mrpt::obs::TPixelLabelInfoBase::setLabel(const int, const int, uint8_t) --> void
setLabelName(...)
setLabelName(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, label_idx: int, name: str) -> None
 
C++: mrpt::obs::TPixelLabelInfoBase::setLabelName(unsigned int, const std::string &) --> void
setSize(...)
setSize(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, NROWS: int, NCOLS: int) -> None
 
Resizes the matrix pixelLabels to the given size, setting all
 bitfields to zero (that is, all pixels are assigned NONE category).
 
C++: mrpt::obs::TPixelLabelInfoBase::setSize(const int, const int) --> void
unsetAll(...)
unsetAll(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, row: int, col: int, label_idx: int) -> None
 
Removes all categories for pixel(row,col)  
 setLabel, unsetLabel
 
C++: mrpt::obs::TPixelLabelInfoBase::unsetAll(const int, const int, uint8_t) --> void
unsetLabel(...)
unsetLabel(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, row: int, col: int, label_idx: int) -> None
 
For the pixel(row,col), removes its classification into the category
  which may be in the range 0 to 7
 Note that 0 is a valid label index, it does not mean "no label" 
 
 
 setLabel, unsetAll 
 
C++: mrpt::obs::TPixelLabelInfoBase::unsetLabel(const int, const int, uint8_t) --> void
writeToStream(...)
writeToStream(self: mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase, out: mrpt.pymrpt.mrpt.serialization.CArchive) -> None
 
C++: mrpt::obs::TPixelLabelInfoBase::writeToStream(class mrpt::serialization::CArchive &) const --> void

Static methods defined here:
readAndBuildFromStream(...) from builtins.PyCapsule
readAndBuildFromStream(in: mrpt.pymrpt.mrpt.serialization.CArchive) -> mrpt.pymrpt.mrpt.obs.TPixelLabelInfoBase
 
C++: mrpt::obs::TPixelLabelInfoBase::readAndBuildFromStream(class mrpt::serialization::CArchive &) --> struct mrpt::obs::TPixelLabelInfoBase *

Readonly properties defined here:
BITFIELD_BYTES

Data descriptors defined here:
pixelLabelNames

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 TRangeImageFilter(pybind11_builtins.pybind11_object)
    Mainly for internal use within
CObservation3DRangeScan::unprojectInto()
 
 
Method resolution order:
TRangeImageFilter
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilter, filter_params: mrpt.pymrpt.mrpt.obs.TRangeImageFilterParams) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilter) -> None
 
3. __init__(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilter, arg0: mrpt.pymrpt.mrpt.obs.TRangeImageFilter) -> None
do_range_filter(...)
do_range_filter(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilter, r: int, c: int, D: float) -> bool
 
Returns true if the point (r,c) with depth D passes all filters. 
 
C++: mrpt::obs::TRangeImageFilter::do_range_filter(size_t, size_t, const float) const --> bool

Data descriptors defined here:
fp

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 TRangeImageFilterParams(pybind11_builtins.pybind11_object)
    Used in CObservation3DRangeScan::unprojectInto()
 
 
Method resolution order:
TRangeImageFilterParams
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilterParams) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.TRangeImageFilterParams, arg0: mrpt.pymrpt.mrpt.obs.TRangeImageFilterParams) -> None

Data descriptors defined here:
mark_invalid_ranges
rangeCheckBetween

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

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

Data descriptors defined here:
ID
pixels

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 VelodyneCalibration(pybind11_builtins.pybind11_object)
    Velodyne calibration data, for usage in mrpt::obs::CObservationVelodyneScan
 
It is mandatory to use some calibration data to convert Velodyne scans into
3D point clouds. Users should
normally use the XML files provided by the manufacturer with each scanner,
but default calibration files can be
loaded with 
 
 
New in MRPT 1.4.0
 
 
CObservationVelodyneScan, CVelodyneScanner
 
 
Method resolution order:
VelodyneCalibration
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, arg0: mrpt.pymrpt.mrpt.obs.VelodyneCalibration) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, : mrpt.pymrpt.mrpt.obs.VelodyneCalibration) -> mrpt.pymrpt.mrpt.obs.VelodyneCalibration
 
C++: mrpt::obs::VelodyneCalibration::operator=(const struct mrpt::obs::VelodyneCalibration &) --> struct mrpt::obs::VelodyneCalibration &
clear(...)
clear(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration) -> None
 
Clear all previous contents 
 
C++: mrpt::obs::VelodyneCalibration::clear() --> void
empty(...)
empty(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration) -> bool
 
Returns true if no calibration has been loaded yet 
 
C++: mrpt::obs::VelodyneCalibration::empty() const --> bool
loadFromXMLFile(...)
loadFromXMLFile(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, velodyne_calibration_xml_filename: str) -> bool
 
Loads calibration from file, in the format supplied by the manufacturer.
 
 
 false on any error, true on success 
 
C++: mrpt::obs::VelodyneCalibration::loadFromXMLFile(const std::string &) --> bool
loadFromXMLText(...)
loadFromXMLText(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, xml_file_contents: str) -> bool
 
Loads calibration from a string containing an entire XML calibration
 file. 
 
 loadFromXMLFile 
 false on any error, true on success 
 
C++: mrpt::obs::VelodyneCalibration::loadFromXMLText(const std::string &) --> bool
loadFromYAMLFile(...)
loadFromYAMLFile(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, velodyne_calib_yaml_filename: str) -> bool
 
Loads calibration from a YAML calibration file.
 
 
 loadFromYAMLText, loadFromXMLFile
 
 
 false on any error, true on success 
 
C++: mrpt::obs::VelodyneCalibration::loadFromYAMLFile(const std::string &) --> bool
loadFromYAMLText(...)
loadFromYAMLText(self: mrpt.pymrpt.mrpt.obs.VelodyneCalibration, yaml_file_contents: str) -> bool
 
Loads calibration from a string containing an entire YAML calibration
 file. 
 
 loadFromYAMLFile, loadFromXMLFile 
 false on any error,
 true on success 
 
C++: mrpt::obs::VelodyneCalibration::loadFromYAMLText(const std::string &) --> bool

Static methods defined here:
LoadDefaultCalibration(...) from builtins.PyCapsule
LoadDefaultCalibration(lidar_model: str) -> mrpt.pymrpt.mrpt.obs.VelodyneCalibration
 
Loads default calibration files for common LIDAR models.
 
 
 Valid model names are: `VLP16`, `HDL32`, `HDL64`
 
 
 It always return a calibration structure, but it may be empty if
 the model name is unknown. See 
 
 
 Default files can be inspected in `[MRPT_SRC or
 /usr]/share/mrpt/config_files/rawlog-grabber/velodyne_default_calib_{*}.xml`
 
C++: mrpt::obs::VelodyneCalibration::LoadDefaultCalibration(const std::string &) --> const struct mrpt::obs::VelodyneCalibration &

Data descriptors defined here:
laser_corrections

Data and other attributes defined here:
PerLaserCalib = <class 'mrpt.pymrpt.mrpt.obs.VelodyneCalibration.PerLaserCalib'>

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 VisualizationParameters(pybind11_builtins.pybind11_object)
    Here we can customize the way observations will be rendered as 3D objects
 in obs_to_viz(), obs3Dscan_to_viz(), etc.
 
 
obs_to_viz(), obs3Dscan_to_viz()
 
 
Method resolution order:
VisualizationParameters
pybind11_builtins.pybind11_object
builtins.object

Methods defined here:
__init__(...)
__init__(*args, **kwargs)
Overloaded function.
 
1. __init__(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters) -> None
 
2. __init__(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, arg0: mrpt.pymrpt.mrpt.obs.VisualizationParameters) -> None
assign(...)
assign(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, : mrpt.pymrpt.mrpt.obs.VisualizationParameters) -> mrpt.pymrpt.mrpt.obs.VisualizationParameters
 
C++: mrpt::obs::VisualizationParameters::operator=(const struct mrpt::obs::VisualizationParameters &) --> struct mrpt::obs::VisualizationParameters &
load_from_ini_file(...)
load_from_ini_file(*args, **kwargs)
Overloaded function.
 
1. load_from_ini_file(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, cfg: mrpt.pymrpt.mrpt.config.CConfigFileBase) -> None
 
2. load_from_ini_file(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, cfg: mrpt.pymrpt.mrpt.config.CConfigFileBase, section: str) -> None
 
C++: mrpt::obs::VisualizationParameters::load_from_ini_file(const class mrpt::config::CConfigFileBase &, const std::string &) --> void
save_to_ini_file(...)
save_to_ini_file(*args, **kwargs)
Overloaded function.
 
1. save_to_ini_file(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, cfg: mrpt.pymrpt.mrpt.config.CConfigFileBase) -> None
 
2. save_to_ini_file(self: mrpt.pymrpt.mrpt.obs.VisualizationParameters, cfg: mrpt.pymrpt.mrpt.config.CConfigFileBase, section: str) -> None
 
C++: mrpt::obs::VisualizationParameters::save_to_ini_file(class mrpt::config::CConfigFileBase &, const std::string &) const --> void

Data descriptors defined here:
axisLimits
axisTickFrequency
axisTickTextSize
colorFromRGBimage
colorMap
colorizeByAxis
drawSensorPose
invertColorMapping
onlyPointsWithColor
pointSize
points2DscansColor
sensorPoseScale
showAxis
showPointsIn2Dscans
showSurfaceIn2Dscans
surface2DscansColor

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
       
format_externals_filename(...) method of builtins.PyCapsule instance
format_externals_filename(obs: mrpt.pymrpt.mrpt.obs.CObservation, fmt: str) -> str
 
Replaces format placeholders in a string according to an observation:
  - `${type}` is replaced by: `img`, `stereo`, `3dcam` for single images,
     stereo images and depth camera observations, respectively, or `other`
     otherwise.
  - `${label}` is replaced by the observation `sensorLabel` field.
  - `%f` with any standard `printf()` format modifiers will be replaced by
    UNIX timestamp (with fractions of seconds) of the observation.
  - Anything else will be left unmodified.
 
  For example, the default format string used in
  `rawlog-edit --rename-externals` is `"${type}_${label}_%.06%f"`.
 
 
 
 
 (new in MRPT 2.4.1)
 
C++: mrpt::obs::format_externals_filename(const class mrpt::obs::CObservation &, const std::string &) --> std::string
obs2Dscan_to_viz(...) method of builtins.PyCapsule instance
obs2Dscan_to_viz(obs: mrpt.pymrpt.mrpt.obs.CObservation2DRangeScan, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Clears `out` and creates a visualization of the given observation.
 
C++: mrpt::obs::obs2Dscan_to_viz(const class std::shared_ptr<class mrpt::obs::CObservation2DRangeScan> &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> void
obs3Dscan_to_viz(...) method of builtins.PyCapsule instance
obs3Dscan_to_viz(obs: mrpt.pymrpt.mrpt.obs.CObservation3DRangeScan, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Clears `out` and creates a visualization of the given observation.
 
C++: mrpt::obs::obs3Dscan_to_viz(const class std::shared_ptr<class mrpt::obs::CObservation3DRangeScan> &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> void
obsPointCloud_to_viz(...) method of builtins.PyCapsule instance
obsPointCloud_to_viz(obs: mrpt.pymrpt.mrpt.obs.CObservationPointCloud, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Clears `out` and creates a visualization of the given observation.
 
C++: mrpt::obs::obsPointCloud_to_viz(const class std::shared_ptr<class mrpt::obs::CObservationPointCloud> &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> void
obsVelodyne_to_viz(...) method of builtins.PyCapsule instance
obsVelodyne_to_viz(obs: mrpt.pymrpt.mrpt.obs.CObservationVelodyneScan, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> None
 
Clears `out` and creates a visualization of the given observation.
 
C++: mrpt::obs::obsVelodyne_to_viz(const class std::shared_ptr<class mrpt::obs::CObservationVelodyneScan> &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> void
obs_to_viz(...) method of builtins.PyCapsule instance
obs_to_viz(*args, **kwargs)
Overloaded function.
 
1. obs_to_viz(obs: mrpt.pymrpt.mrpt.obs.CObservation, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> bool
 
Clears `out` and creates a visualization of the given observation,
  dispatching the call according to the actual observation class.
  
 
 true if type has known visualizer, false if it does not (then, `out`
          will be empty)
 
  
 This and the accompanying functions are defined in namespace
        mrpt::obs, but you must link against mrpt::maps too to have their
        definitions.
 
C++: mrpt::obs::obs_to_viz(const class std::shared_ptr<class mrpt::obs::CObservation> &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> bool
 
2. obs_to_viz(sf: mrpt.pymrpt.mrpt.obs.CSensoryFrame, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters, out: mrpt.pymrpt.mrpt.opengl.CSetOfObjects) -> bool
 
Clears `out` and creates a visualization of the given sensory-frame,
  dispatching the call according to the actual observation classes inside the
 SF.
 
  
 true if type has known visualizer, false if it does not (then, `out`
          will be empty)
 
  
 This and the accompanying functions are defined in namespace
        mrpt::obs, but you must link against mrpt::maps too to have their
        definitions.
 
C++: mrpt::obs::obs_to_viz(const class mrpt::obs::CSensoryFrame &, const struct mrpt::obs::VisualizationParameters &, class mrpt::opengl::CSetOfObjects &) --> bool
recolorize3Dpc(...) method of builtins.PyCapsule instance
recolorize3Dpc(pnts: mrpt.pymrpt.mrpt.opengl.CPointCloudColoured, p: mrpt.pymrpt.mrpt.obs.VisualizationParameters) -> None
 
Recolorize a pointcloud according to the given parameters
 
C++: mrpt::obs::recolorize3Dpc(const class std::shared_ptr<class mrpt::opengl::CPointCloudColoured> &, const struct mrpt::obs::VisualizationParameters &) --> void

 
Data
        COUNT_IMU_DATA_FIELDS = <TIMUDataIndex.COUNT_IMU_DATA_FIELDS: 31>
IMU_ALTITUDE = <TIMUDataIndex.IMU_ALTITUDE: 19>
IMU_MAG_X = <TIMUDataIndex.IMU_MAG_X: 15>
IMU_MAG_Y = <TIMUDataIndex.IMU_MAG_Y: 16>
IMU_MAG_Z = <TIMUDataIndex.IMU_MAG_Z: 17>
IMU_ORI_QUAT_W = <TIMUDataIndex.IMU_ORI_QUAT_W: 24>
IMU_ORI_QUAT_X = <TIMUDataIndex.IMU_ORI_QUAT_X: 21>
IMU_ORI_QUAT_Y = <TIMUDataIndex.IMU_ORI_QUAT_Y: 22>
IMU_ORI_QUAT_Z = <TIMUDataIndex.IMU_ORI_QUAT_Z: 23>
IMU_PITCH = <TIMUDataIndex.IMU_PITCH: 10>
IMU_PITCH_VEL = <TIMUDataIndex.IMU_PITCH_VEL: 4>
IMU_PITCH_VEL_GLOBAL = <TIMUDataIndex.IMU_PITCH_VEL_GLOBAL: 26>
IMU_PRESSURE = <TIMUDataIndex.IMU_PRESSURE: 18>
IMU_ROLL = <TIMUDataIndex.IMU_ROLL: 11>
IMU_ROLL_VEL = <TIMUDataIndex.IMU_ROLL_VEL: 5>
IMU_ROLL_VEL_GLOBAL = <TIMUDataIndex.IMU_ROLL_VEL_GLOBAL: 27>
IMU_TEMPERATURE = <TIMUDataIndex.IMU_TEMPERATURE: 20>
IMU_WX = <TIMUDataIndex.IMU_ROLL_VEL: 5>
IMU_WY = <TIMUDataIndex.IMU_PITCH_VEL: 4>
IMU_WZ = <TIMUDataIndex.IMU_YAW_VEL: 3>
IMU_X = <TIMUDataIndex.IMU_X: 12>
IMU_X_ACC = <TIMUDataIndex.IMU_X_ACC: 0>
IMU_X_ACC_GLOBAL = <TIMUDataIndex.IMU_X_ACC_GLOBAL: 28>
IMU_X_VEL = <TIMUDataIndex.IMU_X_VEL: 6>
IMU_Y = <TIMUDataIndex.IMU_Y: 13>
IMU_YAW = <TIMUDataIndex.IMU_YAW: 9>
IMU_YAW_VEL = <TIMUDataIndex.IMU_YAW_VEL: 3>
IMU_YAW_VEL_GLOBAL = <TIMUDataIndex.IMU_YAW_VEL_GLOBAL: 25>
IMU_Y_ACC = <TIMUDataIndex.IMU_Y_ACC: 1>
IMU_Y_ACC_GLOBAL = <TIMUDataIndex.IMU_Y_ACC_GLOBAL: 29>
IMU_Y_VEL = <TIMUDataIndex.IMU_Y_VEL: 7>
IMU_Z = <TIMUDataIndex.IMU_Z: 14>
IMU_Z_ACC = <TIMUDataIndex.IMU_Z_ACC: 2>
IMU_Z_ACC_GLOBAL = <TIMUDataIndex.IMU_Z_ACC_GLOBAL: 30>
IMU_Z_VEL = <TIMUDataIndex.IMU_Z_VEL: 8>