Datasets:
|
Download README.md from TYessine/airwise-rf-coverage-maps: direct link, hf CLI and curl.
- Browser
- Download file 18.1 kB
-
https://huggingface.co/datasets/TYessine/airwise-rf-coverage-maps/resolve/main/README.md
- Command line
-
hf download hf://datasets/TYessine/airwise-rf-coverage-maps/README.md
-
curl -L -o README.md https://huggingface.co/datasets/TYessine/airwise-rf-coverage-maps/resolve/main/README.md
18.1 kB
| # 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<n<100K | |
| viewer: false # the data is stored as NumPy .npz files, which the Hub viewer cannot display | |
| # 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: | |
| ```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` | <GPU, e.g. RTX 4070 Laptop> | 0.29 s | | |
| | `mahdi` | <GPU> | 0.29 s | | |
| | `sami` | <GPU> | 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`: <N> pass, <N> warn, <N> 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: | |
| ```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} | |
| } | |
| ``` | |