cartographer/sensor/data.h

Overview

Data is the abstract base class for all sensor data types in Cartographer. It provides a common interface for timestamp access, sensor identification, and dispatching to trajectory builders.

Class: cartographer::sensor::Data

Interface

class Data {
 public:
  explicit Data(const std::string& sensor_id);
  virtual ~Data() {}

  virtual common::Time GetTime() const = 0;
  const std::string& GetSensorId() const { return sensor_id_; }
  
  virtual void AddToTrajectoryBuilder(
      mapping::TrajectoryBuilderInterface* trajectory_builder) = 0;

 protected:
  const std::string sensor_id_;
};

Members

  • sensor_id_ — Unique identifier for this sensor (e.g., “laser”, “imu”)

Pure Virtual Methods

  • GetTime() — Returns the measurement timestamp

  • AddToTrajectoryBuilder() — Dispatches data to the appropriate trajectory builder method

Concrete Data Types

RangeData

class RangeData : public Data {
  // sensor::RangeData origin, returns, misses
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    tb->AddRangeData(sensor_id_, time_, range_data_);
  }
};

ImuData

class ImuData : public Data {
  // Eigen::Vector3d linear_acceleration, angular_velocity
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    tb->AddImuData(sensor_id_, time_, imu_data_);
  }
};

OdometryData

class OdometryData : public Data {
  // transform::Rigid3d pose
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    tb->AddOdometryData(sensor_id_, time_, odometry_data_);
  }
};

FixedFramePoseData

class FixedFramePoseData : public Data {
  // transform::Rigid3d pose (in fixed frame, e.g., GPS)
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    tb->AddFixedFramePoseData(sensor_id_, time_, pose_);
  }
};

LandmarkData

class LandmarkData : public Data {
  // std::vector<LandmarkObservation> observations
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    tb->AddLandmarkData(sensor_id_, time_, landmark_data_);
  }
};

Dispatchable Wrapper

For the sensor collator, data is wrapped in Dispatchable:

template <typename T>
class Dispatchable : public Data {
 public:
  Dispatchable(const std::string& sensor_id, common::Time time, T data)
      : Data(sensor_id), time_(time), data_(std::move(data)) {}

  common::Time GetTime() const override { return time_; }
  
  void AddToTrajectoryBuilder(TrajectoryBuilderInterface* tb) override {
    // Uses type-specific dispatch
    AddToTrajectoryBuilderImpl(tb, data_);
  }

 private:
  common::Time time_;
  T data_;
};

Factory Functions

template <typename T>
std::unique_ptr<Data> MakeDispatchable(const std::string& sensor_id,
                                       common::Time time, T data);

Creates a Dispatchable<T> wrapping the sensor data.

Usage

// Create sensor data
auto range_data = sensor::RangeData{origin, returns, misses};
auto dispatchable = sensor::MakeDispatchable("laser", time, range_data);

// Add to trajectory builder (via collator or directly)
trajectory_builder->AddSensorData("laser", std::move(dispatchable));

// The Data's AddToTrajectoryBuilder calls:
// trajectory_builder->AddRangeData("laser", time, range_data);

Sensor ID Convention

Sensor IDs are pairs: {type, id} where type is one of:

  • "rangefinder" — Lidar, depth camera

  • "imu" — Inertial measurement unit

  • "odometer" — Wheel odometry

  • "fixed_frame_pose" — GPS, VIO, external pose

  • "landmark" — Visual landmarks, fiducials

Example: {"rangefinder", "velodyne_top"}, {"imu", "imu_0"}

See Also