The Dataset Viewer has been disabled on this dataset.

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.

Top views of 4 scenes per family: building height (colour) and the 24 candidate ground stations

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 lots
  • downtown: dense centre with tall buildings, lower towards the edges
  • canyon (ood): long parallel buildings with narrow streets
  • courtyard (ood): ring and U shaped buildings around courtyards
  • hilly (ood): blocks on 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 (ood split)
  • 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_time depends 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 one scene_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

Paper for TYessine/airwise-rf-coverage-maps