README.md

---
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](semantic_spray.gif)

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](https://mcap.dev/) recordings for
FiftyOne's native
[multimodal dataset support](https://docs.voxel51.com/user_guide/multimodal.html)
(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](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 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](#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`](https://github.com/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](https://creativecommons.org/licenses/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](https://arxiv.org/abs/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](https://arxiv.org/abs/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](#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](#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](#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](#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](#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](#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](#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](#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](https://www.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](#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](#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:**

```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](#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](#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:

- https://semantic-spray-dataset.github.io
- https://github.com/uulm-mrm/semantic_spray_dataset
- https://oparu.uni-ulm.de/items/a4b310b9-bf50-431b-9676-7398f6da7dd0

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](https://huggingface.co/harpreetsahota))
— MCAP repackaging and this card. Original dataset producers are listed
under [Dataset Description](#dataset-description).

## Dataset Card Contact

Harpreet Sahota — https://huggingface.co/harpreetsahota