README.md

---
pretty_name: PolyTopoBench
license:
- odbl
- cc-by-4.0
task_categories:
- image-segmentation
- object-detection
tags:
- remote-sensing
- aerial-imagery
- geospatial
- polygon
- vectorization
- building-footprint
- land-cover
- topology
size_categories:
- 100K<n<1M
configs:
- config_name: inria_building
  default: true
  data_files:
  - split: train
    path: inria/building/train.parquet
  - split: validation
    path: inria/building/val.parquet
- config_name: deventer_road
  data_files:
  - split: train
    path: deventer/road/train.parquet
  - split: validation
    path: deventer/road/val.parquet
- config_name: deventer_vegetation
  data_files:
  - split: train
    path: deventer/vegetation/train.parquet
  - split: validation
    path: deventer/vegetation/val.parquet
- config_name: deventer_unvegetated
  data_files:
  - split: train
    path: deventer/unvegetated/train.parquet
  - split: validation
    path: deventer/unvegetated/val.parquet
---

# PolyTopoBench

**PolyTopoBench** is a benchmark for **complex vector polygon generation** from remote-sensing imagery. It evaluates whether a model can produce complete polygon topology, including **interior rings (holes)**, rather than only exterior boundaries.

- **Paper:** [*PolyTopoBench: A Benchmark for Complex Vector Polygon Generation from Remote Sensing Imagery*](https://arxiv.org/abs/2609.32856), NeurIPS 2026 (Evaluations and Datasets Track)
- **Code** (evaluator, baselines, data conversion): https://github.com/seai-lab/PolyTopoBench

The benchmark has four single-class tasks on 512 × 512 aerial image patches, with nearly 300K polygon instances, more than 10K complex polygons and over 42K interior rings.

| Task | Train images | Val images | Instances | Complex instances | Interior rings |
|---|---:|---:|---:|---:|---:|
| `inria/building` | 11,860 | 3,500 | 254,133 | 5,512 | 19,854 |
| `deventer/road` | 1,716 | 432 | 4,533 | 1,066 | 9,992 |
| `deventer/vegetation` | 1,716 | 432 | 23,517 | 859 | 1,477 |
| `deventer/unvegetated` | 1,716 | 432 | 16,552 | 2,942 | 10,749 |

A *complex instance* is a polygon with at least one interior ring.

## Repository layout

```
PolyTopoBench/
├── tasks.json                       # task registry: file paths, SHA-256 checksums, statistics
├── inria/
│   ├── images/{train,val}/<city>/*.tif      # 512×512 RGB patches, grouped by city
│   ├── splits.csv                           # patch → split, source tile, patch origin
│   └── building/{train,val}.{json,parquet}  # annotations (COCO JSON and GeoParquet)
├── deventer/
│   ├── images/{train,val}/*.png             # 512×512 RGB patches, shared by all three tasks
│   ├── splits.csv                           # patch → split, upstream image id
│   └── {road,vegetation,unvegetated}/{train,val}.{json,parquet}
└── raw/                                     # source data before patch extraction (optional)
    ├── inria/
    │   ├── train/images/*.tif               # 180 Inria tiles, 5000×5000
    │   ├── train/gt/*.tif                   # official Inria binary masks (not the PolyTopoBench ground truth)
    │   └── raw/train/gt_polygonized/*.geojson   # full-tile vector ground truth (OSM-aligned, manually corrected)
    └── deventer/{train,val}/
        ├── images/*.png                     # same images as deventer/images
        ├── masks/*.png                      # multi-class masks (values 0–4)
        └── annotations/{building,road,vegetation,unvegetated,water}.json   # upstream per-class COCO
```

### Which files do I need?

| Use case | Download | Size |
|---|---|---:|
| Evaluate your method on the validation sets | `inria/**/val*`, `deventer/**/val*`, `tasks.json` | ~3 GB |
| Train and evaluate your method | `inria/`, `deventer/`, `tasks.json` | ~13 GB |
| Re-tile Inria, run Frame Field Learning, or work with Deventer building/water | add `raw/` | +14 GB |

```python
from huggingface_hub import snapshot_download

# Benchmark data only (recommended)
snapshot_download(
    repo_id="PingL/PolyTopoBench",
    repo_type="dataset",
    local_dir="PolyTopoBench",
    allow_patterns=["tasks.json", "inria/*", "deventer/*"],
)
```

Add `"raw/*"` to `allow_patterns`, or drop `allow_patterns`, to download everything.

## Annotation format

Every task split is provided in two equivalent formats. They contain the same polygons, point for point.

### COCO JSON (`<task>/<split>.json`)

The files follow the COCO layout (`images`, `annotations`, `categories`). Each task has a single category with `category_id = 100`. Image `file_name` is relative to `<dataset>/images/<split>/`, for example `austin/austin1-x0000-y0000.tif`.

> **Important: holes are encoded differently from standard COCO.** `segmentation` is a list of rings `[exterior, hole_1, hole_2, ...]`. Ring 0 is the exterior boundary and every further ring is a **hole** of that exterior. Standard COCO tools such as `pycocotools` treat multiple rings as a union of parts, so they will **fill the holes**. Build geometries yourself as shown below.

Each ring is a flat list `[x1, y1, x2, y2, ...]` in pixel coordinates of the 512 × 512 patch (origin at the top-left, y pointing down), closed so that the first point is repeated at the end. Each annotation is one polygon.

```python
import json
from pathlib import Path
from PIL import Image
from shapely.geometry import Polygon

root = Path("PolyTopoBench")
coco = json.loads((root / "inria/building/val.json").read_text())

def to_polygon(segmentation):
    rings = [list(zip(r[0::2], r[1::2])) for r in segmentation]
    return Polygon(rings[0], rings[1:])  # exterior, holes

image_info = coco["images"][0]
image = Image.open(root / "inria/images/val" / image_info["file_name"])
polygons = [to_polygon(a["segmentation"]) for a in coco["annotations"] if a["image_id"] == image_info["id"]]
```

### GeoParquet (`<task>/<split>.parquet`)

One row per polygon, with the columns `annotation_id`, `image_id`, `file_name`, `category`, `area`, `hole_count`, and `geometry`. `geometry` is a WKB `Polygon` whose first ring is the exterior and whose remaining rings are holes. Coordinates are in pixels and no CRS is set. The files open directly in GeoPandas:

```python
import geopandas as gpd

gdf = gpd.read_parquet("PolyTopoBench/deventer/road/val.parquet")
gdf[gdf.hole_count > 0].head()
```

### Splits and task registry

- `inria/splits.csv` lists every patch with `file_name, image_id, split, city, source_tile, x0, y0`. `source_tile` and the pixel offset `(x0, y0)` locate the patch inside its 5000 × 5000 Inria tile.
- `deventer/splits.csv` lists every patch with `file_name, image_id, split, raw_image_id`. `raw_image_id` is the image id in the upstream Deventer-512 annotations.
- `tasks.json` lists, for each task and split, the image directory, the annotation files with their SHA-256 checksums, and the image, instance and hole counts.

`image_id` values are contiguous from 1 within each split. The three Deventer tasks share the same images and the same `image_id` values.

## Evaluation and baselines

The unified evaluator, baseline wrappers and the scripts that convert this release into each baseline's native input format are in the [code repository](https://github.com/seai-lab/PolyTopoBench). The evaluator scores exterior geometry, interior-ring recovery and full ring topology; see the paper for the metric definitions.

## Construction details

**Inria building.** Vector ground truth was built by aligning OpenStreetMap building footprints to the 180 training tiles of the [Inria Aerial Image Labeling dataset](https://project.inria.fr/aerialimagelabeling/) (Austin, Chicago, Kitsap County, Western Tyrol, Vienna), manually correcting residual mismatches, and restoring interior rings from the official raster masks. The full-tile result is in `raw/inria/raw/train/gt_polygonized/`.
- Tiles are split by city, 80/20: in each city, 29 tiles go to train and 7 to validation.
- Each tile is cut into a 10 × 10 grid of 512 × 512 patches. The last row and column start at pixel 4488, so they overlap their neighbours.
- Polygons are clipped to each patch, and clipped parts whose bounding box is 5 px or less on a side are removed.
- Training patches without buildings are dropped. All validation patches are kept, including 512 without buildings.

**Deventer land cover.** The Deventer tasks use the road, vegetation and unvegetated classes of [Deventer-512](https://huggingface.co/datasets/HeinzJiao/Deventer-512). The upstream validation and test splits are merged into the PolyTopoBench validation split. Image ids are renumbered contiguously; `deventer/splits.csv` maps them back to the upstream ids. 292 Deventer polygons (0.65%), mostly with self-touching rings, are not valid under the OGC simple-feature rules. They are kept as released upstream so that the benchmark ground truth stays unchanged.

## License

This dataset combines sources with different terms; see [LICENSE.md](LICENSE.md) for the file-by-file breakdown.

- **Inria vector annotations** are derived from OpenStreetMap and are released under the [Open Database License (ODbL) 1.0](https://opendatacommons.org/licenses/odbl/1-0/). © OpenStreetMap contributors.
- **Inria imagery and official masks** come from the [Inria Aerial Image Labeling dataset](https://project.inria.fr/aerialimagelabeling/), which is built from public-domain imagery and building footprints. Please cite Maggiori et al. (2017).
- **Deventer-512 imagery and annotations** are released under [CC BY 4.0](https://creativecommons.org/licenses/by/4.0/), following the [upstream release](https://huggingface.co/datasets/HeinzJiao/Deventer-512).

## Citation

```bibtex
@misc{liu2026polytopobenchbenchmarkcomplexvector,
      title={PolyTopoBench: A Benchmark for Complex Vector Polygon Generation from Remote Sensing Imagery},
      author={Zeping Liu and Ni Lao and Weiwei Sun and Gil Wolff and Yiqun Xie and Liang Zhao and Junfeng Jiao and Gengchen Mai},
      year={2026},
      eprint={2609.32856},
      archivePrefix={arXiv},
      primaryClass={cs.CV},
      url={https://arxiv.org/abs/2609.32856},
}
```

Please also cite the source datasets:

```bibtex
@inproceedings{maggiori2017can,
  title     = {Can Semantic Labeling Methods Generalize to Any City? The Inria Aerial Image Labeling Benchmark},
  author    = {Maggiori, Emmanuel and Tarabalka, Yuliya and Charpiat, Guillaume and Alliez, Pierre},
  booktitle = {IEEE International Geoscience and Remote Sensing Symposium (IGARSS)},
  pages     = {3226--3229},
  year      = {2017}
}

@inproceedings{jiao2026acpv,
  title     = {ACPV-Net: All-Class Polygonal Vectorization for Seamless Vector Map Generation from Aerial Imagery},
  author    = {Jiao, Weiqin and Cheng, Hao and Vosselman, George and Persello, Claudio},
  booktitle = {Proceedings of the IEEE/CVF Conference on Computer Vision and Pattern Recognition (CVPR)},
  pages     = {13244--13253},
  year      = {2026}
}```

## Contact

Please open an issue in the [code repository](https://github.com/seai-lab/PolyTopoBench/issues). Corresponding author: Gengchen Mai (gengchen.mai@austin.utexas.edu).