# 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

```cpp
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

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

### ImuData

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

### OdometryData

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

### FixedFramePoseData

```cpp
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

```cpp
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`:

```cpp
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

```cpp
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

```cpp
// 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

- [RangeData](range_data.md) — Lidar scan data
- [ImuData](imu_data.md) — IMU measurements
- [Collator](internal/collator.md) — Multi-sensor synchronization