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

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

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