lorinachey/spot-telluride-workshop-dataset

Spot Telluride Workshop Dataset

Multimodal sensor data from a Boston Dynamics Spot D02 (Marble backpack compute), extracted from ROS bags for the Telluride Neuromorphic + AI Workshop. The dataset currently covers two locations, each with its own extraction tool and Hub layout root:

Location	Runs	Hub layout root	Extraction tool
Classroom demo	run1	classroom/run1/<modality>/	extract_demo_data.py
School	run1, run2	school/run1/<modality>/, school/run2/<modality>/	bag_to_hf.py

Note: Configs are not time-synchronized across modalities (different sensor rates). Join on timestamp_ns only with approximate alignment.

Note: Classroom and school configs use different config names (e.g. rgb_d455 vs school_run1_rgb_d455) because each config's data_files path can only point at one location in the repo. See Format differences between classroom and school below before mixing the two.

Dataset at a glance

	Classroom run1	School run1	School run2
Setting	Indoor conference-room demo	School building, longer traversal	School building, shorter traversal (sensor-only)
Configs	9 (incl. extra Spot cameras + OctoMap)	6	3 (RGB, depth, lidar)
RGB / depth frames	~2,479	~11,211	~4,532
Lidar frames	~1,655	~8,298	~3,343
Odometry rows (lio_sam / imu)	~500 / ~41k	~1,559 / ~129k	— (withdrawn)
Approx. download size	~2.8 GB	~9.0 GB	~3.7 GB

Total: ~15.5 GB across 18 configs. Configs are downloaded independently — load_dataset(repo, "<config_name>") only pulls that one config, never the whole dataset.

• Classroom run1 — smallest and quickest option, and the only run with Spot's body cameras (rgb_spot_frontleft / rgb_spot_frontright) and OctoMap (octomap). Good for a first look or quick prototyping.
• School run1 — the largest run (longest traversal, most frames), with full odometry and occupancy maps. Prefer this for anything that needs poses or maps.
• School run2 — shorter sensor-only run at the same school (RGB, depth, lidar). Pose/map products were withdrawn because odometry was not initialized during collection; use run1 for trajectory or occupancy work.

See the Configs — classroom and Configs — school sections below for the full per-modality breakdown, and Format differences between classroom and school for what differs between the two locations.

Quick start

pip install datasets pillow numpy

from datasets import load_dataset

repo = "lorinachey/spot-telluride-workshop-dataset"

# Load one config — only that config is downloaded, not the whole dataset.
rgb = load_dataset(repo, "school_run1_rgb_d455", split="train")
print(f"{len(rgb)} frames")
rgb[0]["image"].show()

Point cloud configs are multi-GB (see table above). Use streaming=True to iterate without downloading everything up front:

pcd = load_dataset(repo, "school_run1_pointclouds", split="train", streaming=True)
first_row = next(iter(pcd))

See Load examples below for depth, point-cloud parsing, and odometry examples for both locations.

Configs — classroom (classroom/run1/)

Config	Description	~Count
rgb_d455	Intel RealSense D455 color images + camera intrinsics	~2,479
depth_d455	D455 depth (16-bit PNG, aligned to color)	~2,478
rgb_spot_frontleft	Spot front-left RGB + intrinsics	~743
rgb_spot_frontright	Spot front-right RGB + intrinsics	~743
pointclouds	Horizontal Ouster lidar, ASCII PCD (XYZ + intensity + ring), all frames at 20 Hz	~1,655
occupancy_grid	2D occupancy map snapshots (PNG)	~830
octomap	OctoMap binary snapshots (.bt)	~911
odometry_lio_sam	SLAM-refined pose from LIO-SAM (lidar + IMU)	500 rows (6 Hz)
odometry_imu	High-rate IMU preintegration pose	41k rows (500 Hz)

Static files under classroom/run1/static/ in the repo: camera_info.json, map_final.png, map_final.yaml.

Configs — school (school/run1/, school/run2/)

School run1 has six configs (school_run1_*). School run2 is sensor-only (school_run2_rgb_d455, school_run2_depth_d455, school_run2_pointclouds): odometry and occupancy products were withdrawn after collection because odometry was not initialized for that run.

Config	Description	run1 count	run2 count
school_runN_rgb_d455	D455 color images + camera intrinsics	11,211	4,532
school_runN_depth_d455	D455 depth (16-bit PNG, aligned to color)	11,212	4,532
school_runN_pointclouds	Horizontal Ouster lidar, raw .npz (XYZ + intensity + ring arrays)	8,298	3,343
school_runN_occupancy_grid	2D occupancy map snapshots (PNG)	274	— (withdrawn)
school_runN_odometry_lio_sam	SLAM-refined pose from LIO-SAM (lidar + IMU)	1,559	— (withdrawn)
school_runN_odometry_imu	High-rate IMU preintegration pose	129,110	— (withdrawn)

No octomap, rgb_spot_frontleft, or rgb_spot_frontright configs exist for the school runs — those modalities weren't captured/extracted for this location.

Static files under school/run1/static/: camera_info_rgb_d455.json, metadata.json, occupancy_grid/map_final.png, occupancy_grid/map_final.yaml.

Static files under school/run2/static/: camera_info_rgb_d455.json, metadata.json only (no map products).

Format differences between classroom and school

The two locations were extracted with different tools and were not normalized to a common schema, to avoid lossy/lossless conversions and preserve each tool's native output:

Aspect	Classroom (classroom/run1/)	School (school/run1/, school/run2/)
Point cloud format	pcd_bytes — ASCII PCD v0.7 text	npz_bytes — raw NumPy .npz archive (arrays: xyz float32 (65536, 3), intensity float32, ring uint16)
camera_info file location	<modality>/camera_info.json	static/camera_info_<modality>.json
metadata.json	Not present	Present per run (written by bag_to_hf.py)
Extra modalities	octomap, rgb_spot_frontleft, rgb_spot_frontright	Not captured

If you need a single point-cloud format across both locations, parse pcd_bytes (see Load examples) or npz_bytes (np.load(io.BytesIO(row["npz_bytes"]))) into the same in-memory representation yourself — the raw column type on the Hub intentionally differs.

LiDAR sensor specs

The horizontal Ouster is configured in 1024x20 mode (set in ouster_double.launch); this applies to both classroom and school runs (same sensor rig on the same robot):

Parameter	Value
Mode	1024x20
Spin rate	20 Hz (20 full 360° revolutions per second)
Azimuth resolution	1,024 columns per revolution
Vertical channels	64 rings (ring index 0–63)
Points per frame	65,536 (64 × 1,024)
Timestamping	PTP 1588 (grandmaster: NUC enp1s0)
Fields per point	x, y, z (float32), intensity (float32), ring (uint16)
Coverage (classroom run1)	~83 seconds of data (1,655 frames ÷ 20 Hz)
Coverage (school run1 / run2)	~415 / ~167 seconds of data (8,298 / 3,343 frames ÷ 20 Hz)

Odometry streams

Both odometry configs are nav_msgs/Odometry poses exported as CSV with the same columns: timestamp_ns, x, y, z, qx, qy, qz, qw (position + quaternion orientation in the mapping/odom frame), for classroom and school run1. They come from different ROS topics on Spot D02 and serve different purposes. School run2 has no odometry or occupancy configs (withdrawn; odometry was not initialized during that run).

	odometry_lio_sam	odometry_imu
ROS topic	/D02/lio_sam/mapping/odometry	/D02/odometry/imu
Source	LIO-SAM mapping node — fuses Ouster lidar + IMU in a SLAM backend	IMU preintegration front-end — integrates inertial measurements (high-rate dead reckoning)
Rate	~6 Hz	~500 Hz
Typical use	Global trajectory, map alignment, slow-but-smooth path; pairs with occupancy_grid, octomap, pointclouds	Short-horizon motion, high temporal resolution; useful for dynamics, control, or interpolating between sparse lidar poses
Trade-off	More globally consistent; lower rate; depends on lidar SLAM quality	Much denser in time; drifts faster over distance; no direct lidar loop closure

Which should I use?

• For path plotting, localization against the built map, or syncing with lidar/map products → prefer odometry_lio_sam.
• For per-frame motion at camera/IMU rate, velocity estimation, or fine-grained timing → prefer odometry_imu, but expect accumulated drift over long segments.

The two streams are not redundant: LIO-SAM corrects drift using lidar structure; IMU preintegration fills in between SLAM updates. Do not assume they share the same frame origin or bias without checking your launch configuration.

Both were recorded in the same rosbag and can be aligned approximately on timestamp_ns, but they are not row-aligned (different row counts and rates).

Load examples

Classroom

from datasets import load_dataset

repo = "lorinachey/spot-telluride-workshop-dataset"

# RGB camera
rgb = load_dataset(repo, "rgb_spot_frontleft", split="train")
print(rgb[0]["timestamp_ns"])
rgb[0]["image"].show()

# Depth
depth = load_dataset(repo, "depth_d455", split="train")

# Point cloud (bytes — ASCII PCD file content; one parquet shard per config)
pcd = load_dataset(repo, "pointclouds", split="train")
print(f"{len(pcd)} frames")

# Save all frames to disk as .pcd files (readable by Open3D, PCL, RViz, etc.)
for row in pcd:
    fname = f"frame_{row['frame_idx']:06d}_{row['timestamp_ns']}.pcd"
    with open(fname, "wb") as f:
        f.write(row["pcd_bytes"])

# Parse directly into a numpy array (x, y, z, intensity, ring)
import numpy as np

def parse_pcd(pcd_bytes: bytes) -> np.ndarray:
    lines = pcd_bytes.decode().splitlines()
    data_start = next(i for i, l in enumerate(lines) if l.startswith("DATA")) + 1
    return np.array([list(map(float, l.split())) for l in lines[data_start:] if l.strip()],
                    dtype=np.float32)  # shape (N, 5): x y z intensity ring

cloud = parse_pcd(pcd[0]["pcd_bytes"])
xyz       = cloud[:, :3]
intensity = cloud[:, 3]
ring      = cloud[:, 4].astype(np.uint16)

# Odometry
odom = load_dataset(repo, "odometry_lio_sam", split="train")

School

Same idea, but with the school_run1_ / school_run2_ config prefixes and .npz point clouds instead of ASCII PCD:

from datasets import load_dataset
import io
import numpy as np

repo = "lorinachey/spot-telluride-workshop-dataset"

# RGB camera (includes camera_info, same as classroom's rgb_d455)
rgb = load_dataset(repo, "school_run1_rgb_d455", split="train")
print(rgb[0]["timestamp_ns"])
rgb[0]["image"].show()

# Depth
depth = load_dataset(repo, "school_run1_depth_d455", split="train")

# Point cloud (raw .npz bytes; one parquet shard per ~50MB of source data)
pcd = load_dataset(repo, "school_run1_pointclouds", split="train")
print(f"{len(pcd)} frames")

npz = np.load(io.BytesIO(pcd[0]["npz_bytes"]))
xyz       = npz["xyz"]        # (65536, 3) float32
intensity = npz["intensity"]  # (65536,) float32
ring      = npz["ring"]       # (65536,) uint16

# Odometry (same schema as classroom)
odom = load_dataset(repo, "school_run1_odometry_lio_sam", split="train")

Row schema (examples)

Classroom RGB configs (rgb_d455, rgb_spot_frontleft, rgb_spot_frontright): frame_idx, timestamp_ns, image, camera_info (JSON string)

Classroom depth_d455: frame_idx, timestamp_ns, depth

Classroom pointclouds: frame_idx, timestamp_ns, pcd_bytes — raw ASCII PCD v0.7 file bytes. Fields: x y z intensity ring (SIZE 4 4 4 4 2, TYPE F F F F U). Write to .pcd or parse with the example above.

Classroom occupancy_grid: timestamp_ns, map_snapshot

Classroom octomap: timestamp_ns, octomap_bt

School school_runN_rgb_d455: frame_idx, timestamp_ns, image, camera_info (JSON string)

School school_runN_depth_d455: frame_idx, timestamp_ns, depth

School school_runN_pointclouds: frame_idx, timestamp_ns, npz_bytes — raw .npz archive bytes (not parsed/converted from classroom's PCD format). Load with np.load(io.BytesIO(row["npz_bytes"])); keys xyz (65536, 3) float32, intensity (65536,) float32, ring (65536,) uint16.

School school_run1_occupancy_grid: timestamp_ns, map_snapshot (no school run2 occupancy config)

odometry_lio_sam / odometry_imu (classroom and school run1 only): timestamp_ns, x, y, z, qx, qy, qz, qw — see Odometry streams above. School run2 has no odometry configs.

Filename convention

Extracted frames use: frame_<index>_<timestamp_ns>.{jpg,png,pcd} for classroom, frame_<index>_<timestamp_ns>.{jpg,png,npz} for school (point clouds only differ in extension/format — see Format differences).

Re-extract and re-upload (maintainers)

The steps below cover classroom only. School runs were extracted with a different tool (bag_to_hf.py, not part of this repo) and packaged into parquet under school/runN/<modality>/ before upload.

LiDAR is extracted at full sensor rate by default (--hz 0). To refresh local files and push only the pointclouds config to Hugging Face:

# ROS environment (on the backpack / collection machine)
source /opt/ros/melodic/setup.bash
source /home/marble/marble_robot_ws/devel/setup.bash

# 1. Re-extract from rosbags (optional: clear old 1 Hz PCDs first)
rm -rf /home/marble/bags/telluride_ws/classroom/run1/extracted/pointclouds
python3 extract_demo_data.py /home/marble/bags/telluride_ws/classroom/run1

# 2. Re-upload pointclouds config only (skip static files and README)
python3 upload_hf_dataset.py \
  --data-dir /home/marble/bags/telluride_ws/classroom/run1/extracted \
  --repo-id lorinachey/spot-telluride-workshop-dataset \
  --config pointclouds \
  --skip-static

# 3. Push updated dataset card after verifying frame count
python3 upload_hf_dataset.py \
  --data-dir /home/marble/bags/telluride_ws/classroom/run1/extracted \
  --repo-id lorinachey/spot-telluride-workshop-dataset \
  --readme-only

Use --hz 1.0 on extraction if you intentionally want 1 Hz subsampling. Point clouds are stored as one or more parquet shards under classroom/run1/pointclouds/ in the Hub repo; load_dataset downloads and unpacks all rows automatically.

Acknowledgements

This work was supported by the 2026 Telluride Neuromorphic AI Workshop.

Citation

If you use this dataset, please cite this Hugging Face dataset page and acknowledge support from the 2026 Telluride Neuromorphic AI Workshop.

License

Apache 2.0 (dataset packaging). Robot data collected for research and education at the Telluride workshop.