| --- |
| 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) |
|
|
|  |
|
|
| 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 |
|
|
