`mrpt.obs`

computeFromOdometry(odometryIncrement: mrpt.poses.CPose2D, options: CActionRobotMovement2D) → None: Computes poseChange from an odometry increment and a motion model

drawSingleSample() → mrpt.poses.CPose2D: Draws a sample from the motion model

class mrpt.obs.CActionRobotMovement3D

C++ API: class mrpt::obs::CActionRobotMovement3D

Bases: CAction

Represents a probabilistic motion increment in SE(3).

class TMotionModelOptions

Options of the probabilistic 3D motion models.

class TOptions_6DOFModel

Parameters of the particle-based 6DOF motion model.

a1: float

a10: float

a2: float

a3: float

a4: float

a5: float

a6: float

a7: float

a8: float

a9: float

additional_std_XYZ: float

additional_std_angle: float

nParticlesCount: int

mm6DOFModel: CActionRobotMovement3D

property poseChange: mrpt.poses.CPose3DPDFGaussian: Pose change as a CPose3DPDFGaussian

rawOdometryIncrementReading: mrpt.poses.CPose3D

computeFromOdometry(odometryIncrement: mrpt.poses.CPose3D, options: CActionRobotMovement3D) → None: Computes poseChange from an odometry increment and a motion model

class mrpt.obs.CObservation

C++ API: class mrpt::obs::CObservation

Bases: mrpt.serialization.CSerializable

Base class of all sensor observations: a timestamp, a sensor label and data.

sensorLabel: str

timestamp: datetime.timedelta

GetRuntimeClass() → mrpt.rtti.TRuntimeClassId: Returns information about the class of an object in runtime.

getSensorPose() → mrpt.poses.CPose3D: Returns the sensor pose (6D) relative to the robot

getTimeStamp() → datetime.timedelta: Returns the observation timestamp.

load() → None: Loads externally-stored data (e.g. images), if any

unload() → None: Frees externally-stored data from memory, if any

class mrpt.obs.CObservation2DRangeScan

C++ API: class mrpt::obs::CObservation2DRangeScan

Bases: CObservation

A “CObservation”-derived class that represents a 2D range scan measurement (typically from a laser scanner).

property aperture: float: Field-of-view in radians

property maxRange: float: Maximum sensor range in meters

property rightToLeft: bool: Scan direction: True=CCW, False=CW

property sensorPose: mrpt.poses.CPose3D: Sensor 6D pose relative to robot base

getScanRange(arg0: int) → float: Returns the range of the i-th ray, in meters.

getScanRangeValidity(arg0: int) → bool: Returns whether the i-th ray has a valid range (false: no echo).

getScanRangesAsNumpy() → numpy.ndarray: Returns all scan ranges as a 1D float32 numpy array

getScanSize() → int: Get number of scan rays.

getValidRangesAsNumpy() → numpy.ndarray: Returns validity flags as a 1D bool numpy array

resizeScan(arg0: int) → None: Resizes all data vectors to allocate a given number of scan rays.

setScanRange(arg0: int, arg1: float) → None: Sets the range of the i-th ray, in meters.

setScanRangeValidity(arg0: int, arg1: bool) → None: Sets whether the i-th ray has a valid range.

class mrpt.obs.CObservation3DRangeScan

C++ API: class mrpt::obs::CObservation3DRangeScan

Bases: CObservation

A depth or RGB+D image from a time-of-flight or structured-light sensor.

property cameraParams: mrpt.img.TCamera: Depth camera intrinsics

property cameraParamsIntensity: mrpt.img.TCamera: Intensity camera intrinsics

property rangeUnits: float: Meters per unit in the raw range image

property range_is_depth: bool: True: ranges are depth (Z); False: distances along each pixel ray

confidenceImage: mrpt.img.CImage

hasConfidenceImage: bool

hasIntensityImage: bool

hasPoints3D: bool

hasRangeImage: bool

intensityImage: mrpt.img.CImage

maxRange: float

relativePoseIntensityWRTDepth: mrpt.poses.CPose3D

sensorPose: mrpt.poses.CPose3D

stdError: float

getPoints3DAsNumpy() → numpy.ndarray: Returns the 3D points as an Nx3 float32 array (see unprojectInto())

getRangeImageAsNumpy() → numpy.ndarray: Returns the range image as an HxW float32 array, in meters (0 = invalid)

getRangeImageRawAsNumpy() → numpy.ndarray: Returns the raw range image as an HxW uint16 array (multiply by rangeUnits for meters)

getScanSize() → int: Number of 3D points (if hasPoints3D)

setRangeImageFromNumpy(ranges: numpy.ndarray) → None: Sets the range image from an HxW array of ranges in meters. NaN or infinite values are stored as 0 (invalid).

unprojectInto(params: T3DPointsProjectionParams = ...) → None: Computes the 3D points (points3D_*) from the range image and camera intrinsics

class mrpt.obs.CObservationGPS

C++ API: class mrpt::obs::CObservationGPS

Bases: CObservation

This class stores messages from GNSS or GNSS+IMU devices, from consumer-grade inexpensive GPS receivers to Novatel/Topcon/… advanced RTK solutions.

property covariance_enu: mrpt.math.CMatrixDouble33 | None: Optional 3x3 ENU position covariance (m^2), or None

fix_type: GnssFixType

has_satellite_timestamp: bool

originalReceivedTimestamp: datetime.timedelta

sensorPose: mrpt.poses.CPose3D

clear() → None: Removes all GNSS messages

getGGA() → gnss.Message_NMEA_GGA | None: Returns a copy of the NMEA GGA message, or None

getGLL() → gnss.Message_NMEA_GLL | None: Returns a copy of the NMEA GLL message, or None

getGSA() → gnss.Message_NMEA_GSA | None: Returns a copy of the NMEA GSA message, or None

getMessageTypes() → list[str]: Names of the GNSS messages in this observation (e.g. NMEA_GGA, NV_OEM6_BESTPOS); str(obs) dumps all of them

getRMC() → gnss.Message_NMEA_RMC | None: Returns a copy of the NMEA RMC message, or None

getVTG() → gnss.Message_NMEA_VTG | None: Returns a copy of the NMEA VTG message, or None

getZDA() → gnss.Message_NMEA_ZDA | None: Returns a copy of the NMEA ZDA message, or None

hasGGA() → bool: True if the observation has an NMEA GGA message

hasGLL() → bool: True if the observation has an NMEA GLL message

hasGSA() → bool: True if the observation has an NMEA GSA message

hasRMC() → bool: True if the observation has an NMEA RMC message

hasVTG() → bool: True if the observation has an NMEA VTG message

hasZDA() → bool: True if the observation has an NMEA ZDA message

setGGA(msg: gnss.Message_NMEA_GGA) → None: Stores (or replaces) the NMEA GGA message

setGLL(msg: gnss.Message_NMEA_GLL) → None: Stores (or replaces) the NMEA GLL message

setGSA(msg: gnss.Message_NMEA_GSA) → None: Stores (or replaces) the NMEA GSA message

setRMC(msg: gnss.Message_NMEA_RMC) → None: Stores (or replaces) the NMEA RMC message

setVTG(msg: gnss.Message_NMEA_VTG) → None: Stores (or replaces) the NMEA VTG message

setZDA(msg: gnss.Message_NMEA_ZDA) → None: Stores (or replaces) the NMEA ZDA message

class mrpt.obs.CObservationIMU

C++ API: class mrpt::obs::CObservationIMU

Bases: CObservation

Measurements of an inertial measurement unit (IMU): orientation, angular velocity, accelerations, etc.

get(idx: TIMUDataIndex) → float: Returns one measurement (it must have been set).

getRawMeasurementsAsNumpy() → numpy.ndarray: Returns raw IMU measurements as 1D float64 numpy array

set(idx: TIMUDataIndex, value: float) → None: Sets one measurement and marks it as valid.

class mrpt.obs.CObservationImage

C++ API: class mrpt::obs::CObservationImage

Bases: CObservation

An image from a camera, along with its pose on the robot and intrinsic parameters.

cameraParams: mrpt.img.TCamera

cameraPose: mrpt.poses.CPose3D

image: mrpt.img.CImage

class mrpt.obs.CObservationOdometry

C++ API: class mrpt::obs::CObservationOdometry

Bases: CObservation

An observation of the current (cumulative) odometry for a wheeled robot.

odometry: mrpt.poses.CPose2D

class mrpt.obs.CObservationRobotPose

C++ API: class mrpt::obs::CObservationRobotPose

Bases: CObservation

An observation providing an alternative robot pose from an external source.

pose: mrpt.poses.CPose3DPDFGaussian

class mrpt.obs.CObservationRotatingScan

C++ API: class mrpt::obs::CObservationRotatingScan

Bases: CObservation

A scan of a rotating LiDAR (Velodyne, Ouster, …) as organized range and intensity images: one row per laser, one column per firing.

property azimuthSpan: float: Azimuth span of the columns (rad).

property columnCount: int: Number of firings (image columns).

property intensityImage: numpy.ndarray: Intensities (uint8, rows x columns), a copy.

property lidarModel: str: LiDAR model name.

property maxRange: float: Maximum valid range (m).

property minRange: float: Minimum valid range (m).

property organizedPoints: numpy.ndarray: Points of each range image cell (float32, rows x columns x 3), in the sensor frame.

property rangeImage: numpy.ndarray: Ranges (uint16, rows x columns; multiply by rangeResolution for meters, 0: invalid). A copy: assign a whole array to change it.

property rangeResolution: float: Range (m) of one unit of rangeImage.

property rowCount: int: Number of lasers (image rows).

property sensorPose: mrpt.poses.CPose3D: Pose of the sensor on the robot.

property startAzimuth: float: Azimuth of the first column (rad).

property sweepDuration: float: Duration of the scan (s).

has_satellite_timestamp: bool

originalReceivedTimestamp: datetime.timedelta

fromGeneric(obs: CObservation) → bool: Fills this scan from any supported observation. Returns False if not supported.

fromScan2D(obs: CObservation2DRangeScan) → None: Fills this scan from a 2D LiDAR scan.

fromVelodyne(obs: CObservationVelodyneScan) → None: Fills this scan from a Velodyne one (with a calibration).

class mrpt.obs.CObservationStereoImages

C++ API: class mrpt::obs::CObservationStereoImages

Bases: CObservation

A pair of images from a stereo camera (left and, optionally, right and disparity), with the camera parameters and poses.

property cameraPose: mrpt.poses.CPose3DQuat: Pose of the left camera on the robot.

property hasImageDisparity: bool: Whether imageDisparity holds an image.

property hasImageRight: bool: Whether imageRight holds an image.

property imageDisparity: mrpt.img.CImage: Disparity image (only valid if hasImageDisparity).

property imageLeft: mrpt.img.CImage: Left camera image.

property imageRight: mrpt.img.CImage: Right camera image (only valid if hasImageRight).

property leftCamera: mrpt.img.TCamera: Left camera intrinsic parameters.

property rightCamera: mrpt.img.TCamera: Right camera intrinsic parameters.

property rightCameraPose: mrpt.poses.CPose3DQuat: Pose of the right camera with respect to the left one.

areImagesRectified() → bool: Whether the images are rectified, by the MRPT convention: all the distortion parameters of leftCamera are zero.

getStereoCameraParams() → mrpt.img.TStereoCamera: Returns both cameras parameters and their relative pose as a TStereoCamera.

setStereoCameraParams(params: mrpt.img.TStereoCamera) → None: Sets both cameras parameters and their relative pose.

class mrpt.obs.CObservationVelodyneScan

C++ API: class mrpt::obs::CObservationVelodyneScan

Bases: CObservation

Raw packets of one Velodyne scan. generatePointCloud() decodes them into point_cloud, read with the pointCloud*() methods.

property calibration: VelodyneCalibration: Calibration used to decode the packets.

property maxRange: float: Maximum valid range (m).

property minRange: float: Minimum valid range (m).

property sensorPose: mrpt.poses.CPose3D: Pose of the sensor on the robot.

has_satellite_timestamp: bool

originalReceivedTimestamp: datetime.timedelta

generatePointCloud(params: VelodyneGeneratePointCloudParameters = ...) → None: Decodes the packets into point_cloud (needs a calibration).

packetCount() → int: Number of raw data packets.

pointCloudAzimuth() → numpy.ndarray: Azimuth of each point (rad); only with generatePerPointAzimuth.

pointCloudIntensity() → numpy.ndarray: Intensity of each generated point (uint8).

pointCloudLaserId() → numpy.ndarray: Laser (ring) of each generated point.

pointCloudTimestamps() → numpy.ndarray: Time of each point (UNIX seconds); only with generatePerPointTimestamp.

pointCloudXYZ() → numpy.ndarray: Generated points as an Nx3 float32 array, in the sensor frame.

pointCount() → int: Number of points generated by generatePointCloud().

class mrpt.obs.CRawlog

C++ API: class mrpt::obs::CRawlog

Bases: mrpt.serialization.CSerializable

The main class for loading and processing robotics datasets, or “rawlogs”.

class TEntryType(value: int)

Members:

etSensoryFrame

etActionCollection

etObservation

etOther

property name: str

property value: int

etActionCollection: ClassVar[CRawlog]

etObservation: ClassVar[CRawlog]

etOther: ClassVar[CRawlog]

etSensoryFrame: ClassVar[CRawlog]

etActionCollection: ClassVar[CRawlog]

etObservation: ClassVar[CRawlog]

etOther: ClassVar[CRawlog]

etSensoryFrame: ClassVar[CRawlog]

static ReadFromArchive(archive: mrpt.serialization.CArchive, entry: int = 0) → tuple: Reads the next entry from a rawlog stream (see mrpt.io.archiveFrom()). Returns (readOk, nextEntryIndex, actions, sensoryFrame, observation): either (actions, sensoryFrame) or observation are None, depending on the rawlog format. readOk is False at the end of the stream.

clear() → None: Removes all entries.

static detectImagesDirectory(rawlogFilename: str) → str: Returns the directory of externally-stored images for a given rawlog file

empty() → bool: Returns true if the rawlog is empty.

getAsAction(index: int) → CActionCollection: Returns entry i as a CActionCollection. Raises if it has a different type.

getAsGeneric(index: int) → mrpt.serialization.CSerializable: Returns entry i, whatever its type

getAsObservation(index: int) → CObservation: Returns entry i as a CObservation. Raises if it has a different type.

getAsObservations(index: int) → CSensoryFrame: Returns entry i as a CSensoryFrame. Raises if it has a different type.

getCommentText() → str: Returns the embedded comment text, if any

getType(index: int) → CRawlog: Returns the type of a given element.

insert(obj: mrpt.serialization.CSerializable) → None: Appends an object (CSensoryFrame, CActionCollection, CObservation, …). The object is stored by reference, not copied.

loadFromRawLogFile(fileName: str, non_obs_objects_are_legal: bool = False) → bool: Loads a .rawlog file (possibly compressed). Returns False on error.

remove(index: int) → None: Removes the entry at the given index.

saveToRawLogFile(fileName: str) → bool: Saves to a .rawlog file. Returns False on error.

setCommentText(text: str) → None: Changes the block of comment text for the rawlog.

size() → int: Returns the number of actions / observations object in the sequence.

class mrpt.obs.CSensoryFrame

C++ API: class mrpt::obs::CSensoryFrame

Bases: 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.

clear() → None: Clear the container, so it holds no observations.

insert(arg0: CObservation) → None: Appends an observation.

size() → int: Returns the number of observations in the list.

class mrpt.obs.CSimpleMap

Bases: mrpt.serialization.CSerializable

A view-based map: a set of poses and what the robot saw from those poses.

class Keyframe

class Keyframe(pose: mrpt.poses.CPose3DPDF, sf: CSensoryFrame, localTwist: mrpt.math.TTwist3D | None = None)

One keyframe of a CSimpleMap: a pose PDF, a sensory frame and an optional twist.

localTwist: mrpt.math.TTwist3D | None

pose: mrpt.poses.CPose3DPDF

sf: CSensoryFrame

changeCoordinatesOrigin(newOrigin: mrpt.poses.CPose3D) → None: Transforms all keyframe poses so the old origin becomes newOrigin

clear() → None: Remove all stored keyframes.

empty() → bool: Returns true if the map has no keyframes.

get(index: int) → CSimpleMap: Returns the i-th keyframe.

insert(pose: mrpt.poses.CPose3DPDF, sf: CSensoryFrame, localTwist: mrpt.math.TTwist3D | None = None) → None
insert(keyframe: CSimpleMap) → None: Appends a keyframe (pose PDF and sensory frame).

loadFromFile(fileName: str) → bool: Loads a .simplemap file (possibly compressed). Returns False on error.

remove(index: int) → None: Removes the i-th keyframe.

saveToFile(fileName: str) → bool: Saves to a .simplemap file. Returns False on error.

size() → int: Returns the number of keyframes in the map.

class mrpt.obs.GnssFixType(value: int)

Members:

UNKNOWN

NO_FIX

AUTONOMOUS

SBAS

GBAS

DGPS

RTK_FLOAT

RTK_FIXED

PPP

DEAD_RECKONING

SIMULATION

property name: str

property value: int

AUTONOMOUS: ClassVar[GnssFixType]

DEAD_RECKONING: ClassVar[GnssFixType]

DGPS: ClassVar[GnssFixType]

GBAS: ClassVar[GnssFixType]

NO_FIX: ClassVar[GnssFixType]

PPP: ClassVar[GnssFixType]

RTK_FIXED: ClassVar[GnssFixType]

RTK_FLOAT: ClassVar[GnssFixType]

SBAS: ClassVar[GnssFixType]

SIMULATION: ClassVar[GnssFixType]

UNKNOWN: ClassVar[GnssFixType]

class mrpt.obs.T3DPointsProjectionParams

C++ API: struct mrpt::obs::T3DPointsProjectionParams

Options of CObservation3DRangeScan.unprojectInto().

MAKE_ORGANIZED: bool

decimation: int

layer: str

robotPoseInTheWorld: mrpt.poses.CPose3D | None

takeIntoAccountSensorPoseOnRobot: bool

class mrpt.obs.TIMUDataIndex(value: int)

Index of each measurement in CObservationIMU

Members:

IMU_X_ACC

IMU_Y_ACC

IMU_Z_ACC

IMU_YAW_VEL

IMU_WZ

IMU_PITCH_VEL

IMU_WY

IMU_ROLL_VEL

IMU_WX

IMU_X_VEL

IMU_Y_VEL

IMU_Z_VEL

IMU_YAW

IMU_PITCH

IMU_ROLL

IMU_X

IMU_Y

IMU_Z

IMU_MAG_X

IMU_MAG_Y

IMU_MAG_Z

IMU_PRESSURE

IMU_ALTITUDE

IMU_TEMPERATURE

IMU_ORI_QUAT_X

IMU_ORI_QUAT_Y

IMU_ORI_QUAT_Z

IMU_ORI_QUAT_W

IMU_YAW_VEL_GLOBAL

IMU_PITCH_VEL_GLOBAL

IMU_ROLL_VEL_GLOBAL

IMU_X_ACC_GLOBAL

IMU_Y_ACC_GLOBAL

IMU_Z_ACC_GLOBAL

property name: str

property value: int

IMU_ALTITUDE: ClassVar[TIMUDataIndex]

IMU_MAG_X: ClassVar[TIMUDataIndex]

IMU_MAG_Y: ClassVar[TIMUDataIndex]

IMU_MAG_Z: ClassVar[TIMUDataIndex]

IMU_ORI_QUAT_W: ClassVar[TIMUDataIndex]

IMU_ORI_QUAT_X: ClassVar[TIMUDataIndex]

IMU_ORI_QUAT_Y: ClassVar[TIMUDataIndex]

IMU_ORI_QUAT_Z: ClassVar[TIMUDataIndex]

IMU_PITCH: ClassVar[TIMUDataIndex]

IMU_PITCH_VEL: ClassVar[TIMUDataIndex]

IMU_PITCH_VEL_GLOBAL: ClassVar[TIMUDataIndex]

IMU_PRESSURE: ClassVar[TIMUDataIndex]

IMU_ROLL: ClassVar[TIMUDataIndex]

IMU_ROLL_VEL: ClassVar[TIMUDataIndex]

IMU_ROLL_VEL_GLOBAL: ClassVar[TIMUDataIndex]

IMU_TEMPERATURE: ClassVar[TIMUDataIndex]

IMU_WX: ClassVar[TIMUDataIndex]

IMU_WY: ClassVar[TIMUDataIndex]

IMU_WZ: ClassVar[TIMUDataIndex]

IMU_X: ClassVar[TIMUDataIndex]

IMU_X_ACC: ClassVar[TIMUDataIndex]

IMU_X_ACC_GLOBAL: ClassVar[TIMUDataIndex]

IMU_X_VEL: ClassVar[TIMUDataIndex]

IMU_Y: ClassVar[TIMUDataIndex]

IMU_YAW: ClassVar[TIMUDataIndex]

IMU_YAW_VEL: ClassVar[TIMUDataIndex]

IMU_YAW_VEL_GLOBAL: ClassVar[TIMUDataIndex]

IMU_Y_ACC: ClassVar[TIMUDataIndex]

IMU_Y_ACC_GLOBAL: ClassVar[TIMUDataIndex]

IMU_Y_VEL: ClassVar[TIMUDataIndex]

IMU_Z: ClassVar[TIMUDataIndex]

IMU_Z_ACC: ClassVar[TIMUDataIndex]

IMU_Z_ACC_GLOBAL: ClassVar[TIMUDataIndex]

IMU_Z_VEL: ClassVar[TIMUDataIndex]

class mrpt.obs.TMapGenericParams

Bases: mrpt.config.CLoadableOptions, mrpt.serialization.CSerializable

Parameters common to all metric maps.

enableObservationInsertion: bool

enableObservationLikelihood: bool

enableSaveAs3DObject: bool

class mrpt.obs.TMetricMapInitializer

Bases: mrpt.config.CLoadableOptions

Base class of the definitions of one metric map (its type and parameters).

genericMapParams: TMapGenericParams

static factory(mapClassName: str) → TMetricMapInitializer: Creates the definition of a map by its class name, e.g. ‘COccupancyGridMap2D’. Requires importing mrpt.maps first, which registers the map types.

getMetricMapClassName() → str: Returns the C++ class name of the map this definition creates

class mrpt.obs.TSetOfMetricMapInitializers

Bases: mrpt.config.CLoadableOptions

A set of map definitions, used to build a CMultiMetricMap.

clear() → None: Removes all map definitions.

push_back(mapDefinition: TMetricMapInitializer) → None: Appends a map definition.

size() → int: Returns the number of map definitions.

class mrpt.obs.VelodyneCalibration

C++ API: struct mrpt::obs::VelodyneCalibration

Velodyne calibration data, for CObservationVelodyneScan.

static LoadDefaultCalibration(lidar_model: str) → VelodyneCalibration: Default calibration of a model (VLP16, HDL32, HDL64), or an empty one if unknown.

empty() → bool: True if no calibration is loaded.

loadFromXMLFile(filename: str) → bool: Loads a Velodyne XML calibration file. Returns False on error.

loadFromYAMLFile(filename: str) → bool: Loads a ROS velodyne_pointcloud YAML calibration file. Returns False on error.

class mrpt.obs.VelodyneGeneratePointCloudParameters

Options of CObservationVelodyneScan.generatePointCloud().

dualKeepLast: bool

dualKeepStrongest: bool

filterOutIsolatedPoints: bool

generatePerPointAzimuth: bool

generatePerPointTimestamp: bool

isolatedPointsFilterDistance: float

maxAzimuth_deg: float

maxDistance: float

minAzimuth_deg: float

minDistance: float

mrpt.obs

Package Contents

`mrpt.obs`