--- # Dataset card for the Hugging Face Hub (uploaded as README.md). Fill in every <...> before uploading. license: cc-by-4.0 pretty_name: AIRWISE synthetic urban RF coverage maps (2.4 GHz, ground-to-drone) task_categories: - image-to-image annotations_creators: - machine-generated source_datasets: - original tags: - radio-propagation - radio-map - coverage-map - path-gain - pathloss - ray-tracing - sionna - uav - drone - wireless - synthetic - out-of-distribution size_categories: - 10K_/ one folder per scene, see "Scene files" below ``` ## Data fields (`.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: ```python 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` | | 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//`) | file | content | |---|---| | `.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: ```python 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): ```python 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](https://creativecommons.org/licenses/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 ```bibtex @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: ```bibtex @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} } ```