README.md

metadata

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

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

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.

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:

   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>/:

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

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

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

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

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

@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}}
}