| --- |
| license: cc-by-4.0 |
| extra_gated_prompt: "This dataset is released under CC BY 4.0. By accessing it, you agree to credit it and to cite it as indicated in the Citation section of this card." |
| extra_gated_button_content: "Agree and access the dataset" |
| pretty_name: SAVAV |
| task_categories: |
| - audio-classification |
| - object-detection |
| tags: |
| - audio |
| - video |
| - multimodal |
| - autonomous-driving |
| - simulation |
| - microphone-array |
| - sound-event-localization |
| size_categories: |
| - 10K<n<100K |
| configs: |
| - config_name: NEW |
| data_files: SAVAV_official/annotations/annotations_NEW.csv |
| - config_name: FEV |
| data_files: SAVAV_official/annotations/annotations_FEV.csv |
| - config_name: TJ |
| data_files: SAVAV_official/annotations/annotations_TJ.csv |
| --- |
| # SAVAV — simulated audio-visual recordings of road vehicles around an ego vehicle |
|
|
| SAVAV contains simulated recordings of cars, vans and motorcycles passing, crossing, following or overtaking an ego vehicle that carries an |
| 8-microphone array and three cameras. The scenes are simulated to match real recordings made on a test site with four environments: an open |
| concrete taxiway with a T-junction, a road along a hedge, a junction next to a large hall, and a narrow access track in a thicket. |
|
|
| All the data are in the folder `SAVAV_official/`. Every run has its sound, the images of its three cameras, its ground-truth geometry and |
| its labels, aligned second by second (see [Alignment](#alignment-of-sound-images-and-labels)). This version contains 2 107 runs |
| (17 h 35 min 45 s) simulated in overcast weather on a dry road. |
|
|
| ## Content |
|
|
| | split | families | runs | duration (sound, images and labels) | annotation rows | download size | |
| |---|---|---|---|---|---| |
| | `NEW` | 30 | 1 679 | 55 565 s (15 h 26 min 05 s) | 91 465 | 358.9 GB (audio 14.1 GB, stems 90.8 GB, images 253.0 GB) | |
| | `FEV` | 38 | 389 | 6 425 s (1 h 47 min 05 s) | 7 459 | 22.4 GB (audio 1.5 GB, images 20.7 GB) | |
| | `TJ` | 21 | 39 | 1 355 s (22 min 35 s) | 1 882 | 3.4 GB (audio 0.2 GB, stems 1.6 GB, images 1.6 GB) | |
| | total | 89 | 2 107 | 63 345 s (17 h 35 min 45 s) | 100 806 | 384.7 GB (audio 15.9 GB, stems 92.4 GB, images 275.3 GB) | |
|
|
| Every second of every run is labelled and has its 8-channel sound and 20 images per camera; a second with vehicles on two sides of the |
| ego has two annotation rows. |
|
|
| - `NEW`: new scenarios with 1 to 4 vehicles around a parked or driving ego (pass-bys, crossings, overtakes, lead and following vehicles, |
| the ego pulling out at a junction), with mirrored variants. |
| - `FEV`: replays of the real recordings, same vehicles and same trajectories. |
| - `TJ`: replays of the T-junction recordings, ego parked at 10, 50 and 100 m from the junction. |
|
|
| <!-- schematics --> |
| ## Scenario types |
|
|
| Every run of the dataset belongs to one of thirteen scenario types. The schematics below are neutral bird's-eye views, valid for any vehicle (car, van or motorcycle) and any of the four environments: solid red = main path, dotted red = mirror direction, thin red = lane or distance variants, blue = ego path, dashed boxes = optional positions, light-blue wedge = field of view of the ego cameras. Distances are to scale (scale bar in each figure). `annotations/scenario_types.csv` gives the type of every scenario. |
|
|
|  |
|
|
| | Type | Ego | Environments | Scenarios | Runs | Speeds | Closest approach | |
| |---|---|---|---|---|---|---| |
| | S01 Single pass-by | static (128 runs) / driving (50 runs) | W F T O | 35 | 178 | 29-55 km/h | 12-44 m | |
| | S02 Convoy pass-by | static (159 runs) / driving (148 runs) | W F T O | 34 | 307 | 28-49 km/h | 14-44 m | |
| | S03 Hidden pass-by | static (68 runs) / driving (86 runs) | W F T O | 18 | 154 | 28-49 km/h | 15-48 m | |
| | S04 Opposite-direction crossing | static (93 runs) / driving (56 runs) | W F T O | 18 | 149 | 27-50 km/h | 14-47 m | |
| | S05 Mixed traffic from both sides | static (288 runs) / driving (368 runs) | W F T O | 56 | 656 | 31-50 km/h | 15-46 m | |
| | S06 Platoon at the T-junction | static | O | 21 | 39 | 10-52 km/h | 23-144 m | |
| | S07 Stopped at the junction | static | O | 1 | 12 | 21-40 km/h | 6-119 m | |
| | S08 Ego overtaken | driving | F O | 19 | 147 | 32-64 km/h | 3-7 m | |
| | S09 Ego overtakes | driving | O | 1 | 10 | 10-20 km/h | 3-4 m | |
| | S10 Lead or following vehicle | driving | F O | 7 | 49 | 26-49 km/h | 6-40 m | |
| | S11 Oncoming traffic | driving | O | 1 | 10 | 31-50 km/h | 4-5 m | |
| | S12 Ego pulling out | driving | W F T O | 32 | 160 | 31-50 km/h | 7-14 m | |
| | S13 Ego overtakes with oncoming traffic | driving | F O | 24 | 236 | 16-39 km/h | 4-18 m | |
|
|
| Total: 2107 runs. |
|
|
| ### S01 Single pass-by |
|
|
| One vehicle drives past the static ego, from the left or from the right (mirror). |
|
|
|  |
|
|
| Families: `hedge_drive` (NEW, 30 runs), `T5_T-J_W_30kmh` (FEV, 18 runs), `T5_T-J_50kmh` (FEV, 14 runs), `BMW_T-J_50kmh` (FEV, 12 runs), `BMW_T-J_W_50kmh` (FEV, 12 runs), `T5_T-J_30kmh` (FEV, 12 runs), `BMW_T-J_30kmh` (FEV, 10 runs), `T5_T-J_F_50kmh` (FEV, 10 runs), `hedge` (NEW, 10 runs), `junction_occluded_drive` (NEW, 10 runs), `track_drive` (NEW, 10 runs), `T5_T-J_T_30kmh` (FEV, 8 runs), `T5_T-J_T_30kmh_ego26m` (FEV, 8 runs), `BMW_T-J_50kmh_opposite_lane` (FEV, 4 runs), `BMW_T-J_F_30kmh2` (FEV, 3 runs), `BMW_T-J_F_30kmh3` (FEV, 2 runs), `BMW_T-J_F_30kmh4` (FEV, 2 runs), `BMW_T-J_F_30kmh5` (FEV, 2 runs), `BMW_T-J_F_30kmh` (FEV, 1 runs). |
|
|
| ### S02 Convoy pass-by |
|
|
| Two to four vehicles follow each other past the static ego, same direction. |
|
|
|  |
|
|
| Families: `hedge_multi_drive` (NEW, 36 runs), `taxiway_multi` (NEW, 36 runs), `taxiway_multi_drive` (NEW, 36 runs), `track_multi_drive` (NEW, 36 runs), `junction_multi` (NEW, 30 runs), `hedge_multi` (NEW, 24 runs), `track_multi` (NEW, 24 runs), `DC_IDBUZZ_Following_W_30kmh` (FEV, 17 runs), `DC_IDBUZZ_Following_W_50kmh` (FEV, 16 runs), `two_vehicles` (NEW, 10 runs), `two_vehicles_drive` (NEW, 10 runs), `DC_IDBUZZ_Following_F_30kmh` (FEV, 9 runs), `BMW_T5_Following_W_30kmh` (FEV, 8 runs), `BMW_T5_Following_W_50kmh` (FEV, 8 runs), `DC_IDBUZZ_Following_F_50kmh` (FEV, 7 runs). |
|
|
| ### S03 Hidden pass-by |
|
|
| Two vehicles side by side, the larger one between the ego and the smaller one, which is masked. |
|
|
|  |
|
|
| Families: `hedge_hidden_drive` (NEW, 22 runs), `taxiway_hidden` (NEW, 22 runs), `taxiway_hidden_drive` (NEW, 22 runs), `track_hidden_drive` (NEW, 22 runs), `junction_hidden` (NEW, 20 runs), `DC_IDBUZZ_Hiding_W_30kmh` (FEV, 10 runs), `hedge_hidden` (NEW, 10 runs), `track_hidden` (NEW, 10 runs), `BMW_T5_Hiding_W_30kmh` (FEV, 8 runs), `DC_IDBUZZ_Hiding_F_50kmh` (FEV, 8 runs). |
|
|
| ### S04 Opposite-direction crossing |
|
|
| Two vehicles from opposite sides cross in front of the static ego. |
|
|
|  |
|
|
| Families: `DC_IDBUZZ_Crossing_W_30kmh` (FEV, 14 runs), `DC_IDBUZZ_Crossing_W_50kmh` (FEV, 12 runs), `hedge_multi_drive` (NEW, 12 runs), `taxiway_multi` (NEW, 12 runs), `taxiway_multi_drive` (NEW, 12 runs), `track_multi_drive` (NEW, 12 runs), `junction_multi` (NEW, 10 runs), `two_vehicles` (NEW, 10 runs), `two_vehicles_drive` (NEW, 10 runs), `DC_IDBUZZ_Crossing_F_50kmh` (FEV, 8 runs), `DC_IDBUZZ_Crossing_T_50kmh` (FEV, 8 runs), `DC_IDBUZZ_Crossing_T_50kmh_ego26m` (FEV, 8 runs), `DC_IDBUZZ_Crossing_F_30kmh` (FEV, 7 runs), `DC_IDBUZZ_Crossing_T_30kmh` (FEV, 7 runs), `DC_IDBUZZ_Crossing_T_30kmh_ego26m` (FEV, 7 runs). |
|
|
| ### S05 Mixed traffic from both sides |
|
|
| Three or four vehicles from both sides; variants change the order of arrival. |
|
|
|  |
|
|
| Families: `hedge_multi` (NEW, 96 runs), `hedge_multi_drive` (NEW, 96 runs), `taxiway_multi` (NEW, 96 runs), `taxiway_multi_drive` (NEW, 96 runs), `track_multi` (NEW, 96 runs), `track_multi_drive` (NEW, 96 runs), `junction_multi` (NEW, 80 runs). |
|
|
| ### S06 Platoon at the T-junction |
|
|
| Two cars (plus a motorcycle, plus a van) in line at a fixed spacing, 10, 50 or 100 m. |
|
|
|  |
|
|
| Families: `2_cars_1_moto_1_van_T-J_static_50kmh_100m` (TJ, 3 runs), `2_cars_1_moto_T-J_static_50kmh_50m` (TJ, 3 runs), `2_cars_T-J_static_50kmh_100m` (TJ, 3 runs), `2_cars_T-J_static_50kmh_10m` (TJ, 3 runs), `2_cars_1_moto_1_van_T-J_static_30kmh_100m` (TJ, 2 runs), `2_cars_1_moto_1_van_T-J_static_50kmh_10m` (TJ, 2 runs), `2_cars_1_moto_1_van_T-J_static_50kmh_50m` (TJ, 2 runs), `2_cars_1_moto_T-J_static_30kmh_100m` (TJ, 2 runs), `2_cars_1_moto_T-J_static_30kmh_10m` (TJ, 2 runs), `2_cars_1_moto_T-J_static_30kmh_50m` (TJ, 2 runs), `2_cars_1_moto_T-J_static_50kmh_10m` (TJ, 2 runs), `2_cars_T-J_static_30kmh_100m` (TJ, 2 runs), `2_cars_T-J_static_30kmh_10m` (TJ, 2 runs), `2_cars_T-J_static_50kmh_50m` (TJ, 2 runs), `2_cars_1_moto_1_van_T-J_static_10kmh_100m` (TJ, 1 runs), `2_cars_1_moto_1_van_T-J_static_10kmh_10m` (TJ, 1 runs), `2_cars_1_moto_1_van_T-J_static_30kmh_10m` (TJ, 1 runs), `2_cars_1_moto_T-J_static_10kmh_100m` (TJ, 1 runs), `2_cars_1_moto_T-J_static_10kmh_10m` (TJ, 1 runs), `2_cars_1_moto_T-J_static_10kmh_50m` (TJ, 1 runs), `2_cars_T-J_static_30kmh_50m` (TJ, 1 runs). |
|
|
| ### S07 Stopped at the junction |
|
|
| The ego waits at the junction with a vehicle stopped behind it while another one crosses. |
|
|
|  |
|
|
| Families: `junction_static` (NEW, 12 runs). |
|
|
| ### S08 Ego overtaken |
|
|
| A vehicle overtakes the moving ego on the left, on the right, on both sides, or a motorcycle filters past. |
|
|
|  |
|
|
| Families: `overtaking` (NEW, 50 runs), `BMW_Take_Over_30kmh` (FEV, 27 runs), `T5_Take_Over_30kmh_2` (FEV, 23 runs), `DC_IDBUZZ_Take_over_30kmh` (FEV, 15 runs), `left_and_right_takeover` (NEW, 15 runs), `TC_Take_Over_30kmh_exit_bus` (FEV, 10 runs), `BMW_Take_Over_50kmh_crazy` (FEV, 6 runs), `T5_Take_Over_30kmh` (FEV, 1 runs). |
|
|
| ### S09 Ego overtakes |
|
|
| The moving ego overtakes a slower vehicle. |
|
|
|  |
|
|
| Families: `overtaking` (NEW, 10 runs). |
|
|
| ### S10 Lead or following vehicle |
|
|
| A vehicle drives ahead of, or behind, the moving ego at a constant gap. |
|
|
|  |
|
|
| Families: `following` (NEW, 22 runs), `T5_Take_Over_30kmh_2` (FEV, 11 runs), `DC_IDBUZZ_Take_over_30kmh` (FEV, 9 runs), `BMW_Take_Over_30kmh` (FEV, 5 runs), `BMW_Take_Over_50kmh_crazy` (FEV, 1 runs), `T5_Take_Over_30kmh` (FEV, 1 runs). |
|
|
| ### S11 Oncoming traffic |
|
|
| A vehicle comes towards the moving ego on the other lane. |
|
|
|  |
|
|
| Families: `oncoming` (NEW, 10 runs). |
|
|
| ### S12 Ego pulling out |
|
|
| The ego stops at the give-way line, waits for two or three vehicles to pass, then turns right into the near lane or left across it. |
|
|
|  |
|
|
| Families: `hedge_insert` (NEW, 40 runs), `junction_insert` (NEW, 40 runs), `taxiway_insert` (NEW, 40 runs), `track_insert` (NEW, 40 runs). |
|
|
| ### S13 Ego overtakes with oncoming traffic |
|
|
| The moving ego pulls out behind a lead vehicle, passes it and cuts back in before meeting oncoming traffic. |
|
|
|  |
|
|
| Families: `overtake_oncoming` (NEW, 236 runs). |
| <!-- /schematics --> |
|
|
| ## Alignment of sound, images and labels |
|
|
| A run lasts a whole number of seconds `n`. Second `k` (`0 <= k < n`) is made of: |
|
|
| | modality | second `k` | |
| |---|---| |
| | sound | samples `48000 k` to `48000 k + 47999` of `audio_8ch.flac` and of every stem | |
| | video | frames `20 k` to `20 k + 19` of `cameras/cam0.mp4`, `cam1.mp4` and `cam2.mp4` (times `k`, `k + 0.05`, ..., `k + 0.95` s) | |
| | 1-fps images | frame `20 k + 10` (time `k + 0.5` s) of each camera, in `frames_1fps.tar` | |
| | geometry | rows `20 k` to `20 k + 19` of `geometry.csv` and of `frames_index.csv` (`time_s` = frame / 20) | |
| | labels | the row(s) with `chunk_idx` = `start_s` = `k`; per-vehicle distances, speeds and azimuths are taken at `k + 0.5` s | |
|
|
| `audio_8ch.flac` has exactly `48000 n` samples. The videos, `geometry.csv` and `frames_index.csv` have `20 n + 1` frames or rows: the |
| last one, at time `n`, closes the run and belongs to no second. Nothing is published without its counterpart: there is no sound without |
| images, no image without sound and no second without labels. |
|
|
| The `FEV` and `TJ` runs replay real recordings: what is published is a part of the simulated scene, given in `scene.json` → `publication` |
| (`scene_start_s`, `scene_end_s`, `duration_s`). The times inside `scene.json` (trajectories, start times) are scene times: subtract |
| `scene_start_s` to compare them with the other files, which all start at 0. A `NEW` run is published whole, from scene time 0. |
|
|
| ## Preparing the data for a model (20 fps) |
|
|
| The unit of the dataset is the second: one second of sound (48 000 samples x 8 microphones), its 20 frames per camera and its label |
| row(s). The simplest correct way to cut a run is by frame number, never by duration: |
|
|
| 1. read the sound and take `n = len(audio) // 48000` seconds; |
| 2. decode each video and keep frames `0` to `20 n - 1`; frame `20 n` (the last one) closes the run and is dropped; |
| 3. second `k` = `audio[48000 k : 48000 (k + 1)]`, `frames[20 k : 20 k + 20]`, rows `20 k` to `20 k + 19` of `geometry.csv`, and the |
| label row(s) with `chunk_idx == k`. |
|
|
| ```python |
| import os |
| import av # pip install av |
| import numpy as np |
| import soundfile as sf |
| |
| def seconds(run_dir, cam="cam1"): |
| """Yields (k, the 20 frames of second k as an array (20, 1024, 1224, 3), the sound of second k (48000, 8)), one second at a time.""" |
| audio, fs = sf.read(os.path.join(run_dir, "audio_8ch.flac"), dtype="int16") |
| n = len(audio) // 48000 |
| frames = [] |
| with av.open(os.path.join(run_dir, "cameras", cam + ".mp4")) as video: |
| for i, frame in enumerate(video.decode(video=0)): |
| if i >= 20 * n: # frame 20 n closes the run: it belongs to no second |
| break |
| frames.append(frame.to_ndarray(format="rgb24")) |
| if len(frames) == 20: |
| k = i // 20 |
| yield k, np.stack(frames), audio[48000 * k: 48000 * (k + 1)] |
| frames = [] |
| ``` |
|
|
| Good to know: |
|
|
| - A 30 s run has 601 frames, and the video header gives 30.05 s. Do not stretch or resample the video to the length of the sound, and do |
| not `reshape` all the frames into blocks of 20 (601 is not a multiple of 20): keep `frames[:20 * n]`. |
| - Lower frame rates: 10 fps = frames `20 k, 20 k + 2, ..., 20 k + 18`; 5 fps = one frame out of four from `20 k`; 1 fps = frame |
| `20 k + 10`, already extracted in `frames_1fps.tar` (`tools/extract_frames.py --fps 10` writes the 10 fps frames). |
| - The three cameras are synchronous: frame `i` of `cam0.mp4`, `cam1.mp4` and `cam2.mp4` is the same instant, `i / 20` s. |
| - `tools/reformat_to_chunks.py` cuts the sound into one file per second with the same numbering. |
|
|
| ## Layout |
|
|
| ``` |
| SAVAV_official/ |
| ├── annotations/ |
| │ ├── annotations_NEW.csv annotations_NEW.xlsx all rows of a split (sheets long and legend in the .xlsx) |
| │ ├── annotations_FEV.csv annotations_FEV.xlsx |
| │ └── annotations_TJ.csv annotations_TJ.xlsx |
| ├── tools/ scripts described below |
| ├── NEW/<family>/<run>/ |
| │ ├── audio_8ch.flac |
| │ ├── stems/<vehicle>.flac, stems/background.flac, stems/README.txt |
| │ ├── cameras/cam0.mp4, cameras/cam1.mp4, cameras/cam2.mp4 |
| │ ├── frames_1fps.tar |
| │ ├── frames_index.csv |
| │ ├── geometry.csv |
| │ ├── scene.json |
| │ └── annotations.csv |
| ├── FEV/<family>/<run>/ same files, without stems/ |
| └── TJ/<family>/<run>/ same files as NEW |
| ``` |
|
|
| ## Files of a run |
|
|
| | file | content | |
| |---|---| |
| | `audio_8ch.flac` | the 8 microphones of the ego vehicle, 48 kHz, 16-bit (what the array hears) | |
| | `stems/<vehicle>.flac`, `stems/background.flac` | the same 8 channels for each vehicle alone and for the background (ambient noise and ego self-noise), 24-bit; `audio_8ch` = background + sum of the vehicle tracks. Present for every `NEW` and `TJ` run; the `FEV` runs have no stems | |
| | `cameras/cam0.mp4`, `cam1.mp4`, `cam2.mp4` | left, front and right cameras of the ego vehicle, 1224 x 1024, 20 fps, H.264, no sound | |
| | `frames_1fps.tar` | one JPEG per second and per camera (frame `20 k + 10`), named `frames_1fps/<run>_<cam>_<frame>.jpg` | |
| | `frames_index.csv` | one row per video frame: time, environment, ego position and heading, camera position, frame number and JPEG name of each camera, position, heading and speed of every vehicle | |
| | `geometry.csv` | ground truth at 20 Hz: positions (local East-North frame in metres, and WGS84), headings and speeds of the ego vehicle, of the microphone array and of every vehicle | |
| | `scene.json` | scenario definition: vehicle classes, paths, speeds, start times (and the `publication` interval for `FEV` and `TJ`) | |
| | `annotations.csv` | the rows of this run (same columns as the split files, without `chunk_folder`) | |
|
|
| ## Labels |
|
|
| `SAVAV_official/annotations/annotations_<split>.csv` (and the same table in `.xlsx`, with a `legend` sheet that describes every column) |
| holds one row per second, per run and per occupied side. |
|
|
| - `audio_path` is the run's `audio_8ch.flac`; the row covers `[start_s, start_s + 1)` seconds of that file (`start_s` = `chunk_idx`), |
| and frames `20 start_s` to `20 start_s + 19` of the videos. |
| - `scenario_key` = `<family>___<run>` identifies a run (some run names exist in several families). |
| - `chunk_folder` = `chunk_<A>_<B>`: name of that second in the chunked layout below; `B` = `chunk_idx`, `A` = absolute chunk number |
| (index of that second in the source recording for `TJ`, `A` = `B` for `NEW` and `FEV`). |
| - `left`, `front`, `right`, `back`: side of the group (azimuth clockwise from the ego heading: front |az| <= 45°, right 45-135°, |
| back |az| >= 135°, left -135 to -45°); `none`: no vehicle in that second; `both`: vehicles on more than one side. A second with |
| vehicles on two sides has two rows. |
| - `car`, `van`, `moto`, `objects_combo`, `count`: classes and number of vehicles of the group. |
| - `<vehicle>_distance_m`, `<vehicle>_speed_kmh`, `<vehicle>_side`, `<vehicle>_azimuth_deg`: per-vehicle values at the middle of the |
| second, the time of the 1-fps image. |
| - `ego_mode` (`static` / `driving`), `ego_speed_kmh`, `env` (`O` taxiway, `W` hedge, `F` hall, `T` thicket), `information` (readable summary). |
|
|
| ## Download, step by step |
|
|
| 1. **Accept the conditions.** Log in to Hugging Face, open this page and click *Agree and access the dataset* (access is granted at once). |
| 2. **Install the client** (Python 3.9 or later): `pip install -U huggingface_hub`. This provides the `hf` command. |
| 3. **Log in.** Create a token with the *Read* role at <https://huggingface.co/settings/tokens>, then run `hf auth login` and paste it |
| (or set the environment variable `HF_TOKEN`). |
| 4. **Download the annotations and the tools first** (about 82 MB) into a local folder, here `SAVAV`: |
|
|
| ```bash |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/annotations/*" |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/tools/*" |
| ``` |
|
|
| 5. **Download the runs you need**, one `--include` per command (and at most one `--exclude`); the files land in |
| `SAVAV/SAVAV_official/<split>/<family>/<run>/`: |
|
|
| ```bash |
| # one split with sound and images, without stems (TJ: 1.8 GB, NEW: 268.0 GB; FEV has no stems: 22.4 GB) |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/TJ/*" --exclude "*/stems/*" |
| # one split, everything (TJ: 3.4 GB) |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/TJ/*" |
| # one family |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/NEW/two_vehicles/*" |
| # the whole dataset without stems (292.2 GB), or with stems (384.7 GB) without the --exclude |
| hf download AnonymAccount/SAVAV --repo-type dataset --local-dir SAVAV --include "SAVAV_official/*" --exclude "*/stems/*" |
| ``` |
|
|
| Add `--dry-run` to see the list and the total size before downloading. Re-running the same command after an interruption |
| skips the files already complete. |
|
|
| The same in Python, with several patterns at once; for example the sound, geometry and labels of every run, without images and stems |
| (16.9 GB; TJ 0.2 GB, FEV 1.6 GB, NEW 15.0 GB): |
|
|
| ```python |
| from huggingface_hub import snapshot_download |
| |
| snapshot_download(repo_id="AnonymAccount/SAVAV", repo_type="dataset", local_dir="SAVAV", |
| allow_patterns=["SAVAV_official/*"], |
| ignore_patterns=["*/stems/*", "*/cameras/*", "*/frames_1fps.tar"]) |
| ``` |
|
|
| The annotation tables can also be loaded with `datasets` (after step 3): `load_dataset("AnonymAccount/SAVAV", "TJ", split="train")`, |
| and likewise `"NEW"` and `"FEV"`. |
|
|
| ## Reading one second of sound and its images |
|
|
| ```python |
| import os |
| import pandas as pd |
| import soundfile as sf |
| |
| root = "SAVAV" # the --local-dir of the download |
| rows = pd.read_csv(os.path.join(root, "SAVAV_official/annotations/annotations_TJ.csv"), low_memory=False) |
| row = rows.iloc[0] |
| k = int(row["start_s"]) |
| audio, fs = sf.read(os.path.join(root, row["audio_path"]), start=k * 48000, stop=(k + 1) * 48000, dtype="int16") # (48000, 8) |
| run_dir = os.path.dirname(os.path.join(root, row["audio_path"])) |
| frames = range(20 * k, 20 * k + 20) # frames of cameras/cam0.mp4, cam1.mp4, cam2.mp4 for this second |
| jpeg = "frames_1fps/%s_cam1_%05d.jpg" % (os.path.basename(run_dir), 20 * k + 10) # in <run_dir>/frames_1fps.tar |
| print(row["scenario_key"], row["information"], audio.shape, jpeg) |
| ``` |
|
|
| ## Reformatting to 1-second chunks, step by step |
|
|
| The original recordings are stored as one folder per second. `tools/reformat_to_chunks.py` rebuilds this layout from the download; |
| the chunks are bit-exact slices of `audio_8ch.flac`. |
|
|
| 1. Download the annotations, the tools and the runs to convert (steps 4 and 5 above). |
| 2. Install the dependencies: `pip install numpy soundfile pandas openpyxl`. |
| 3. Check the size of the output (the whole dataset gives 48.7 GB of WAV: NEW 42.7 GB, FEV 4.9 GB, TJ 1.0 GB): |
|
|
| ```bash |
| python SAVAV/SAVAV_official/tools/reformat_to_chunks.py SAVAV/SAVAV_official --out SAVAV_chunks --dry-run |
| ``` |
|
|
| 4. Convert (`--splits TJ` or `--families two_vehicles` to convert a part only, `--workers 4` to use several cores): |
|
|
| ```bash |
| python SAVAV/SAVAV_official/tools/reformat_to_chunks.py SAVAV/SAVAV_official --out SAVAV_chunks --workers 4 |
| ``` |
|
|
| 5. Result: |
|
|
| ``` |
| SAVAV_chunks/<split>/annotations_<split>.xlsx, annotations_<split>.csv |
| SAVAV_chunks/<split>/<family>/annotations_<family>.xlsx |
| SAVAV_chunks/<split>/<family>/<run>/audio_chunks/<chunk_folder>/chunk_full.wav 8 channels, 48 kHz, 16-bit, 48000 samples |
| SAVAV_chunks/<split>/<family>/<run>/geometry.csv, scene.json |
| ``` |
|
|
| In these annotation files `audio_path` points to the chunk file, relative to the folder that contains `SAVAV_chunks` |
| (`SAVAV_chunks/TJ/<family>/<run>/audio_chunks/chunk_000413_000000/chunk_full.wav`). Options: `--stems` also places the stems, |
| `--keep-flac` the full `audio_8ch.flac`, `--format flac` writes FLAC chunks. An interrupted conversion resumes where it stopped. |
|
|
| ## Tools |
|
|
| `SAVAV_official/tools/` (see its `README.md`): `reformat_to_chunks.py` (chunked layout of whole splits, above), |
| `split_audio_chunks.py` (the same for one run), `extract_frames.py` (every camera frame as JPEG or PNG, at 20 or 10 fps) and |
| `make_overview_video.py` (a side-by-side video of the three cameras with the sound and the labels, for viewing). |
|
|
| ## License |
|
|
| CC BY 4.0. The simulation environment includes two vehicle models under CC BY 4.0: “Police car” by SpatialNeglect and “Ambulance” by |
| RCC Design (Fab), modified. |
|
|
| ## Citation |
|
|
| If you use SAVAV, please cite it as follows (the reference will be completed after the review of the accompanying paper): |
|
|
| ```bibtex |
| @misc{savav2026, |
| title = {SAVAV: simulated audio-visual recordings of road vehicles around an ego vehicle}, |
| author = {Anonymous}, |
| year = {2026}, |
| howpublished = {\url{https://huggingface.co/datasets/AnonymAccount/SAVAV}} |
| } |
| ``` |
|
|
