Datasets:

Voxel51
/

semanticspray-plusplus

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:  (... 412 chars omitted)
  child 0, item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type: string, _ra (... 400 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, scene_rel_path: string
      child 6, scene_name: string
      child 7, vehicle_type: string
      child 8, num_scans: int64
      child 9, duration_s: double
      child 10, has_object_labels: bool
      child 11, ego_velocity_kmh: double
      child 12, object_velocity_kmh: double
      child 13, distance_to_object_m: double
      child 14, object_direction: int64
      child 15, amb_tmp_c: double
      child 16, source_bag: string
      child 17, _dataset_id: struct<$oid: string>
          child 0, $oid: string
      child 18, created_at: struct<$date: string>
          child 0, $date: string
      child 19, last_modified_at: struct<$date: string>
          child 0, $date: string
group_media_types: null
info: null
app_config: null
classes: null
mask_targets: null
default_mask_targets: null
skeletons: null
camera_intrinsics: null
static_transforms: null
annotation_runs: null
brain_methods: null
evaluations: null
runs: null
label_schemas: null
frame_label_s
...
ruct<name: string, ftype: string, embedded_doc_type: string, subfield: string, fields: list<item:  (... 306 chars omitted)
      child 0, name: string
      child 1, ftype: string
      child 2, embedded_doc_type: string
      child 3, subfield: string
      child 4, fields: list<item: struct<name: 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
tags: list<item: null>
  child 0, item: null
default_classes: list<item: null>
  child 0, item: null
frame_fields: list<item: null>
  child 0, item: null
last_modified_at: struct<$date: string>
  child 0, $date: string
sample_collection_name: string
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': {'$date': Value('string')}, '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:  (... 412 chars omitted)
                child 0, item: struct<_id: struct<$oid: string>, filepath: string, tags: list<item: null>, _media_type: string, _ra (... 400 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, scene_rel_path: string
                    child 6, scene_name: string
                    child 7, vehicle_type: string
                    child 8, num_scans: int64
                    child 9, duration_s: double
                    child 10, has_object_labels: bool
                    child 11, ego_velocity_kmh: double
                    child 12, object_velocity_kmh: double
                    child 13, distance_to_object_m: double
                    child 14, object_direction: int64
                    child 15, amb_tmp_c: double
                    child 16, source_bag: string
                    child 17, _dataset_id: struct<$oid: string>
                        child 0, $oid: string
                    child 18, created_at: struct<$date: string>
                        child 0, $date: string
                    child 19, last_modified_at: struct<$date: string>
                        child 0, $date: string
              group_media_types: null
              info: null
              app_config: null
              classes: null
              mask_targets: null
              default_mask_targets: null
              skeletons: null
              camera_intrinsics: null
              static_transforms: null
              annotation_runs: null
              brain_methods: null
              evaluations: null
              runs: null
              label_schemas: null
              frame_label_s
              ...
              ruct<name: string, ftype: string, embedded_doc_type: string, subfield: string, fields: list<item:  (... 306 chars omitted)
                    child 0, name: string
                    child 1, ftype: string
                    child 2, embedded_doc_type: string
                    child 3, subfield: string
                    child 4, fields: list<item: struct<name: 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
              tags: list<item: null>
                child 0, item: null
              default_classes: list<item: null>
                child 0, item: null
              frame_fields: list<item: null>
                child 0, item: null
              last_modified_at: struct<$date: string>
                child 0, $date: string
              sample_collection_name: string
              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': {'$date': Value('string')}, '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 SemanticSpray++ Multimodal (MCAP)

A FiftyOne build of the SemanticSpray++ dataset (Piroli, Dallabetta, Kopp, Walessa, Meissner & Dietmayer; Institute of Measurement, Control, and Microtechnology, Ulm University, with BMW AG), a multimodal labeled dataset for testing camera, LiDAR, and radar perception in wet-surface "vehicle spray" conditions. This build repackages the 36-scene labeled subset (SemanticSpray++'s own contribution on top of the earlier SemanticSpray dataset) as time-synchronized MCAP recordings for FiftyOne's native multimodal dataset support (FiftyOne 1.19+). Each sample is one episode — one vehicle-following recording — viewable in FiftyOne's tiled multimodal viewer with synchronized camera imagery, three point-cloud streams (top LiDAR + two low-res LiDARs), a radar point stream, and the full label set for the lead vehicle: 2D camera boxes, 3D LiDAR boxes, LiDAR point-wise semantic labels, and radar point-wise semantic labels.

This is a FiftyOne dataset with 36 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/semanticspray-plusplus")

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

Dataset Details

Dataset Description

SemanticSpray++ labels a subset of scenes from the RoadSpray dataset — raw, unlabeled recordings of vehicles following each other on wet surfaces in a highway-like scenario. The ego vehicle follows a lead vehicle (a small car or a large van) at a fixed distance (20 m or 30 m) while both travel at matched speeds from 50–130 km/h in 10 km/h steps, on a closed airstrip (no other traffic), generating a trailing water-spray plume off the wet pavement. The ego vehicle carries a roof-mounted high-resolution LiDAR, two low-resolution LiDARs (front/rear), a front-mounted long-range radar, and a front-mounted camera.

SemanticSpray++ extends an earlier release, SemanticSpray (the same authors' RA-L 2023 paper), which provides LiDAR point-wise semantic labels (background / foreground / noise) for all scenes in the RoadSpray subset the authors worked with. SemanticSpray++ (IV 2024) adds, for a 36-scene subset chosen to cover a range of speeds, distances, and both lead-vehicle types: 2D bounding boxes on the camera image, 3D bounding boxes on the LiDAR point cloud, and semantic labels on the radar points — all for the lead vehicle, with Car (small vehicle) and Van (large vehicle) as the primary classes.

This FiftyOne build covers all 36 of those labeled scenes — every episode in this dataset has the full label set. See Curation Rationale for why the other, LiDAR-only scenes from the same download are excluded.

Curated by: Aldi Piroli, Vinzenz Dallabetta, Johannes Kopp, Marc Walessa, Daniel Meissner, Klaus Dietmayer — Institute of Measurement, Control, and Microtechnology, Ulm University, and BMW AG — original scenario design, sensor recording (RoadSpray), and all label annotation (SemanticSpray / SemanticSpray++). This MCAP/FiftyOne multimodal repackaging (episode authoring, dataset card) was prepared independently by Harpreet Sahota.
Funded by: [More Information Needed] — neither paper's text discloses a funding source or grant number.
Shared by: Harpreet Sahota (this repackaging); the original dataset is shared by the authors via https://semantic-spray-dataset.github.io , the uulm-mrm/semantic_spray_dataset devkit repository, and Ulm University's OPARU institutional repository (https://oparu.uni-ulm.de/items/a4b310b9-bf50-431b-9676-7398f6da7dd0).
Language(s): N/A (sensor data — camera, LiDAR, radar; no text).
License: CC BY 4.0 for the dataset itself, confirmed on the OPARU landing page and the bundled README.txt. The devkit's own toolkit code (loaders, converters, visualization scripts) is separately MIT-licensed (Copyright (c) 2023 Aldi Piroli).

Dataset Sources

Repository: https://github.com/uulm-mrm/semantic_spray_dataset (devkit; the paper's own text points at github.com/aldipiroli/semantic_spray_dataset, which now 301-redirects here — the repo moved to the Ulm University MRM org at some point after publication)
Paper:
- Piroli, A., Dallabetta, V., Kopp, J., Walessa, M., Meissner, D., & Dietmayer, K. (2023). Energy-based Detection of Adverse Weather Effects in LiDAR Data. IEEE Robotics and Automation Letters. arXiv:2305.16129 — introduces the base SemanticSpray dataset (LiDAR semantic labels).
- Piroli, A., Dallabetta, V., Kopp, J., Walessa, M., Meissner, D., & Dietmayer, K. (2024). SemanticSpray++: A Multimodal Dataset for Autonomous Driving in Wet Surface Conditions. 2024 IEEE Intelligent Vehicles Symposium (IV). arXiv:2406.09945 — introduces the SemanticSpray++ boxes + radar labels used by this build.
- Base raw recordings: Linnhoff, C., Elster, L., Rosenberger, P., & Winner, H. (2022). Road spray in lidar and radar data for individual moving objects. Technical University of Darmstadt. https://tudatalib.ulb.tu-darmstadt.de/handle/tudatalib/3537
Demo: https://semantic-spray-dataset.github.io (official project page)

Uses

Direct Use

Exercising/demoing FiftyOne's multimodal MCAP support: synchronized playback of camera, three point-cloud streams, radar, 2D/3D boxes, and point-wise semantic labels, across 36 short (4–13 s) real driving episodes.
Browsing/qualitatively reviewing how LiDAR spray noise, camera occlusion (windshield wipers, blur, overexposure), and radar semantics vary with driving speed (50–130 km/h), following distance (20 m / 30 m), and lead vehicle type (Car vs. Van) — the sample-level fields make this filterable in the grid without opening every MCAP.
Prototyping detection/segmentation pipelines against real (not simulated) multimodal adverse-weather ground truth: every episode has 2D camera boxes, 3D LiDAR boxes, LiDAR point-wise semantic labels, and radar point-wise semantic labels for the lead vehicle.
Inspecting the effect of spray on LiDAR point density and radar returns qualitatively, as a companion to the paper's own quantitative baselines (PointPillars/SECOND/CenterPoint for 3D detection, YOLOv8 for 2D detection, SPVCNN for semantic segmentation) — this build does not include those model weights or evaluation code (see Out-of-Scope Use).

Out-of-Scope Use

Reproducing the paper's baseline benchmark numbers (Tables I/II and the segmentation confusion matrices). Those require the devkit's own OpenPCDet/SPVCNN data loaders and the specific train/fine-tune splits used in the paper; this build only repackages the labeled MCAP episodes, not a training pipeline.
Any use of the 171 LiDAR-only ("SemanticSpray", no boxes) scenes from the same OPARU download — they are not included in this build (see Curation Rationale).
Cross-modal geometric projection using camera intrinsics/extrinsics — no camera calibration exists anywhere for this dataset (not in the OPARU download, the devkit, or the user-supplied calibration.json). The camera stream is Image-tile-only; it is not connected to the /tf tree.
Treating the radar's value channel as a confirmed Doppler velocity. The paper's text describes radar points as (x, y, vx, vy), but the raw file's corresponding column does not behave like a velocity component in this build's source files (see Parsing decisions); it is carried through unlabeled as value, not vx/vy.
Treating episode timestamps as real capture times. The source archive has no per-scan capture time; timestamps here are synthesized (recording start time + an assumed 10 Hz spacing) purely for smooth MCAP playback.

Dataset Structure

This is a flat (ungrouped) FiftyOne dataset with media_type: "multimodal" and 36 samples. Each sample is one episode (one RoadSpray recording scene), 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 is decoded live by FiftyOne's multimodal viewer.

The dataset carries no per-sample tags, no temporal tags, and dataset.info is empty. The built-in metadata field is unpopulated (None) because compute_metadata() was not run. Sensor extrinsics are not stored in dataset.info; they live inside each MCAP as /tf (foxglove.FrameTransforms) messages — see Parsing decisions for their provenance.

Totals across the 36 episodes: 2,587 scans/frames, 20,178 MCAP messages, 255.1 s of recording summed across all (independent, not contiguous) episodes, ~1.52 GB of MCAP on disk. 18 episodes have the Car (VW Golf) lead vehicle, 18 have the Van (VW Crafter); speeds span 50–130 km/h in 10 km/h steps; following distance is 20 m or 30 m.

Label totals (verified directly against the source .json/.npy/.label files, not estimated):

Modality	Class	Count
Camera 2D boxes	`Car` / `Van` / `Other Vehicle` / `Person`	1,362 / 1,225 / 44 / 27
LiDAR 3D boxes	`Car` / `Van` / `Other Vehicle`	1,362 / 1,225 / 8
Radar point semantics	`Background` / `Van` / `Car` / `Other Vehicle`	1,915 / 1,500 / 1,410 / 7 (points, not boxes)
LiDAR point semantics	`background` / `noise` / `foreground`	75,566,282 (97.11%) / 1,669,602 (2.15%) / 577,305 (0.74%) — of 77,813,189 total points

Other Vehicle and Person are camera-box-only in the LiDAR case (no Person LiDAR/radar equivalent exists) — richer than the papers' headline "Car and Van" framing, but present in every source label file.

Fields

Field	FiftyOne type	Description
`filepath`	`StringField`	Absolute path to the episode's `.mcap` file — the sample's multimodal media
`scene_rel_path`	`StringField`	Source scene folder path (`<Vehicle>_dynamic/<NNNN>_<recording-datetime>_0`), verbatim from the source archive
`scene_name`	`StringField`	Scene folder's own name (basename of `scene_rel_path`)
`vehicle_type`	`StringField`	Lead vehicle, parsed from the folder name: `Golf` (small car) or `Crafter` (van)
`num_scans`	`IntField`	Number of LiDAR scans (frames) in the episode
`duration_s`	`FloatField`	Episode duration, computed as `(num_scans - 1) / 10 Hz` — see the timestamp caveat in Parsing decisions
`has_object_labels`	`BooleanField`	`True` for every sample in this build (all 36 are the labeled subset) — kept for schema parity with a hypothetical wider build, not because it varies here
`ego_velocity_kmh`	`FloatField`	Ego vehicle speed for the episode, from `metadata.txt`
`object_velocity_kmh`	`FloatField`	Lead vehicle speed, from `metadata.txt` — always equal to `ego_velocity_kmh` (constant-relative-distance following)
`distance_to_object_m`	`FloatField`	Following distance: `20.0` or `30.0`
`object_direction`	`IntField`	`+1`/`-1`, which way down the airstrip the episode runs
`amb_tmp_c`	`FloatField`	Ambient temperature at recording time, from `metadata.txt`
`source_bag`	`StringField`	Original ROS bag filename this episode was extracted from

Standard FiftyOne bookkeeping fields (id, tags, metadata, created_at, last_modified_at) are also present but not source-specific. ego_velocity_kmh/object_velocity_kmh/distance_to_object_m/ object_direction/amb_tmp_c are constant scalars for the whole episode (one row per scene in metadata.txt), not time-varying telemetry — that's why they're sample fields rather than an MCAP Plot-tile stream.

MCAP topics (inside each episode)

Topic	Schema	Frame	Notes
`/camera/image`	`foxglove.CompressedImage`	`camera`	Raw JPEG bytes, all scans, 2048×1088
`/camera/annotations`	`foxglove.ImageAnnotations`	(2D, image space)	2D box per scan as a `PointsAnnotation` LineLoop (source JSON's 4 corner points, already correctly wound) + a `TextAnnotation` with the box's class name, color-coded by class
`/velodyne_points`	`foxglove.PointCloud`	`velodyne`	`x,y,z,intensity,ring` + RGB colored by the LiDAR point-wise semantic label (background/foreground/noise)
`/front_ibeo_lux`, `/rear_ibeo_lux`	`foxglove.PointCloud`	`ibeo_lux_front`, `ibeo_lux_rear`	`x,y,z,intensity` + a fixed per-sensor color; no message is logged for a scan where that sensor returned 0 points (see Parsing decisions)
`/delphi_esr_detection_visu`	`foxglove.PointCloud`	`radar`	Native `(x, y, z=0)` in the radar's own frame + a `value` field (see the radar caveat above) + RGB colored by the radar point-wise semantic label
`/objects/lidar_boxes`	`foxglove.SceneUpdate`	`velodyne`	3D cuboid(s) per scan (`CubePrimitive`, color-coded by class) + a billboarded `TextPrimitive` per box with the class name
`/tf`	`foxglove.FrameTransforms`	—	`base_link → {velodyne, ibeo_lux_front, ibeo_lux_rear, radar}`, re-logged every scan (not once) so the 3D tile can always resolve the frame — see Parsing decisions

Label types and why

No FiftyOne sample-level label fields (Detections, Segmentation, etc.) are attached to the samples. The annotations are real and dense — every one of the 2,587 scans in this build has all four label types — but they are per-frame within a multi-frame episode sample, not a single fixed-length label for the whole sample the way a Detections field on an image sample would be. They are logged as native MCAP schemas (ImageAnnotations/SceneUpdate/colored PointCloud) instead, decoded live by the multimodal viewer's Image and 3D tiles in sync with playback, which is the same modeling choice the fiftyone-multimodal-import skill uses for any per-frame content inside an episode.

All sample-level fields are primitives (identifiers, scan/duration counts, and the metadata.txt columns) — see the Fields table above.

Parsing decisions

One sample = one scene folder (episode), not one sample per scan. Each scene is a short synchronized multi-sensor recording (camera + top LiDAR + 2 low-res LiDARs + radar advancing scan-by-scan), matching the fiftyone-multimodal-import skill's episode model directly.
Scope: only the 36 SemanticSpray++ labeled scenes. The other 171 scenes in the same OPARU download (SemanticSpray, LiDAR-semantic-only, no boxes) are deliberately not included in this build — see Curation Rationale.
Radar point cloud is native 2D (x, y, z=0) in the radar's own frame. The raw .bin file's 3rd column is a dataset-wide constant (0.44) that is exactly the radar's calibrated mount height above the rear axle in the user-supplied calibration.json — i.e. mounting-height leakage baked in by whoever extracted these files from the original rosbags, not a real per-point measurement. The static base_link → radar transform (z=0.44) places the flat plane at the correct physical height via the frame graph instead.
No camera calibration exists anywhere — not in the OPARU download, not in the devkit, not in the user-supplied calibration.json (which covers only the LiDARs, radar, and GNSS/IMU reference point). The camera frame is intentionally left unconnected to the /tf tree.
LiDAR/radar/GNSS-IMU extrinsics come from a user-supplied calibration.json, not from the OPARU download or the devkit repo (neither ships any calibration at all). Its provenance is unconfirmed — likely originating from the original RoadSpray sensor setup documentation (possibly fzd-datasets.de/spray, unconfirmed) — see the file's own _provenance field before citing it further.
The devkit's own get_3D_boxes_openPCDet_format() has a bug — it reads contour["center3D"] instead of contour["rotation3D"] when building the box heading. This build does not use that function; heading is parsed directly from rotation3D.z (radians).
poses.txt is not used. Its translation column and bottom row are always 0.0 in every scene checked — not a valid homogeneous transform — so no trajectory/TF channel is derived from it.
/tf is re-logged every scan, not once. A single one-shot transform message is spec-valid but ages out of the 3D tile's transform-lookup window a few seconds into playback (point clouds would disappear while the Image tile, which needs no frame lookup, kept playing) — an earlier build of this pipeline had this bug; the values themselves never change scan-to-scan, only the timestamp does.
Box className is preserved and color-coded, not just drawn as a plain box. Every 2D/3D box carries its source className (Car/Van/Other Vehicle/Person) as a text label, and boxes are colored per class using the same palette as the radar point-semantic colors, so the same class reads as the same color across the camera 2D, LiDAR 3D, and radar tiles.
Scans with 0 points get no message on that topic, rather than a spec-valid-but-empty one. This is most common on /rear_ibeo_lux (up to ~95% zero-point scans in some episodes; /front_ibeo_lux is never zero, /velodyne_points is never zero, /delphi_esr_detection_visu has one zero-point scan total across all 36 episodes) and appeared to make the 3D tile's point-cloud renderer show a load error on the affected topic. No points are fabricated either way — the sensor's silence on a scan is left as "no message," not "message with invented points."
Timestamps are synthesized, not real capture times. The archive stores no per-scan capture time, only a sequential scan index per scene. t0 is parsed from the scene folder name's recording datetime; scans are spaced at an assumed 10 Hz. This is a smoothness approximation for playback, not a verified capture rate — do not reason about absolute wall-clock time from it.
Two open/unverified caveats, not yet resolved as of this card: the top LiDAR's calibrated yaw (≈ -90°) has not been visually confirmed against the camera's forward direction (risk of a double-rotation if the raw .bin data is already vehicle-forward-aligned), and the radar's value field (raw column, range ≈ -19..35) has not been confirmed against the sensor's own datasheet as a Doppler/range-rate quantity.
Not included in this build: the 171 LiDAR-only scenes from the same download, poses.txt, camera calibration/frustum data (none exists), and the devkit's OpenPCDet/SPVCNN data loaders and trained baseline weights.

Dataset Creation

Curation Rationale

The full OPARU download covers all 207 RoadSpray scenes SemanticSpray labels for LiDAR point-wise semantics (17,419 scans, ~16 GB), of which only 36 scenes (2,587 scans) additionally have the SemanticSpray++ label set (2D camera boxes, 3D LiDAR boxes, radar point semantics). This build targets exactly that 36-scene labeled subset — every episode has the complete, dense label set, so there is nothing to filter with a has_object_labels flag and no partially-labeled episode in the grid. The other 171 scenes were deliberately excluded rather than included with a filter flag, matching an explicit request to build "the SemanticSpray++ dataset" specifically. The corresponding raw scene folders were also removed from local disk once this build was authored (freeing ~14 GB); they remain re-downloadable from OPARU if a wider, LiDAR-only-inclusive build is ever wanted later.

Source Data

Data Collection and Processing

Per the papers: the RoadSpray recordings were made on a closed airstrip (highway-like, no other traffic) with an ego vehicle following a lead vehicle (a small car or a large van) at a fixed distance (20 m or 30 m) across speeds 50–130 km/h in 10 km/h increments, generating a trailing water-spray plume off the wet pavement. The ego vehicle carried a top-mounted high-resolution LiDAR, a front-mounted long-range radar, and a front-mounted camera (two additional low-resolution LiDARs, front and rear, are present in the released files but are not described in either paper's text). Because the different sensors record at different frequencies, the LiDAR was used as the synchronization signal when extracting per-sensor files from the raw ROS bags. LiDAR points are (x, y, z, intensity, ring); the camera is 2048×1088 RGB JPEG; radar points are described in the paper as (x, y, vx, vy) (see the caveat under Out-of-Scope Use on why this build does not label the corresponding column vx/vy).

For this repackaging: the 36 labeled scene folders were extracted from Ulm University's OPARU institutional repository (DSpace REST API, since the devkit's own download.sh bitstream URLs return stale 724-byte stub responses), checksum-verified, and packed one .mcap file per scene with the foxglove-sdk, adding a user-supplied calibration.json (see Parsing decisions) as the /tf stream so the multimodal viewer's 3D tile can place every point cloud in one consistent frame. No label values were altered, relabeled, or synthesized beyond the conversions documented there.

Who are the source data producers?

The Institute of Measurement, Control, and Microtechnology, Ulm University, and BMW AG (Aldi Piroli, Vinzenz Dallabetta, Johannes Kopp, Marc Walessa, Daniel Meissner, Klaus Dietmayer) produced the SemanticSpray and SemanticSpray++ labels. The underlying raw recordings (RoadSpray) were produced by Christian Linnhoff, Lukas Elster, Philipp Rosenberger, and Hermann Winner at the Technical University of Darmstadt.

Annotations

Annotation process

Per the SemanticSpray++ paper (Section III-B):

LiDAR point-wise semantics (background / foreground / noise): manual per-point labeling (from the earlier SemanticSpray/RA-L 2023 paper).
Camera 2D boxes: manual, one box per lead-vehicle instance per frame, format [top-left, top-right, bottom-left, bottom-right] in pixel coordinates. Many frames have the lead vehicle partially or totally occluded (windshield wipers, spray blur, sun glare/overexposure); for these, box positions are interpolated between two visible frames rather than left unlabeled.
LiDAR 3D boxes: manual, format [x, y, z, w, h, l, θ] (center + dimensions + heading around the z-axis), one box per lead-vehicle instance per frame.
Radar point semantics: semi-automatic — radar points are projected into the LiDAR frame using the sensors' calibration, then labeled Car or Van if they fall inside the corresponding 3D LiDAR box, Background otherwise; every radar scan is then manually checked and any incorrect automatic labels are fixed by hand.

Who are the annotators?

[More Information Needed] — neither paper names individual annotators beyond the papers' own author list; the annotation work is presented as having been done by the authors/their research group.

Personal and Sensitive Information

The recordings were made on a closed, private airstrip with no public traffic, and the scenario involves only the ego and lead test vehicles. However, the source label files' class taxonomy includes a camera-only Person class (27 boxes across the 36 episodes) that neither paper's text mentions (both papers describe only Car and Van) — this suggests incidental people (e.g. test staff) appear in some camera frames. [More Information Needed] on their identity or consent status; this repackaging performs no additional blurring, redaction, or re-identification beyond what the source release already contains, and does not know whether any privacy filtering was applied upstream.

Citation

BibTeX:

@article{piroli2023energybased,
  title   = {Energy-based Detection of Adverse Weather Effects in LiDAR Data},
  author  = {Piroli, Aldi and Dallabetta, Vinzenz and Kopp, Johannes and
             Walessa, Marc and Meissner, Daniel and Dietmayer, Klaus},
  journal = {IEEE Robotics and Automation Letters},
  year    = {2023}
}

@inproceedings{piroli2024semanticsprayplusplus,
  title     = {SemanticSpray++: A Multimodal Dataset for Autonomous Driving
               in Wet Surface Conditions},
  author    = {Piroli, Aldi and Dallabetta, Vinzenz and Kopp, Johannes and
               Walessa, Marc and Meissner, Daniel and Dietmayer, Klaus},
  booktitle = {2024 IEEE Intelligent Vehicles Symposium (IV)},
  year      = {2024}
}

@techreport{linnhoff2022roadspray,
  title      = {Road spray in lidar and radar data for individual moving
                objects},
  author     = {Linnhoff, Christian and Elster, Lukas and Rosenberger,
                Philipp and Winner, Hermann},
  year       = {2022},
  institution = {Technical University of Darmstadt},
  url        = {https://tudatalib.ulb.tu-darmstadt.de/handle/tudatalib/3537}
}

APA:

Piroli, A., Dallabetta, V., Kopp, J., Walessa, M., Meissner, D., & Dietmayer, K. (2023). Energy-based detection of adverse weather effects in LiDAR data. IEEE Robotics and Automation Letters.

Piroli, A., Dallabetta, V., Kopp, J., Walessa, M., Meissner, D., & Dietmayer, K. (2024). SemanticSpray++: A multimodal dataset for autonomous driving in wet surface conditions. In 2024 IEEE Intelligent Vehicles Symposium (IV).

Linnhoff, C., Elster, L., Rosenberger, P., & Winner, H. (2022). Road spray in lidar and radar data for individual moving objects. Technical University of Darmstadt. https://tudatalib.ulb.tu-darmstadt.de/handle/tudatalib/3537

More Information

This repository is an independently-curated, derived subset of the official SemanticSpray++ dataset, repackaged as MCAP for FiftyOne's multimodal support. It is not an official Ulm University or BMW AG artifact, and it is subject to the source dataset's CC BY 4.0 license.

Two things worth flagging for anyone extending this build:

The SemanticSpray (RA-L 2023) paper's abstract states LiDAR semantic labels for "16,565 dynamic scenes," while the full OPARU download (207 scenes, 17,419 scans total) matches this project's own recon count exactly but not the paper's headline figure. This discrepancy was not chased down further since the 171 LiDAR-only scenes it would affect are out of scope for this build (see Curation Rationale).
The user-supplied calibration.json used for the /tf stream is not part of any official release checked so far — see the provenance caveat under Parsing decisions before relying on its exact values for anything beyond this build's own 3D-tile placement.

For the full dataset (all 207 scenes including the 171 LiDAR-only ones, and the devkit's OpenPCDet/SPVCNN loaders and baseline evaluation code), see:

Viewing these episodes requires FiftyOne 1.19 or newer for multimodal media support. The 36 MCAP files total ~1.52 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: 606

Total file size:

1.56 GB

Papers for Voxel51/semanticspray-plusplus

SemanticSpray++: A Multimodal Dataset for Autonomous Driving in Wet Surface Conditions

Paper • 2406.09945 • Published Jun 14, 2024

Energy-based Detection of Adverse Weather Effects in LiDAR Data

Paper • 2305.16129 • Published Jun 29, 2023