--- 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 (`_dynamic/__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