README.md

---
license: cc-by-4.0
tags:
- robotics
- event-camera
- multimodal
- computer-vision
- depth-estimation
- lidar
- imu
- motion-capture
- simulation
- space-robotics
- semantic-segmentation
configs:
- config_name: firefly
  data_files:
  - split: trajectory_007
    path: firefly/trajectory_007/*.parquet
  - split: trajectory_008
    path: firefly/trajectory_008/*.parquet
  - split: trajectory_009
    path: firefly/trajectory_009/*.parquet
- config_name: realsense_color
  data_files:
  - split: trajectory_007
    path: realsense_color/trajectory_007/*.parquet
  - split: trajectory_008
    path: realsense_color/trajectory_008/*.parquet
  - split: trajectory_009
    path: realsense_color/trajectory_009/*.parquet
- config_name: realsense_depth
  data_files:
  - split: trajectory_007
    path: realsense_depth/trajectory_007/*.parquet
  - split: trajectory_008
    path: realsense_depth/trajectory_008/*.parquet
  - split: trajectory_009
    path: realsense_depth/trajectory_009/*.parquet
- config_name: events
  data_files:
  - split: trajectory_007
    path: events/trajectory_007/*.parquet
  - split: trajectory_008
    path: events/trajectory_008/*.parquet
  - split: trajectory_009
    path: events/trajectory_009/*.parquet
- config_name: lidar
  data_files:
  - split: trajectory_007
    path: lidar/trajectory_007/*.parquet
  - split: trajectory_008
    path: lidar/trajectory_008/*.parquet
  - split: trajectory_009
    path: lidar/trajectory_009/*.parquet
- config_name: imu
  data_files:
  - split: trajectory_007
    path: imu/trajectory_007/*.parquet
  - split: trajectory_008
    path: imu/trajectory_008/*.parquet
  - split: trajectory_009
    path: imu/trajectory_009/*.parquet
- config_name: mocap
  data_files:
  - split: trajectory_007
    path: mocap/trajectory_007/*.parquet
  - split: trajectory_008
    path: mocap/trajectory_008/*.parquet
  - split: trajectory_009
    path: mocap/trajectory_009/*.parquet
- config_name: robot_messages
  data_files:
  - split: trajectory_007
    path: robot_messages/trajectory_007/*.parquet
  - split: trajectory_008
    path: robot_messages/trajectory_008/*.parquet
  - split: trajectory_009
    path: robot_messages/trajectory_009/*.parquet
- config_name: sim_3d_rgb
  data_files:
  - split: train
    path: sim_3d_rgb/*/*.parquet
- config_name: sim_3d_depth
  data_files:
  - split: train
    path: sim_3d_depth/*/*.parquet
- config_name: sim_3d_semantic
  data_files:
  - split: train
    path: sim_3d_semantic/*/*.parquet
- config_name: sim_3d_events
  data_files:
  - split: train
    path: sim_3d_events/*/*.parquet
- config_name: sim_3d_lidar
  data_files:
  - split: train
    path: sim_3d_lidar/*/*.parquet
- config_name: sim_3d_imu
  data_files:
  - split: train
    path: sim_3d_imu/*/*.parquet
- config_name: sim_3d_mocap
  data_files:
  - split: train
    path: sim_3d_mocap/*/*.parquet
- config_name: sim_3d_steps
  data_files:
  - split: train
    path: sim_3d_steps/*/*.parquet
- config_name: sim_zerog_rgb
  data_files:
  - split: train
    path: sim_zerog_rgb/*/*.parquet
- config_name: sim_zerog_depth
  data_files:
  - split: train
    path: sim_zerog_depth/*/*.parquet
- config_name: sim_zerog_semantic
  data_files:
  - split: train
    path: sim_zerog_semantic/*/*.parquet
- config_name: sim_zerog_events
  data_files:
  - split: train
    path: sim_zerog_events/*/*.parquet
- config_name: sim_zerog_lidar
  data_files:
  - split: train
    path: sim_zerog_lidar/*/*.parquet
- config_name: sim_zerog_imu
  data_files:
  - split: train
    path: sim_zerog_imu/*/*.parquet
- config_name: sim_zerog_mocap
  data_files:
  - split: train
    path: sim_zerog_mocap/*/*.parquet
- config_name: sim_zerog_joint_states
  data_files:
  - split: train
    path: sim_zerog_joint_states/*/*.parquet
- config_name: sim_zerog_steps
  data_files:
  - split: train
    path: sim_zerog_steps/*/*.parquet
---

# off_test

Synchronized recordings from one rig: a Prophesee EVK4 (IMX636) event
camera, a FLIR Blackfly S Firefly frame camera, an Intel RealSense D455
(color + depth), plus -- where recorded -- a Livox Mid-360 lidar + IMU,
motion-capture poses and the robot's own control/state topics. Everything
is recorded on a single host per trajectory, so every `timestamp_ns` within
one trajectory shares one clock -- just match by nearest timestamp.

This dataset accumulates multiple recording sessions ("trajectories"), each
with its own full set of sensor streams. **Modality is the Hub config;
trajectory is the split within it** -- not every trajectory necessarily has
every modality (a sensor can be off/disconnected for a given recording), so
not every config has every split. See the table below for exactly which
trajectory has which modalities.

## Trajectories

| trajectory | events | firefly | realsense_color | realsense_depth | lidar | imu | mocap | robot_messages |
|---|---|---|---|---|---|---|---|---|
| trajectory_007 | 24,151,820 | 1,626 | 297 | 593 | 409 | 820 | 26,278 | 9,601 |
| trajectory_008 | 126,755,280 | 1,634 | 302 | 609 | 391 | 918 | 18,897 | 10,417 |
| trajectory_009 | 111,366,953 | 1,637 | 593 | 610 | 367 | 879 | 28,434 | 10,290 |

(— means that sensor recorded no data for that trajectory; counts are
event rows / image frames)

## Configs / how to load

```python
from datasets import load_dataset

# one trajectory, one modality:
events = load_dataset("r3m3c3/off_test", "events", split="trajectory_007")
firefly = load_dataset("r3m3c3/off_test", "firefly", split="trajectory_007")
rs_color = load_dataset("r3m3c3/off_test", "realsense_color", split="trajectory_007")
rs_depth = load_dataset("r3m3c3/off_test", "realsense_depth", split="trajectory_007")
lidar = load_dataset("r3m3c3/off_test", "lidar", split="trajectory_007")
imu = load_dataset("r3m3c3/off_test", "imu", split="trajectory_007")
mocap = load_dataset("r3m3c3/off_test", "mocap", split="trajectory_007")
robot_messages = load_dataset("r3m3c3/off_test", "robot_messages", split="trajectory_007")

# ALL trajectories for one modality, as a DatasetDict keyed by trajectory:
all_events = load_dataset("r3m3c3/off_test", "events")
print(list(all_events.keys()))   # every trajectory that has event data
```

Each image config yields rows with a decoded PIL `image` column plus a
`timestamp_ns` column. `events` yields a flat table (Arrow/Parquet-backed)
with one row per event.

- `lidar`: one row per scan -- `scan_index`, `timestamp_ns`,
  `header_stamp_ns`, `bag_timestamp_ns`, and one list column per point
  field (`x`, `y`, `z`, `intensity`, `tag`, `line`, `timestamp` for the
  Mid-360), all the same length within a row.
- `imu`: one row per sample -- orientation quaternion, angular velocity
  (rad/s), linear acceleration (**g**, the Livox driver's unit, not m/s^2).
- `mocap`: one row per pose -- `body` (tracked rigid body name), position
  (m) `x, y, z` and quaternion `qx, qy, qz, qw` in the mocap world frame.
  Filter by `body` for one object.
- `robot_messages`: every other recorded topic (controller commands, joint
  states, joystick, arm/disarm, ...) -- one row per message with `topic`,
  `msgtype`, the time columns and `data`, the full message as a JSON
  string (`json.loads(row["data"])`). Filter by `topic`.

`timestamp_ns` is always on the recording host's clock. Non-camera streams
additionally carry `header_stamp_ns` (the publisher's own stamp, null if
the message has none) and `bag_timestamp_ns` (receipt time at the
recorder); `timestamp_ns` equals the header stamp when that stream's
header clock agreed with the recorder's to within 1 s, else receipt time.

## Timestamps

Every timestamp -- `events`' `t` column and every image config's
`timestamp_ns` column -- is an **int64 nanosecond Unix epoch timestamp**,
consistent *within* a trajectory (same recording host, same clock, no
NTP/PTP sync needed) but **not comparable across trajectories** -- each
recording session starts its own clock reference. To align modalities,
find the nearest timestamp within the same trajectory/split only.

Event timestamps: the sensor's own internal clock is a free-running counter
with no absolute epoch reference of its own. Each trajectory anchors it to
epoch time independently, via an offset confirmed stable across two
consecutive event packets at the start of that trajectory's recording
(guards against a stale/buffered backlog burst on the first packet -- see
`bag_to_dataset/convert.py`). Events' *relative* timing to each other is
exact (decoded bit-for-bit from the sensor's raw EVT3 stream); the
*absolute* anchor is accurate to within one packet's capture latency (a few
milliseconds), the same order of uncertainty the other sensors' own
timestamps carry.

## Minimal example: events around a given frame

```python
import numpy as np
from datasets import load_dataset

events = load_dataset("r3m3c3/off_test", "events", split="trajectory_007")
frames = load_dataset("r3m3c3/off_test", "firefly", split="trajectory_007")

t0 = frames[100]["timestamp_ns"]
t_col = np.asarray(events["t"])           # loads the t column as one array
lo, hi = np.searchsorted(t_col, [t0 - 10_000_000, t0 + 10_000_000])  # +/- 10ms
window = events[lo:hi]                     # dict of x, y, p, t lists for that window
```
(works the same for any other trajectory -- swap the split name)

## Calibration

See `calibration/<trajectory_id>.yaml` for that trajectory's per-camera
intrinsics (K, D, R, P) -- kept per-trajectory rather than shared, in case
the rig gets recalibrated between recording sessions. Each entry has a
`source` field -- either `ros_camera_info` (published live by the driver)
or `supplement:...` (the driver didn't publish real intrinsics; filled in
from a separate calibration pass instead). Check this before trusting a
camera's numbers.

## Sensors

| sensor | model | modality |
|---|---|---|
| events | Prophesee EVK4 (IMX636) | event stream (EVT3) |
| firefly | FLIR Blackfly S BFS-U3-63S4C | RGB frames (debayered) |
| realsense_color | Intel RealSense D455 | RGB frames |
| realsense_depth | Intel RealSense D455 | depth (16-bit, aligned to color) |
| lidar | Livox Mid-360 | 3D point cloud scans |
| imu | Livox Mid-360 built-in IMU | orientation, angular velocity (rad/s), linear acceleration (g) |
| mocap | motion capture (vrpn_mocap) | 6-DoF pose per tracked body |
| robot_messages | robot / controller / teleop topics | one row per ROS message, payload as JSON |

<!-- sim-dataset:begin (written by pooh_dataset_pipeline sim/publish_hf.py) -->

## Simulated data (`sim_3d_*`, `sim_zerog_*` configs)

Simulated counterpart of the real recordings in this repo, from the
[Space Robotics Bench](https://github.com/AndrejOrsula/space_robotics_bench)
(Isaac Sim), driven by trained go-to-pose policies. Same layout as the real
data -- one folder per modality, one sub-folder per trajectory -- in two
groups. Each config has one `train` split with all its trajectories; every
row has a `trajectory_id`, and `sim_manifest.json` gives each trajectory's scenario
(e.g. `orbital/iss/earth`).

| group | trajectories | content |
|---|---|---|
| `sim_3d_<modality>/` | 2111 | orbital inspection in 3D: a free-flying chaser orbits a static space structure (procedural CubeSats, satellite mockup, Venus Express, Lunar Gateway, ISS) against an Earth or black-sky background |
| `sim_zerog_<modality>/` | 1056 | Zero-G lab digital twin: the planar Floating Platform inspects or docks to a satellite mockup / CubeSat held by the lab's wall or ceiling arm, or floating |

### Configs

| modality | sim_3d | sim_zerog | content |
|---|---|---|---|
| rgb | `sim_3d_rgb` | `sim_zerog_rgb` | RGB frames: `image`, `timestamp_ns`, `frame_index` |
| depth | `sim_3d_depth` | `sim_zerog_depth` | depth along the optical axis, 16-bit, units of calibration `depth.scale_m` (mm, cm for far scenes; 0 = no return) |
| semantic | `sim_3d_semantic` | `sim_zerog_semantic` | 8-bit class IDs: 0 background, 1 unlabelled, 2 target, 3 robot arm, 4 spacecraft |
| events | `sim_3d_events` | `sim_zerog_events` | `t, x, y, p` (p: 1 ON, 0 OFF), emulated IMX636 (v2e or openEB: calibration `events.emulator`), pixel-aligned with the camera |
| lidar | `sim_3d_lidar` | `sim_zerog_lidar` | one row per scan; list columns `x, y, z, distance, channel` in the lidar frame |
| imu | `sim_3d_imu` | `sim_zerog_imu` | robot IMU: `orientation_*`, `angular_velocity_*` (rad/s), `linear_acceleration_*` (**m/s^2**) |
| mocap | `sim_3d_mocap` | `sim_zerog_mocap` | ground-truth pose + twist per `body`: `x,y,z`, `qx,qy,qz,qw`, `vx,vy,vz`, `wx,wy,wz` (world frame) |
| joint_states | — | `sim_zerog_joint_states` | per `articulation`: `position`, `velocity`, `effort` lists (lab arms, platform) |
| steps | `sim_3d_steps` | `sim_zerog_steps` | one row per policy step: `action`, `observation`, `reward`, `reward_terms`, goal errors, `task_state` |

Per trajectory: `calibration/<trajectory>.yaml` (pinhole intrinsics `K`, mount
extrinsics; RGB, depth, semantic and events share one pixel-aligned camera) and
`metadata/<trajectory>.yaml` (scenario parameters, rates, policy, tracking
summary). `sim_manifest.json` lists every sim trajectory with its group,
scenario, duration and row counts.

### Loading

```python
from datasets import load_dataset

# one modality, every trajectory of the group:
rgb = load_dataset("r3m3c3/off_test", "sim_3d_rgb", split="train")
# every trajectory of one scenario (scenarios: sim_manifest.json):
import json
from huggingface_hub import hf_hub_download
m = json.load(open(hf_hub_download("r3m3c3/off_test", "sim_manifest.json", repo_type="dataset")))
iss = [t for t, e in m["trajectories"].items() if e["scenario"] == "orbital/iss/earth"]
rgb_iss = load_dataset("r3m3c3/off_test", data_files=[f"sim_3d_rgb/{t}/*.parquet" for t in iss], split="train")
# one trajectory (only its files are downloaded):
events = load_dataset("r3m3c3/off_test", data_files="sim_3d_events/trajectory_hera2_000001/*.parquet", split="train")
joints = load_dataset("r3m3c3/off_test", data_files="sim_zerog_joint_states/trajectory_hera2_000007/*.parquet", split="train")
```

### Time and frames

- **Timestamps (`timestamp_ns`, event `t`) are simulation time in ns since the
  episode reset**, not Unix epoch; shared by every modality of a trajectory.
- Rates: camera 20 Hz, lidar 10 Hz, mocap/IMU/joints 120 Hz, policy 10 Hz
  (exact values in `metadata/<trajectory>.yaml`, `rates_hz`).
- Quaternions are `xyzw`; world frame z-up at the environment origin.


The full trajectory list (group, scenario, duration) is in `SIM_DATASET.md` and `sim_manifest.json`.

<!-- sim-dataset:end -->