| | |
- 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 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.
CAction, CRawlog
|
| |
- 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
CAction, CActionRobotMovement3D,
|
| |
- 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 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:
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>
CObservation, CObservationStereoImages
|
| |
- 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).
CObservation, CActionRobotMovement2D
|
| |
- 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 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 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.
| |