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