Hugging Face's logo

Datasets:
Voxel51
/
oxford-spires-multimodal

Tasks:
Robotics
Depth Estimation
Languages:
English
Size:
n<1K
ArXiv:
Tags:
fiftyone
mcap
multimodal
robotics
slam
lidar
Libraries:
FiftyOne
License:
Dataset card Files
xet
 Community
Dataset Viewer
Duplicate
The dataset viewer is not available for this split.
Cannot load the dataset split (in streaming mode) to extract the first rows.
Error code:   StreamingRowsError
Exception:    CastError
Message:      Couldn't cast
samples: list<item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type:  (... 590 chars omitted)
  child 0, item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type: string, _ra (... 578 chars omitted)
      child 0, _id: struct<$oid: string>
          child 0, $oid: string
      child 1, filepath: string
      child 2, tags: list<item: null>
          child 0, item: null
      child 3, _media_type: string
      child 4, _rand: double
      child 5, sequence_id: string
      child 6, location: string
      child 7, recording_date: timestamp[s]
      child 8, run_number: int64
      child 9, duration_s: double
      child 10, message_count: int64
      child 11, channel_count: int64
      child 12, topics: list<item: string>
          child 0, item: string
      child 13, schemas: list<item: string>
          child 0, item: string
      child 14, has_image: bool
      child 15, has_pointcloud: bool
      child 16, has_gps: bool
      child 17, has_imu: bool
      child 18, has_logs: bool
      child 19, has_trajectory: bool
      child 20, has_camera_calibration: bool
      child 21, has_depth: bool
      child 22, has_depth_overlay: bool
      child 23, has_surface_normals: bool
      child 24, has_rgb_lidar: bool
      child 25, num_cameras: int64
      child 26, _dataset_id: struct<$oid: string>
          child 0, $oid: string
      child 27, created_at: struct<$date: string>
          child 0, $date:
...
e: string, ftype: string, embedded_doc_type: null, subfield: null, fields: list (... 115 chars omitted)
          child 0, item: struct<name: string, ftype: string, embedded_doc_type: null, subfield: null, fields: list<item: null (... 103 chars omitted)
              child 0, name: string
              child 1, ftype: string
              child 2, embedded_doc_type: null
              child 3, subfield: null
              child 4, fields: list<item: null>
                  child 0, item: null
              child 5, db_field: string
              child 6, description: null
              child 7, info: null
              child 8, read_only: bool
              child 9, created_at: struct<$date: string>
                  child 0, $date: string
      child 5, db_field: string
      child 6, description: null
      child 7, info: null
      child 8, read_only: bool
      child 9, created_at: struct<$date: string>
          child 0, $date: string
created_at: struct<$date: string>
  child 0, $date: string
tags: list<item: null>
  child 0, item: null
frame_fields: list<item: null>
  child 0, item: null
active_label_schemas: list<item: null>
  child 0, item: null
last_loaded_at: struct<$date: string>
  child 0, $date: string
persistent: bool
default_classes: list<item: null>
  child 0, item: null
sample_collection_name: string
name: string
slug: string
media_type: string
last_modified_at: struct<$date: string>
  child 0, $date: string
saved_views: list<item: null>
  child 0, item: null
to
{'_id': {'$oid': Value('string')}, 'name': Value('string'), 'slug': Value('string'), 'version': Value('string'), 'created_at': {'$date': Value('string')}, 'last_modified_at': {'$date': Value('string')}, 'last_deletion_at': Value('null'), 'last_loaded_at': {'$date': Value('string')}, 'sample_collection_name': Value('string'), 'persistent': Value('bool'), 'media_type': Value('string'), 'group_media_types': Json(decode=True), 'tags': List(Value('null')), 'info': Json(decode=True), 'app_config': {'dynamic_groups_target_frame_rate': Value('int64'), 'grid_media_field': Value('string'), 'media_fallback': Value('bool'), 'media_fields': List(Value('string')), 'modal_media_field': Value('string'), 'plugins': Json(decode=True)}, 'classes': Json(decode=True), 'default_classes': List(Value('null')), 'mask_targets': Json(decode=True), 'default_mask_targets': Json(decode=True), 'skeletons': Json(decode=True), 'camera_intrinsics': Json(decode=True), 'static_transforms': Json(decode=True), 'sample_fields': List({'name': Value('string'), 'ftype': Value('string'), 'embedded_doc_type': Value('string'), 'subfield': Value('string'), 'fields': List({'name': Value('string'), 'ftype': Value('string'), 'embedded_doc_type': Value('null'), 'subfield': Value('null'), 'fields': List(Value('null')), 'db_field': Value('string'), 'description': Value('null'), 'info': Value('null'), 'read_only': Value('bool'), 'created_at': {'$date': Value('string')}}), 'db_field': Value('string'), 'description': Value('null'), 'info': Value('null'), 'read_only': Value('bool'), 'created_at': {'$date': Value('string')}}), 'frame_fields': List(Value('null')), 'saved_views': List(Value('null')), 'workspaces': List(Value('null')), 'annotation_runs': Json(decode=True), 'brain_methods': Json(decode=True), 'evaluations': Json(decode=True), 'runs': Json(decode=True), 'active_label_schemas': List(Value('null')), 'label_schemas': Json(decode=True), 'frame_label_schemas': Json(decode=True)}
because column names don't match
Traceback:    Traceback (most recent call last):
                File "/src/services/worker/src/worker/utils.py", line 149, in get_rows_or_raise
                  return get_rows(
                      dataset=dataset,
                  ...<4 lines>...
                      column_names=column_names,
                  )
                File "/src/libs/libcommon/src/libcommon/utils.py", line 272, in decorator
                  return func(*args, **kwargs)
                File "/src/services/worker/src/worker/utils.py", line 129, in get_rows
                  rows_plus_one = list(itertools.islice(safe_iter(ds, dataset=dataset), rows_max_number + 1))
                File "/src/services/worker/src/worker/utils.py", line 489, in safe_iter
                  yield from ds.decode(False) if ds.features else ds
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2818, in __iter__
                  for key, example in ex_iterable:
                                      ^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2355, in __iter__
                  for key, pa_table in self._iter_arrow():
                                       ~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 2380, in _iter_arrow
                  for key, pa_table in self.ex_iterable._iter_arrow():
                                       ~~~~~~~~~~~~~~~~~~~~~~~~~~~~^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 536, in _iter_arrow
                  for key, pa_table in iterator:
                                       ^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/iterable_dataset.py", line 419, in _iter_arrow
                  for key, pa_table in self.generate_tables_fn(**gen_kwags):
                                       ~~~~~~~~~~~~~~~~~~~~~~~^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 343, in _generate_tables
                  self._cast_table(pa_table, json_field_paths=json_field_paths),
                  ~~~~~~~~~~~~~~~~^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
                File "/usr/local/lib/python3.14/site-packages/datasets/packaged_modules/json/json.py", line 132, in _cast_table
                  pa_table = table_cast(pa_table, self.info.features.arrow_schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2369, in table_cast
                  return cast_table_to_schema(table, schema)
                File "/usr/local/lib/python3.14/site-packages/datasets/table.py", line 2297, in cast_table_to_schema
                  raise CastError(
                  ...<3 lines>...
                  )
              datasets.table.CastError: Couldn't cast
              samples: list<item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type:  (... 590 chars omitted)
                child 0, item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type: string, _ra (... 578 chars omitted)
                    child 0, _id: struct<$oid: string>
                        child 0, $oid: string
                    child 1, filepath: string
                    child 2, tags: list<item: null>
                        child 0, item: null
                    child 3, _media_type: string
                    child 4, _rand: double
                    child 5, sequence_id: string
                    child 6, location: string
                    child 7, recording_date: timestamp[s]
                    child 8, run_number: int64
                    child 9, duration_s: double
                    child 10, message_count: int64
                    child 11, channel_count: int64
                    child 12, topics: list<item: string>
                        child 0, item: string
                    child 13, schemas: list<item: string>
                        child 0, item: string
                    child 14, has_image: bool
                    child 15, has_pointcloud: bool
                    child 16, has_gps: bool
                    child 17, has_imu: bool
                    child 18, has_logs: bool
                    child 19, has_trajectory: bool
                    child 20, has_camera_calibration: bool
                    child 21, has_depth: bool
                    child 22, has_depth_overlay: bool
                    child 23, has_surface_normals: bool
                    child 24, has_rgb_lidar: bool
                    child 25, num_cameras: int64
                    child 26, _dataset_id: struct<$oid: string>
                        child 0, $oid: string
                    child 27, created_at: struct<$date: string>
                        child 0, $date:
              ...
              e: string, ftype: string, embedded_doc_type: null, subfield: null, fields: list (... 115 chars omitted)
                        child 0, item: struct<name: string, ftype: string, embedded_doc_type: null, subfield: null, fields: list<item: null (... 103 chars omitted)
                            child 0, name: string
                            child 1, ftype: string
                            child 2, embedded_doc_type: null
                            child 3, subfield: null
                            child 4, fields: list<item: null>
                                child 0, item: null
                            child 5, db_field: string
                            child 6, description: null
                            child 7, info: null
                            child 8, read_only: bool
                            child 9, created_at: struct<$date: string>
                                child 0, $date: string
                    child 5, db_field: string
                    child 6, description: null
                    child 7, info: null
                    child 8, read_only: bool
                    child 9, created_at: struct<$date: string>
                        child 0, $date: string
              created_at: struct<$date: string>
                child 0, $date: string
              tags: list<item: null>
                child 0, item: null
              frame_fields: list<item: null>
                child 0, item: null
              active_label_schemas: list<item: null>
                child 0, item: null
              last_loaded_at: struct<$date: string>
                child 0, $date: string
              persistent: bool
              default_classes: list<item: null>
                child 0, item: null
              sample_collection_name: string
              name: string
              slug: string
              media_type: string
              last_modified_at: struct<$date: string>
                child 0, $date: string
              saved_views: list<item: null>
                child 0, item: null
              to
              {'_id': {'$oid': Value('string')}, 'name': Value('string'), 'slug': Value('string'), 'version': Value('string'), 'created_at': {'$date': Value('string')}, 'last_modified_at': {'$date': Value('string')}, 'last_deletion_at': Value('null'), 'last_loaded_at': {'$date': Value('string')}, 'sample_collection_name': Value('string'), 'persistent': Value('bool'), 'media_type': Value('string'), 'group_media_types': Json(decode=True), 'tags': List(Value('null')), 'info': Json(decode=True), 'app_config': {'dynamic_groups_target_frame_rate': Value('int64'), 'grid_media_field': Value('string'), 'media_fallback': Value('bool'), 'media_fields': List(Value('string')), 'modal_media_field': Value('string'), 'plugins': Json(decode=True)}, 'classes': Json(decode=True), 'default_classes': List(Value('null')), 'mask_targets': Json(decode=True), 'default_mask_targets': Json(decode=True), 'skeletons': Json(decode=True), 'camera_intrinsics': Json(decode=True), 'static_transforms': Json(decode=True), 'sample_fields': List({'name': Value('string'), 'ftype': Value('string'), 'embedded_doc_type': Value('string'), 'subfield': Value('string'), 'fields': List({'name': Value('string'), 'ftype': Value('string'), 'embedded_doc_type': Value('null'), 'subfield': Value('null'), 'fields': List(Value('null')), 'db_field': Value('string'), 'description': Value('null'), 'info': Value('null'), 'read_only': Value('bool'), 'created_at': {'$date': Value('string')}}), 'db_field': Value('string'), 'description': Value('null'), 'info': Value('null'), 'read_only': Value('bool'), 'created_at': {'$date': Value('string')}}), 'frame_fields': List(Value('null')), 'saved_views': List(Value('null')), 'workspaces': List(Value('null')), 'annotation_runs': Json(decode=True), 'brain_methods': Json(decode=True), 'evaluations': Json(decode=True), 'runs': Json(decode=True), 'active_label_schemas': List(Value('null')), 'label_schemas': Json(decode=True), 'frame_label_schemas': Json(decode=True)}
              because column names don't match

Need help to make the dataset viewer work? Make sure to review how to configure the dataset viewer, and open a discussion for direct support.

Dataset Card for Oxford Spires Multimodal (MCAP)

image/png

A FiftyOne build of the Oxford Spires Dataset, the large-scale LiDAR-visual localisation, reconstruction and radiance-field benchmark from the Oxford Robotics Institute (ORI). This build repackages 6 of the 24 source sequences — one per historic Oxford landmark — as time-synchronised MCAP recordings for FiftyOne's native multimodal dataset support (FiftyOne 1.19+). Each sample is one episode, viewable in FiftyOne's tiled multimodal viewer with synchronised three-camera fisheye imagery, motion-undistorted LiDAR point clouds, IMU telemetry, and a live 6-DoF pose track from LiDAR-inertial SLAM.

Alongside the raw sensor streams, each episode also carries the three per-camera products of the source devkit's own generate_depth.py pipeline — 16-bit depth maps, HSV depth overlays on the camera image, and surface-normal maps — logged as additional streams so the devkit's canonical visualisation is reproducible inside the App.

Oxford Spires is a raw multi-sensor dataset for benchmarking SLAM, Structure-from-Motion, Multi-View Stereo, NeRF and 3D Gaussian Splatting methods; it carries no object-level annotations. "Ground truth" in the source dataset means millimetre-accurate Terrestrial LiDAR Scanner (TLS) 3D models and the centimetre-accurate trajectories registered against them. This repackaging does not add or alter any ground truth; see Dataset Creation for exactly what was kept, converted, and left out.

This is a FiftyOne dataset with 6 samples.

Installation

If you haven't already, install FiftyOne:

pip install -U fiftyone

Usage 

import fiftyone as fo
from fiftyone.utils.huggingface import load_from_hub

# Load the dataset
# Note: other available arguments include 'max_samples', etc
dataset = load_from_hub("Voxel51/oxford-spires-multimodal")

# Launch the App
session = fo.launch_app(dataset)

Dataset Details

Dataset Description

The Oxford Spires Dataset was captured in and around six well-known historic landmarks in Oxford, UK, using a custom handheld multi-sensor perception unit called Frontier, carried in a backpack at walking pace. The unit comprises three synchronised global-shutter colour fisheye cameras (forward-, left- and right-facing), a 64-beam automotive 3D LiDAR, and an inertial sensor, all precisely calibrated. Each site is additionally covered by a millimetre-accurate reference 3D model captured with a Terrestrial LiDAR Scanner, which the authors use both as reconstruction ground truth and — via ICP registration of the mobile LiDAR scans — as the source of centimetre-accurate ground-truth trajectories.

In total the source dataset contains 24 sequences across the six sites, covering more than 125,000 m² (about the size of a small town), with the average distance travelled per sequence exceeding 400 metres. The three forward/left/right camera configuration is a distinguishing feature: it widens the field of view for texture mapping and supplies the extra view constraints that vision-only methods need to infer 3D structure from a single linear pass through an environment. The authors establish three benchmarks on this data — localisation, 3D reconstruction, and novel-view synthesis — and use them to show that state-of-the-art radiance field methods overfit to training poses and generalise poorly to out-of-sequence viewpoints.

This FiftyOne build covers 6 full-length episodes, one per site (see Curation Rationale).

  • Curated by: Oxford Robotics Institute, Department of Engineering Science, University of Oxford, in collaboration with the Group of Automation, Robotics and Computer Vision (AUROVA), University of Alicante — original data collection, sensor calibration, TLS reference models, and ground-truth trajectory post-processing. This MCAP/FiftyOne multimodal repackaging (episode authoring, dataset card) was prepared independently by Harpreet Sahota.
  • Funded by: Partly funded by the National Research Foundation of Korea (NRF) grant funded by the Korea government (MSIT), No. RS-2024-00461409. Miguel Ángel Muñoz-Bañón is supported by the Valencian Community Government and the European Union through the CIBEST/2023/44 fellowship and the PROMETEO/2021/075 project.
  • Shared by: Harpreet Sahota (this repackaging); the original Oxford Spires Dataset is shared by the Oxford Robotics Institute via https://dynamic.robots.ox.ac.uk/datasets/oxford-spires/ and the ori-drs/oxford_spires_dataset Hugging Face dataset repository.
  • Language(s): N/A (sensor data — camera, LiDAR, IMU, pose; no text).
  • License: CC BY-NC-SA 4.0 — Copyright (c) 2024, University of Oxford; intended for non-commercial academic use. Commercial use requires contacting the original authors at oxfordspiresdataset@robots.ox.ac.uk.

Dataset Sources

Uses

Direct Use

  • Exercising/demoing FiftyOne's multimodal MCAP support: synchronised playback of three fisheye camera streams, motion-undistorted LiDAR point clouds, IMU telemetry, and a moving 6-DoF sensor pose across full-length, real handheld recordings (3.5–13.7 minutes each).
  • Inspecting LiDAR-camera calibration quality interactively — the depth overlay streams (/overlay_cam_*) reproduce the devkit's own LiDAR-on-image visualisation, which the paper uses (Figs. 4 and 5) to demonstrate calibration and motion-undistortion accuracy.
  • Prototyping analyses that need per-frame LiDAR-to-camera projection: 16-bit euclidean depth maps and surface-normal maps are logged per camera at every image-synchronised keyframe.
  • Qualitative review of LiDAR-inertial SLAM trajectory behaviour, with the world → base transform track driving the 3D tile's camera and point-cloud placement.
  • Browsing site-to-site variation (limestone vs. Keble's alternating red and white brick; open squares vs. narrow passages; indoor/outdoor lighting transitions) via the location sample field.

Out-of-Scope Use

  • Reproducing the paper's localisation, reconstruction, or novel-view synthesis benchmark numbers. Those benchmarks require artifacts that are not in this build: the TLS ground-truth 3D models, the TLS-registered ground-truth trajectories (gt-tum.txt), the HBA and COLMAP trajectory variants, and the COLMAP SfM outputs. See Parsing decisions.
  • Any task needing object-level labels (detection, segmentation, classification). No such annotations exist anywhere in the source dataset.
  • Metric evaluation against the poses in this build. The pose track here is the VILENS-SLAM estimate shipped in slam-poses.csv, which is itself one of the systems evaluated in the paper's localisation benchmark (ATE 0.03–1.11 m depending on sequence), not the TLS-registered ground truth (≈1–2 cm accuracy).
  • Photometrically consistent colour reconstruction from the merged /lidar_rgb clouds. The paper explicitly flags this as an open problem for this data: camera auto-exposure was enabled, so the same 3D structure observed from different viewpoints has inconsistent pixel intensity, and merging colourised LiDAR clouds "would lead to a mixture of different colours in the reconstruction."
  • Map-based workflows. There is no GNSS/GPS stream anywhere in the source dataset, so the App's Map tile is empty for every episode by design.

Dataset Structure

This is a flat (ungrouped) FiftyOne dataset with media_type: "multimodal" and 6 samples. Each sample is one episode, stored as one .mcap file; FiftyOne infers the multimodal media type automatically from the .mcap extension. There are no separate per-frame image or point-cloud samples — the episode is the sample unit, and every stream inside it (cameras, LiDAR, IMU, transforms, and the derived depth/overlay/normal products) is decoded live by FiftyOne's multimodal viewer.

The dataset carries no per-sample tags, no temporal tags, and dataset.info is empty — there is no extra dataset-level metadata beyond the per-sample fields below. Sensor calibration is not stored in dataset.info; it lives inside each MCAP as foxglove.CameraCalibration and foxglove.FrameTransform messages, so the viewer can use it directly. The built-in metadata field is unpopulated (None) because compute_metadata() was not run.

Totals across the 6 episodes: 1,091,709 MCAP messages, 2,481.3 seconds (41.4 minutes) of recording, 37 GB of MCAP on disk.

Episodes in this dataset

sequence_id location recording_date duration_s message_count channel_count /lidar clouds has_rgb_lidar
2024-03-12-keble-college-02 keble-college 2024-03-12 300.1 148,939 18 805 False
2024-03-13-observatory-quarter-02 observatory-quarter 2024-03-13 275.1 131,263 18 361 False
2024-03-14-blenheim-palace-05 blenheim-palace 2024-03-14 372.9 160,664 19 361 True
2024-03-20-christ-church-05 christ-church 2024-03-20 822.1 336,685 19 713 True
2024-05-20-bodleian-library-02 bodleian-library 2024-05-20 503.0 219,393 19 521 True
2024-07-09-new-college-01 new-college 2024-07-09 208.1 94,765 19 192 True

The two 18-channel episodes lack /lidar_rgb because their source point clouds already ship with colour baked in — see Parsing decisions.

The effective image rate varies markedly between episodes (from ≈4.8 Hz for christ-church-05 to ≈20 Hz for keble-college-02, computed as image count divided by episode duration). The paper documents the raw camera streams as 20 Hz, so the raw/images.zip archives for some sequences appear to be a decimated subset rather than the full stream; the counts logged here match those archives exactly.

Fields

Field FiftyOne type Description
filepath StringField Absolute path to the episode's .mcap file — the sample's multimodal media
sequence_id StringField Source sequence name (YYYY-MM-DD-<site>-<NN>), verbatim from the source repository's folder name
location StringField Site slug parsed from sequence_id (e.g. keble-college); one of 6
recording_date StringField Recording date parsed from sequence_id, YYYY-MM-DD
run_number IntField Run index at that site, parsed from the sequence_id suffix
duration_s FloatField Episode duration in seconds, computed from the MCAP's message-time span
message_count IntField Total MCAP message count across all channels
channel_count IntField Total MCAP channel (topic) count — 18 or 19
topics ListField(StringField) Every MCAP topic present (see MCAP topics)
schemas ListField(StringField) Every distinct message schema present in the episode
has_image BooleanField Has an Image-tile-decodable stream (foxglove.CompressedImage or foxglove.RawImage) — True for all
has_pointcloud BooleanField Has a 3D-tile-decodable point-cloud stream (foxglove.PointCloud) — True for all
has_gps BooleanField Has a Map-tile GPS fix stream (foxglove.LocationFix) — False for all; no GNSS exists in the source
has_imu BooleanField Has IMU telemetry — True for all; hardcoded, because the stream is logged as generic JSON rather than a recognised IMU schema
has_logs BooleanField Has a Logs-tile stream (foxglove.Log) — False for all
has_trajectory BooleanField Has a 6-DoF pose track (the world → base FrameTransform series) — True for all
has_camera_calibration BooleanField Has foxglove.CameraCalibration streams — True for all
has_depth BooleanField Has per-camera 16-bit depth maps (/depth_*) — True for all
has_depth_overlay BooleanField Has per-camera depth overlays on the camera image (/overlay_*) — True for all
has_surface_normals BooleanField Has per-camera surface-normal maps (/normal_*) — True for all
has_rgb_lidar BooleanField Has the derived camera-colourised full-sweep cloud (/lidar_rgb) — True for 4 of 6 episodes
num_cameras IntField Number of cameras in the rig — 3 for every episode

Standard FiftyOne bookkeeping fields (id, tags, metadata, created_at, last_modified_at) are also present but not source-specific.

MCAP topics (inside each episode)

Cameras use the devkit's own labels from configs/sensor.yaml: cam_front, cam_left, cam_right (source directories cam0, cam1, cam2 respectively).

Topic(s) Schema Tile Notes
/cam_front/image_raw, /cam_left/image_raw, /cam_right/image_raw foxglove.CompressedImage (jpeg) Image Raw, still-distorted fisheye JPEGs (1440×1080), byte-for-byte from the source raw/cam{0,1,2} folders
/cam_front/calibration, /cam_left/calibration, /cam_right/calibration foxglove.CameraCalibration 3D (frustums) Static, logged once at episode start; equidistant distortion model with K/D from configs/sensor.yaml
/lidar foxglove.PointCloud 3D VILENS-SLAM motion-undistorted keyframe clouds (≈1 Hz, one per SLAM pose-graph node), in frame base. Fields x,y,z,intensity,normal_x,normal_y,normal_z,curvature, or x,y,z,red,green,blue,normal_*,curvature for the two episodes whose source clouds ship colour
/lidar_rgb (4 of 6 episodes) foxglove.PointCloud 3D Derived, not a devkit product. The full sweep with RGB sampled by projecting every point into all three cameras; points no camera sees keep an intensity-derived grey. Fields x,y,z,red,green,blue
/depth_cam_front, /depth_cam_left, /depth_cam_right foxglove.RawImage (16UC1) Image Euclidean depth × 256 as uint16, equivalent to the devkit's depths_euc_accum_0 output
/overlay_cam_front, /overlay_cam_left, /overlay_cam_right foxglove.CompressedImage (jpeg) Image Depth-coloured LiDAR points drawn over the camera image (HSV colormap, radius-2 circles), equivalent to the devkit's *_overlay output
/normal_cam_front, /normal_cam_left, /normal_cam_right foxglove.CompressedImage (png) Image Surface normals from the PCD normal_* fields, rotated into the camera frame and encoded (n+1)/2·255, equivalent to the devkit's normals_euc_accum_0 output
/tf foxglove.FrameTransform 3D One static base → lidar transform at episode start, plus per SLAM keyframe: world → base and world → {cam_front, cam_left, cam_right}
/imu generic JSON (auto-named jsonschema, e.g. schema-f5wrpOiP) Plot / Message acc_x/y/z and ang_vel_x/y/z at the IMU's native rate, from raw/imu.csv

Label types and why

No FiftyOne sample-level label fields (Detections, Keypoints, Classification, etc.) are attached. Two reasons:

  1. The source dataset has no object-level annotations at all — it is a raw multi-sensor SLAM/reconstruction benchmark. Its "ground truth" is TLS 3D models and 6-DoF trajectories, used to compute benchmark metrics, not per-sample labels.
  2. Each sample is a continuous 3.5–13.7 minute recording rather than a single frame, so there is no single fixed-length list that a sample-level label field could hold.

The one label-like quantity that does exist per episode — the 6-DoF trajectory — is therefore embedded as an MCAP transform stream (/tf) inside the same timeline as the sensor data, decoded live by the multimodal viewer, exactly like the sensor topics themselves. This also lets the viewer place point clouds and camera frustums correctly in the world frame during playback. It was logged as foxglove.FrameTransform rather than as a static pose list because the viewer consumes transforms to resolve frames at each timestamp.

All remaining per-sample fields are primitives, not labels: identifiers (sequence_id, location, recording_date, run_number), MCAP inventory (duration_s, message_count, channel_count, topics, schemas), and boolean capability flags (has_*). The flags exist so episodes can be filtered in the grid without opening every MCAP first, e.g. dataset.match(F("has_rgb_lidar")). They are derived from schema names, not topic substrings, except has_imu (hardcoded True, since the IMU rides on a generic JSON channel) and the has_depth/has_depth_overlay/ has_surface_normals/has_rgb_lidar flags (derived from topic prefixes, since those products share the generic image/point-cloud schemas).

Parsing decisions

  • One sample = one full episode. The source Hugging Face repository is roughly 1.3 TB, so 6 of the 24 sequences were selected — one per site, choosing the smallest sequence at each site by download size — and each was authored as a complete recording rather than a short window.
  • Built from the per-file raw artifacts, not the ROS bags. The source ships every sequence as both ROS 1 .bag and ROS 2 .db3 (2–15 GB each) and as individual files. This build reads the individual files (raw/images.zip, raw/imu.csv, processed/vilens-slam/undist-clouds.zip, processed/vilens-slam/slam-poses.csv), which avoids the bag conversion entirely and gives the motion-undistorted, image-synchronised clouds the devkit's own tooling expects.
  • Devkit frame naming. Frames are base, lidar, cam_front, cam_left, cam_right, matching the labels in configs/sensor.yaml rather than inventing ROS-style names.
  • Cloud points are in the body frame, so they are logged as base. The undistorted PCD files' VIEWPOINT header equals the matching slam-poses.csv row, and the devkit's own undistort_sequence.py writes an identity viewpoint — i.e. the point data itself is already expressed in the sensor/body frame at capture time. Verified directly: a mid-sequence cloud whose pose is 65 m from the origin has its point centroid at the origin.
  • Camera extrinsics follow the devkit's own composition. T_base_cam = T_base_lidar @ inv(T_cam_lidar), the same expression used in the devkit's scripts/reconstruction_benchmark/main.py, with the per-camera T_cam_lidar and rig T_base_lidar read from configs/sensor.yaml. Cameras are logged as direct time-varying world → cam_* transforms at each SLAM keyframe, so the viewer never has to chain through a single-sample static transform to resolve world.
  • Depth/overlay/normal maps are ports of the devkit's own functions (oxspires_tools.depth.projection.encode_points_as_depthmap, depth.utils.get_overlay, depth.surface_normal.compute_normalmap): euclidean depth scaled by 256 into uint16, nearest point winning per pixel, HSV colormap overlay with radius-2 circles, and normal maps that flip normals toward the camera and reserve (128,128,128) for empty pixels. They were reimplemented in numpy/OpenCV rather than called directly because the devkit's projection module imports open3d, which has no wheel for this machine's platform.
  • Hidden-point removal is skipped. It is the one step of the devkit's depth pipeline that genuinely requires open3d; the devkit itself exposes this as a supported --skip_hpr flag. For a single LiDAR keyframe sweep this mainly affects points on the far side of thin occluders.
  • The projection field-of-view cone is 160°, taken from the devkit's camera_fov: 160.0 in configs/sensor.yaml, which is the value its own projection code uses to filter points before cv2.fisheye.projectPoints. Note this differs from the per-camera field of view quoted in the paper (126° × 92.4°); the devkit value was kept for fidelity to the devkit's output.
  • Image-to-cloud pairing uses a 25 ms threshold (max_time_diff_camera_and_pose: 0.025 from configs/sensor.yaml), matching each cloud to the nearest image per camera. Cameras that fall outside the threshold for a given keyframe simply get no derived frame there, which is why per-camera depth/overlay/normal counts differ slightly within an episode.
  • /lidar_rgb is only built where the source clouds lack colour. The keble-college-02 and observatory-quarter-02 undistorted clouds carry a packed PCL rgb field instead of intensity (colourised upstream by the dataset authors); for those, the colour is decoded into red/green/ blue on /lidar itself and the derived /lidar_rgb is skipped as a strictly worse duplicate — camera projection can only colour the 56–84% of points that fall inside a camera's view, whereas the upstream colour covers the whole sweep.
  • The IMU rides on a generic JSON channel, not foxglove.Imu, because imu.csv provides only linear acceleration and angular velocity — no orientation or covariance. Consequence: it is inspectable in the Plot and Message tiles but is not reported under schemas as a recognised IMU schema, hence the hardcoded has_imu.
  • Real capture timestamps throughout. Every message is logged at its source timestamp (Unix epoch nanoseconds) with no rebasing, so duration_s reflects the true recording span and all streams share one coherent clock.
  • Clouds without a matching SLAM pose are still logged. blenheim-palace-05 has 361 undistorted clouds but only 340 poses in slam-poses.csv; all 361 clouds appear on /lidar, while /tf carries 340 keyframes, so the surplus clouds render at the last resolved transform.
  • Not included in this build: the raw 10 Hz LiDAR sweeps (raw/lidar-clouds.zip), the COLMAP SfM outputs (processed/colmap/), the TLS ground-truth 3D models (ground_truth_map/), the TLS-registered ground-truth and refined trajectory variants (gt-tum.txt, hba-tum.txt, colmap-tum.txt), the TLS-rendered ground-truth depth images, and the reconstruction and novel-view-synthesis benchmark artifacts. Note also that the source repository does not currently ship processed/trajectory/ or processed/colmap/ for the New College sequences at all.

Dataset Creation

Curation Rationale

The full source repository is roughly 1.3 TB — every sequence ships raw images, raw LiDAR sweeps, ROS 1 and ROS 2 bags, VILENS-SLAM outputs and COLMAP outputs, on top of per-site TLS reference maps (about 76 GB) and benchmark result artifacts. Exhaustive coverage is impractical for a lightweight FiftyOne showcase, so this build optimises for site diversity at minimum download: one sequence per landmark, choosing the smallest available sequence at each site, giving all six architectural settings the paper describes (Bodleian Library ≈37,000 m²; Christ Church College ≈26,000 m²; Keble College ≈18,000 m²; New College ≈18,000 m²; Blenheim Palace ≈14,000 m²; Radcliffe Observatory Quarter ≈12,000 m²).

Within each episode the priority was the opposite of trimming: episodes are complete recordings, and the streams were chosen to reproduce what the devkit itself visualises — hence the inclusion of all three generate_depth.py products rather than depth maps alone.

Source Data

Data Collection and Processing

Per the paper: each sequence was collected by walking with the Frontier handheld perception unit mounted in a backpack. The unit carries three colour fisheye cameras facing forward, left and right — a customised Alphasense Core Development Kit from Sevensense Robotics AG — each 1440×1080 (1.6 MP) global shutter with a 126° × 92.4° field of view and roughly 36° of overlap between adjacent cameras, running at 20 Hz with auto-exposure enabled. A cellphone-grade IMU inside the Alphasense Core runs at 400 Hz and is hardware-synchronised to the three cameras by a Sevensense FPGA. A 64-channel Hesai QT64 LiDAR (10 Hz, 104° field of view, 60 m maximum range, ±3 cm typical accuracy) is mounted on top of the cameras.

Synchronisation is both hardware and software: the Alphasense device clock and the Hesai LiDAR are synchronised to the unit's host computer using Precision Time Protocol (sub-microsecond accuracy); the cameras' exposure intervals are aligned about their midpoints so the image triplets share one timestamp; and because the QT64 scans continuously, each point cloud is motion-corrected with IMU preintegration using VILENS and undistorted to the time of the next camera frame. The result is that every node in the SLAM pose graph has three camera images and one undistorted LiDAR cloud at an identical timestamp.

Calibration used the equidistant (Kannala-Brandt) model for the fisheye lenses: camera intrinsics and inter-camera extrinsics with Kalibr (sub-pixel reprojection residuals, 0.22–0.23 px mean), IMU noise from an eight-hour Allan variance sequence, per-camera camera-IMU extrinsics with Kalibr, and a single SE(3) camera-bundle-to-LiDAR transform with DiffCal.

Reference data: a Leica RTC360 TLS (360° × 300° field of view, 130 m range, 1.9 mm point accuracy at 10 m and 5.3 mm at 40 m, colourised from 432 megapixel imagery) scanned each site; scans were registered with Leica Cyclone REGISTER 360 Plus to 3–7 mm average cloud-to-cloud error and merged into a 1 cm colourised map. Ground-truth trajectories were then produced by ICP-registering each undistorted LiDAR cloud to that merged map with an offline version of VILENS, reaching approximately 1–2 cm accuracy. Processed outputs released alongside the raw data include the VILENS-SLAM trajectory and undistorted clouds, and COLMAP SfM results computed over images spaced 1 m apart (about 1 Hz at walking pace).

For this repackaging: the six sequences' individual-file artifacts were downloaded from the public Hugging Face repository, extracted, and packed into one .mcap file per episode with the foxglove-sdk, computing the depth/overlay/normal products with ports of the devkit's own projection code. Every episode was then verified against its own source files — image counts per camera, IMU row count, cloud count, and expected transform count all had to match exactly, with per-channel timestamp monotonicity checked — before ingest. No sensor data was synthesized, relabeled, or altered beyond the conversions documented in Parsing decisions.

Who are the source data producers?

The Oxford Robotics Institute, Department of Engineering Science, University of Oxford, with the Group of Automation, Robotics and Computer Vision (AUROVA) at the University of Alicante — specifically Yifu Tao, Miguel Ángel Muñoz-Bañón, Lintong Zhang, Jiahao Wang, Lanke Frank Tarimo Fu, and Maurice Fallon. The paper additionally acknowledges Tobit Flatscher, Ayoung Kim, Matias Mattamala, Christina Kassab, Haedam Oh, Jianeng Wang, and Dongjae Lee for help with sensing, calibration, collection, post-processing and proofreading.

Annotations

Annotation process

There is no annotation process: the Oxford Spires Dataset contains no manually labelled, object-level annotations. What the source dataset calls ground truth is produced automatically — reconstruction ground truth is the registered and merged Leica RTC360 TLS point cloud per site, and localisation ground truth is the trajectory obtained by ICP-registering each motion-undistorted LiDAR cloud against that TLS map using an offline version of VILENS. Neither of those artifacts is included in this build; the pose track logged here is the VILENS-SLAM estimate from slam-poses.csv (see Out-of-Scope Use).

Who are the annotators?

No human annotators were involved. All ground-truth quantities in the source dataset are the output of automated survey-grade scanning, registration, and SLAM/ICP post-processing performed by the dataset authors.

Personal and Sensitive Information

The recordings were made in and around public and semi-public university and palace grounds in Oxford, so incidental pedestrians can appear in the camera imagery. The ROS bag filenames in the source repository contain blurred_filtered (e.g. ..._blurred_filtered_compressed.db3), which indicates that a privacy filtering step — presumably face and licence-plate blurring — was applied upstream to the bag streams before public release.

[More Information Needed] on the specifics: neither the paper nor the devkit documents an anonymisation procedure or tool, and it is not documented whether the raw/images.zip JPEG archives used to build these episodes carry the same blurring as the bag streams. This repackaging performs no additional processing, re-identification, or redaction beyond what the Oxford Robotics Institute already released publicly.

Citation

BibTeX:

@article{tao2025spires,
  title   = {The Oxford Spires Dataset: Benchmarking Large-Scale
             LiDAR-Visual Localisation, Reconstruction and Radiance Field
             Methods},
  author  = {Tao, Yifu and Mu{\~n}oz-Ba{\~n}{\'o}n, Miguel {\'A}ngel and
             Zhang, Lintong and Wang, Jiahao and Fu, Lanke Frank Tarimo and
             Fallon, Maurice},
  journal = {The International Journal of Robotics Research},
  year    = {2025},
  doi     = {10.1177/02783649251369905}
}

APA:

Tao, Y., Muñoz-Bañón, M. Á., Zhang, L., Wang, J., Fu, L. F. T., & Fallon, M. (2025). The Oxford Spires Dataset: Benchmarking large-scale LiDAR-visual localisation, reconstruction and radiance field methods. The International Journal of Robotics Research.

More Information

This repository is an independently-curated, derived subset of the official Oxford Spires Dataset, repackaged as MCAP for FiftyOne's multimodal support. It is not an official Oxford Robotics Institute artifact, and it is subject to the source dataset's non-commercial CC BY-NC-SA 4.0 licence.

For the full dataset (all 24 sequences, raw LiDAR sweeps, ROS 1/ROS 2 bags, COLMAP outputs, per-site TLS reference maps, TLS-registered ground-truth trajectories, rendered ground-truth depth images, and the localisation / reconstruction / novel-view-synthesis benchmark artifacts and evaluation code), see:

Viewing these episodes requires FiftyOne 1.19 or newer for multimodal media support. The 6 MCAP files total 37 GB.

Dataset Card Authors

Harpreet Sahota (@harpreetsahota) — MCAP repackaging and this card. Original dataset producers are listed under Dataset Description.

Dataset Card Contact

Harpreet Sahota — https://huggingface.co/harpreetsahota
Downloads last month
392
Total file size:
39.7 GB

Paper for Voxel51/oxford-spires-multimodal