Hugging Face's logo

Datasets:
Voxel51
/
semanticspray-plusplus

Tasks:
Robotics
Languages:
English
Size:
n<1K
ArXiv:
Tags:
fiftyone
mcap
multimodal
robotics
autonomous-driving
lidar
Libraries:
FiftyOne
License:
Dataset card Files
xet
 Community
semanticspray-plusplus / README.md
harpreetsahota's picture
harpreetsahota
Update README.md
778fea9 verified
preview code
|
Raw
History Blame Contribute Delete
29.8 kB
metadata 
annotations_creators:
  - expert-generated
language: en
license: cc-by-4.0
size_categories:
  - n<1K
task_categories:
  - robotics
task_ids: []
pretty_name: SemanticSpray++ Multimodal (MCAP)
tags:
  - fiftyone
  - mcap
  - multimodal
  - robotics
  - autonomous-driving
  - lidar
  - radar
  - point-cloud
  - camera
  - object-detection
  - semantic-segmentation
  - adverse-weather
description: >-
  The SemanticSpray++ dataset (Ulm University / BMW AG), ingested into a
  FiftyOne multimodal dataset: 36 MCAP episodes of a vehicle-following recording
  on a closed airstrip in wet surface conditions, each with synchronized camera,
  top-mounted LiDAR, two low-res LiDARs, and front radar, plus 2D camera boxes,
  3D LiDAR boxes, LiDAR point-wise semantic labels, and radar point-wise
  semantic labels for the lead vehicle in every episode.
dataset_summary: >


  This is a [FiftyOne](https://github.com/voxel51/fiftyone) dataset with 36
  samples.


  ## Installation


  If you haven't already, install FiftyOne:


  ```bash

  pip install -U fiftyone

  ```


  ## Usage


  ```python

  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 Card for SemanticSpray++ Multimodal (MCAP)

image/png

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