Datasets:
AIRWISE synthetic urban RF coverage maps
Ray traced path gain maps from a ground station to a drone flying at a fixed altitude above synthetic 128 m Γ 128 m city blocks, at 2.4 GHz. Every map comes with the height map of its scene (ground + buildings), the station position and the drone altitude, so it can be used to train and test models that predict a radio coverage map from the city geometry (e.g. image-to-image neural networks), including on unseen city layouts (out of distribution split).
The dataset was made for Neural Prediction of RF Coverage Maps for Drone Missions, a project of AIRWISE, a set of student projects at Politecnico di Milano on simulating drone missions in urban and complex environments. Planning a drone mission that keeps a radio link to the ground station needs a coverage map at every flight altitude; ray tracing gives accurate maps but is slow and has to be rerun whenever the station or the scene changes. The project asks whether a neural network trained on ray traced maps can replace it, and how much accuracy is lost for the speedup.
Four scenes per family (rows). Colour: building height; dots: candidate ground stations (blue open, cyan street, red courtyard).
At a glance
| Scenes | 1,620 procedurally generated city blocks, 128 m Γ 128 m, 6 layout families (3 seen in training, 3 unseen) |
| Maps | 19,440 path gain maps of 128 Γ 128 cells (1 m), 3 ground stations per scene Γ 4 drone altitudes |
| Input | surface height map (m) + station position (m) + drone altitude (m) |
| Target | path gain in dB, floored at -150 dB |
| Frequency | 2.4 GHz, isotropic vertically polarised antennas |
| Ray tracer | Sionna RT 2.2.0 (RadioMapSolver): line of sight, specular and diffuse reflections, diffraction |
| Format | NumPy .npz, one file per split, ~990 MB in total (compressed); scenes ~620 MB |
| Code | https://github.com/YessineT/Neural-Prediction-of-RF-Coverage-Maps-for-Drone-Missions (dataset-generation/) |
| Authors | Yessine Turki, Mehdi Ben Mefteh, Sami El Azaar (Multidisciplinary Project, Politecnico di Milano) |
| Supervisors | Luca Barletta (Politecnico di Milano), Stefano Rini, Alessia Radicula, Arthur Garbuz |
| Contact | open an issue on the GitHub repository |
| Version | 2.0, 2026-11-14: three times larger, merged from the scenes and maps of the three authors (see "Sources") |
Repository layout
README.md this card
train.npz val.npz test.npz ood.npz the maps (one file per split)
settings.json the exact ray tracing settings used for every map
merge_info.json scenes and maps per split and per source
example_maps.png the maps of one scene
scenes_city/ the 3D scenes the maps were traced on (to reproduce or extend the dataset)
index.json every scene with its family, split and source
config.json all generator parameters, the seed and the town numbers of every source
check_results.json result of every quality check, per scene
overview.png top views of a few scenes per family
<family>_<NNNN>/ one folder per scene, see "Scene files" below
Data fields (<split>.npz)
Every split file holds the arrays below. All strings are stored as fixed width unicode, so the files load with
plain np.load (no allow_pickle). S = number of scenes in the split, N = number of maps (N = 12 S).
| array | shape | type | meaning |
|---|---|---|---|
heights |
(S, 128, 128) | float32 | surface height of every scene of the split (terrain + buildings), m |
scene_names |
(S,) | str | scene name, e.g. blocks_0007 (folder in scenes_city/) |
scene_hash |
(S,) | str | SHA-1 of the scene's height map at tracing time |
scene_source |
(S,) | str | who generated and traced the scene: yessine, mahdi or sami (see "Sources") |
scene_idx |
(N,) | int32 | index into heights / scene_names of every map |
station_pos |
(N, 3) | float32 | ground station (transmitter) position x, y, z, m |
altitude |
(N,) | float32 | height z of the map plane (drone altitude), m: 15, 30, 45 or 60 |
target_db |
(N, 128, 128) | float32 | path gain in dB, -150 dB = no ray arrived (weaker values are also clipped to -150) |
rt_time |
(N,) | float32 | ray tracing time of that map, s (RTX 4070 Laptop GPU, after an untimed warm-up) |
The height maps are stored once per scene; use scene_idx to pair each map with its scene. The maps of one scene
are stored station by station, each with the 4 altitudes in increasing order.
Grid. The scene is centred on (0, 0). Cell [i, j] (row i, column j) has its centre at
x = j β 63.5 m, y = i β 63.5 m, i.e. rows run along y and columns along x, and the maps line up exactly with the
height maps (checked). All heights, altitudes and station z values are absolute z coordinates, not heights above
the ground. The terrain is flat (z = 0) except in the hilly family (Β±2 to 5 m), where a station can have a
negative z.
Path gain. target_db is the path gain between two isotropic (0 dBi) antennas, so for a real link
received power (dBm) = transmit power (dBm) + antenna gains (dBi) + target_db.
Validity mask. A cell is valid only where a drone can be, i.e. where the map plane is above the surface:
valid = heights[scene_idx[k]] < altitude[k] - 0.5
Cells inside buildings taller than the altitude are not valid and should be left out of the loss and the evaluation (they may contain tiny numerical values, see "Quality checks").
Splits
| split | families | scenes | maps | file size |
|---|---|---|---|---|
| train | blocks, grid, downtown | 1,080 (360 per family) | 12,960 | 660 MB |
| val | blocks, grid, downtown | 135 (45 per family) | 1,620 | 83 MB |
| test | blocks, grid, downtown | 135 (45 per family) | 1,620 | 82 MB |
| ood | canyon, courtyard, hilly | 270 (90 per family) | 3,240 | 165 MB |
A scene belongs to exactly one split, so no geometry is shared between splits. Train, val and test come from the
same distribution (two sample Kolmogorov-Smirnov test on built fraction, tallest building and number of
buildings). The ood families are never seen in training and measure generalisation to new kinds of cities.
Use val for model selection and report test and ood separately.
Layout families
blocks: scattered buildings of random size, orientation and height (boxes, L shapes, podium + tower)grid: rotated Manhattan style street grid, blocks cut into lotsdowntown: dense centre with tall buildings, lower towards the edgescanyon(ood): long parallel buildings with narrow streetscourtyard(ood): ring and U shaped buildings around courtyardshilly(ood):blockson hilly terrain
Buildings are 6 to 55 m tall and at least 3 m apart; no roof is closer than 1 m to a drone altitude, so the validity mask is unambiguous.
Sources
The scenes were generated and traced by the three authors in equal shares, with the same generator, the same generator parameters, the same seed recipe and identical ray tracing settings (verified when merging), each on a separate range of scene numbers, and then merged into one dataset:
| source | scene numbers (blocks, grid, downtown) | scene numbers (canyon, courtyard, hilly) | scenes | maps |
|---|---|---|---|---|
yessine |
0 β 149 | 0 β 29 | 540 | 6,480 |
mahdi |
150 β 299 | 30 β 59 | 540 | 6,480 |
sami |
300 β 449 | 60 β 89 | 540 | 6,480 |
Every source contributes the same number of scenes to every split (e.g. 360 train scenes each). No scene name and
no scene content (height map and stations) appears twice across sources. scene_source (in the .npz files) and
source (in scenes_city/index.json) tell which source a scene comes from. The sources were traced on different
machines, which matters only for rt_time (see "Timing").
Statistics
Computed on the released files, over valid cells only.
| split | valid cells | valid cells without signal (-150 dB) | path gain where there is signal: 5th pct / median / max | rt_time median |
|---|---|---|---|---|
| train | 95.1 % | 2.0 % | -118.3 / -81.6 / -53.9 dB | 0.31 s |
| val | 95.1 % | 1.8 % | -117.3 / -81.3 / -54.0 dB | 0.31 s |
| test | 94.9 % | 2.0 % | -118.9 / -82.2 / -54.0 dB | 0.31 s |
| ood | 94.4 % | 3.8 % | -121.2 / -81.0 / -54.0 dB | 0.29 s |
The highest gain (about -54 dB) is the free space gain over the shortest station to drone distance (5 m). The no-signal cells sit at -150 dB, about 70 dB below the median, so with a plain MSE on dB values these few cells weigh a lot in the loss; consider treating them separately (e.g. clip the target to a higher floor, or add a "signal / no signal" output).
How the maps were made
Scenes. generate_city_scenes.py builds each scene from a fixed seed (2026): it places the buildings of the
family's layout, writes closed meshes for Sionna, and computes the height map on the same 1 m grid as the radio
maps.
Ground stations. Each scene has 24 candidate stations, 1 to 10 m above the ground, at least 2 m from every wall, 5 m from the border and 5 m from each other, and at least 5 m below the lowest drone altitude. Three of them are chosen per scene at random (fixed seed); a station whose maps failed a quality check is replaced by another one.
Ray tracing (settings.json has the exact values):
| setting | value |
|---|---|
| frequency | 2.4 GHz |
| antennas | 1 isotropic, vertically polarised antenna at the station and at every map cell |
| rays per map | 1e8 |
maximum interactions per path (max_depth) |
8 |
| line of sight, specular reflection | on |
| diffraction | on |
| diffuse reflection | on, scattering coefficient 0.3, Lambertian pattern |
| refraction (through walls) | off: the buildings are closed, hollow volumes without inner walls, so energy crossing a whole building would be far too strong |
| materials | ITU-R P.2040 "concrete" (buildings) and "medium dry ground" (ground), 0.2 m thick |
These settings were chosen in a convergence study on a sample of scenes: with 1e8 rays no line of sight cell is
missed, and shadowed cells differ from a 2e8 ray reference by about 0.6 dB (median). Raising max_depth from 8 to
10 (tested with specular reflections only) leaves the gain unchanged where there is signal and switches 1.2 % of the
cells between signal and no signal. Diffraction and diffuse reflections each change shadowed cells by up to ~18 dB
(90th percentile) and are therefore included.
Timing. rt_time is the wall clock time of one RadioMapSolver call, including the transfer of the map to
the CPU, so it can serve as the baseline for a speed comparison with a learned model. The sources were traced on
different machines, so compare timings within one source (scene_source):
| source | GPU | median rt_time |
|---|---|---|
yessine |
<GPU, e.g. RTX 4070 Laptop> | 0.29 s |
mahdi |
0.29 s | |
sami |
0.35 s |
A few maps take longer, up to 1.6 s.
Quality checks
Every scene of the merged dataset was checked with check_city_scenes.py --full (results per scene in
scenes_city/check_results.json: pass, warn, fail; almost all warnings are the tiny numerical leaks
described below), among others:
- the meshes are closed, outward facing and exactly the buildings in
meta.json; the ray traced mesh equals the height map (vertical rays through every cell, horizontal rays along every row and column) - the validity mask computed from the mesh equals the one computed from the height map
- the gain right above the station matches free space, never exceeds free space by more than 10 dB, and shadowed cells receive clearly less than line of sight cells (exact line of sight from the mesh)
- the power inside buildings is at most 1e-4 of the map's power. Some maps contain a few very weak values inside buildings (rays slipping numerically through mesh edges, typically 1e-8 of the map's power); those cells are outside the validity mask
- the generator is reproducible: regenerating with the same seed gives identical files
Scenes that failed a check were not traced.
Scene files (scenes_city/<scene>/)
| file | content |
|---|---|
<scene>.xml |
Sionna / Mitsuba scene (load with sionna.rt.load_scene) |
meshes/ground.ply, meshes/buildings.ply |
binary PLY meshes, one closed mesh per building |
height_map.npz |
x, y (cell centres), terrain, surface and occupancy (share of the cell covered by buildings), 128 Γ 128 |
sources.npz |
the 24 candidate stations: positions, height_agl, ground_z, wall_distance, station_class (0 open, 1 street, 2 courtyard) |
meta.json |
family, statistics and the exact geometry of every building |
Usage
One map:
import numpy as np
from huggingface_hub import hf_hub_download
f = hf_hub_download("TYessine/airwise-rf-coverage-maps", "train.npz", repo_type="dataset")
d = np.load(f)
k = 0 # one map
height = d["heights"][d["scene_idx"][k]] # input, 128 x 128, m
target = d["target_db"][k] # output, 128 x 128, dB
valid = height < d["altitude"][k] - 0.5 # cells to use in the loss
A PyTorch dataset (the whole train split takes about 0.9 GB of memory):
import numpy as np
import torch
class CoverageMaps(torch.utils.data.Dataset):
def __init__(self, path):
with np.load(path) as d:
self.heights = torch.from_numpy(d["heights"])
self.idx = torch.from_numpy(d["scene_idx"]).long()
self.station = torch.from_numpy(d["station_pos"])
self.alt = torch.from_numpy(d["altitude"])
self.target = torch.from_numpy(d["target_db"])
def __len__(self):
return len(self.target)
def __getitem__(self, k):
h = self.heights[self.idx[k]]
valid = h < self.alt[k] - 0.5
return dict(height=h, station=self.station[k], altitude=self.alt[k],
target=self.target[k], valid=valid)
How the station and the altitude are given to the model (extra input channels, distance map, conditioning vector, ...) is left to the user.
Suggested metrics. RMSE in dB over the valid cells of every map, reported for test and ood separately
(and, if useful, per family and per altitude). Since a mission planner mostly needs to know where the link holds,
also report the error near the boundary between covered and uncovered cells (for a chosen sensitivity threshold),
and the prediction time per map next to rt_time.
To reproduce or extend the dataset (other stations, altitudes or settings), download scenes_city/ and run
make_dataset.py from the code repository.
Intended uses
- Training and benchmarking fast surrogate models of ray tracing (radio map prediction from the city geometry)
- Studying generalisation to unseen city layouts (
oodsplit) - Planning drone links or ground station positions in research settings
Out of scope. The maps are not a substitute for measurements or a site survey of a real city, and should not be used as the only basis for safety critical drone operations.
Limitations
- The cities are synthetic: box shaped buildings of a single material, no windows, vegetation, vehicles or street furniture.
- The maps are simulated, not measured. Diffuse scattering uses a single scattering coefficient (0.3, a typical value for building facades) that was not fitted to measurements.
- The maps give the average path gain of the ray traced paths; fast fading is not modelled.
- One frequency (2.4 GHz), one antenna type (isotropic, vertical polarisation), four fixed altitudes and a 128 m Γ 128 m area; models trained on it will not transfer directly to other settings.
rt_timedepends on the GPU and the Sionna version, and the three sources were traced on different machines; compare it only with timings on the same hardware, within onescene_source.
License
CC BY 4.0. The scenes and maps were generated with Sionna RT (Apache 2.0); the ITU material parameters come from ITU-R P.2040.
Citation
@misc{turki2026airwise,
title = {AIRWISE synthetic urban RF coverage maps},
author = {Turki, Yessine and Ben Mefteh, Mehdi and El Azaar, Sami},
year = {2026},
howpublished = {\url{https://huggingface.co/datasets/TYessine/airwise-rf-coverage-maps}}
}
Please also cite Sionna RT, which was used to compute the maps:
@article{sionna-rt,
title = {Sionna RT: Differentiable Ray Tracing for Radio Propagation Modeling},
author = {Hoydis, Jakob and Ait Aoudia, Fay{\c{c}}al and Cammerer, Sebastian and Nimier-David, Merlin and
Binder, Nikolaus and Marcus, Guillermo and Keller, Alexander},
journal = {arXiv preprint arXiv:2303.11103},
year = {2023}
}
- Downloads last month
- 283
