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, 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

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.

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:

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. 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 (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. 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 for the file-by-file breakdown.

• Inria vector annotations are derived from OpenStreetMap and are released under the Open Database License (ODbL) 1.0. © OpenStreetMap contributors.
• Inria imagery and official masks come from the Inria Aerial Image Labeling dataset, 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, following the upstream release.

Citation

@inproceedings{liu2026polytopobench,
  title     = {PolyTopoBench: A Benchmark for Complex Vector Polygon Generation from Remote Sensing Imagery},
  author    = {Liu, Zeping and Lao, Ni and Sun, Weiwei and Wolff, Gil and Xie, Yiqun and Zhao, Liang and Jiao, Junfeng and Mai, Gengchen},
  booktitle = {Advances in Neural Information Processing Systems (NeurIPS), Evaluations and Datasets Track},
  year      = {2026}
}

Please also cite the source datasets:

@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).