README.md

metadata

pretty_name: City3D-MultiGen
license: other
license_name: mixed-code-and-third-party-data
license_link: LICENSE
language:
  - en
size_categories:
  - 100K<n<1M
task_categories:
  - image-to-3d
tags:
  - 3d-point-cloud
  - point-cloud-generation
  - city-scale
  - remote-sensing
  - satellite-imagery
  - digital-surface-model
  - eccv-2026

City3D-MultiGen

A benchmark of ~163K densely annotated city tiles from Melbourne (Australia) and London (UK), each with aligned point-cloud geometry, satellite imagery, semantic segmentation maps, and a Digital Surface Model (DSM).

City3D-MultiGen is the benchmark introduced in our ECCV 2026 paper "GridFlow: Structured Latent Flow for Seamless City-Scale 3D Point Cloud Generation."

---

⚠️ Important: this repository does not redistribute third-party data

To comply with the Google Maps Platform Terms of Service and the licenses of the source 3D datasets, this repository does not contain:

• ❌ Satellite images (*_sat.png) — retrieved from the Google Maps Static API
• ❌ Styled map renders (*_map.png) — Google Maps content
• ❌ Semantic masks (*_Building.png, *_RoadSurface.png, …) — derived from the Google map renders, and therefore also Google-derived content
• ❌ Source point clouds (City of Melbourne LiDAR, HoliCity meshes)

Instead, this repository provides everything you need to reproduce the full dataset yourself:

• ✅ The complete processing pipeline scripts
• ✅ Tile coordinate metadata (the geographic grid that defines every tile)
• ✅ Train / validation / test split lists
• ✅ Step-by-step instructions below

You bring your own Google Maps Platform API key and download the source 3D data from its official providers; the scripts then rebuild the aligned multi-modal tiles locally.

---

What gets reconstructed (per-tile layout)

After running the pipeline, each tile grid_<id>/ contains:

File	Modality	Produced by
grid_<id>.las	Point cloud (geometry + RGB)	tiling the source point cloud
grid_<id>.json	Tile metadata (geo-extent, grid index)	tiling
grid_<id>_sat.png	Satellite image	Google Maps Static API
grid_<id>_map.png	Styled semantic render	Google Maps Static API
grid_<id>_<Class>.png	Per-class binary masks	parsing _map.png
grid_<id>_dsm.tif / _dsm.png	Digital Surface Model	rasterized from the point cloud
grid_<id>_bev.png	Bird's-eye-view render	rendered from the point cloud

Semantic classes (6): Building, RoadSurface, Railway, VegetationLand, UrbanLand, WaterSurface.

---

Prerequisites

pip install -r requirements.txt

System dependency — PDAL. The tiling scripts call PDAL (pdal translate and PDAL pipelines) to crop tiles and write LAS spatial-reference headers. PDAL is not a pip package; install it via conda or your system package manager:

conda install -c conda-forge pdal
# or (Debian/Ubuntu):  sudo apt-get install pdal

You will also need a Google Maps Platform account with the Maps Static API enabled:

• GOOGLE_MAPS_API_KEY — your API key
• GOOGLE_MAPS_URL_SIGNING_SECRET — your URL-signing secret
• GOOGLE_MAPS_STYLE_MAP_ID — the ID of your own Google Cloud map style used to render the semantic maps (see note below)

Set them as environment variables (the scripts read them from the environment; never commit keys to this repo):

export GOOGLE_MAPS_API_KEY="your-key"
export GOOGLE_MAPS_URL_SIGNING_SECRET="your-signing-secret"
export GOOGLE_MAPS_STYLE_MAP_ID="your-map-style-id"

Recreating the semantic map style. The per-class semantic masks are parsed from a custom-styled Google map in which each land-cover class is rendered in a fixed colour. We provide the exact style definition at docs/semantic_map_style.json. To reproduce it, open the Google Cloud console, go to Map Styles → Create style → JSON tab → Upload JSON File, upload this file, and save. The style is built on the light base map, which supplies the default water / vegetation / land colours, while building, railway and road surfaces are recoloured explicitly. Set the resulting Map ID as GOOGLE_MAPS_STYLE_MAP_ID. The class→colour mapping consumed by the parser is in CLASS_COLORS_HEX at the top of Obtain_corresponding_map_signed.py.

By using these scripts you are making live calls to the Google Maps Platform under your own account, and you are responsible for complying with the Google Maps Platform Terms of Service. See docs/GOOGLE_MAPS_NOTICE.md.

---

Reproducing the dataset

Step 1 — Download the source 3D data (link only, not hosted here)

City	Source	Link
Melbourne	City of Melbourne 3D Point Cloud 2018 (LAS; MGA Zone 55 / AHD)	https://data.melbourne.vic.gov.au/explore/dataset/city-of-melbourne-3d-point-cloud-2018/
London	HoliCity (FBX CAD models)	https://holicity.io/ · https://github.com/zhou13/holicity

⚠️ HoliCity is for non-commercial (academic/research) use only. You must accept the HoliCity Terms of Use before downloading. The underlying CAD models are owned by AccuCities Inc. and the panoramas by Google; commercial use requires their explicit permission. The London portion of City3D-MultiGen inherits these restrictions.

Place the downloaded files where the tiling scripts expect them (see scripts/README.md).

Step 2 — Tile the point clouds

HoliCity only — first sample a point cloud from the FBX meshes. The London source is distributed as FBX CAD meshes, not point clouds. Sample a dense point cloud from each mesh and export it to LAS using CloudCompare (Edit ▸ Mesh ▸ Sample Points). Then attach the geographic spatial reference to the tiles with holicity/convert_coord.py and holicity/add_coord_head.py before tiling. (Melbourne is already distributed as LAS, so it skips this step.)

Then partition the point clouds into 150 m × 150 m tiles:

# Melbourne
python scripts/melbourne/export_las_blocks_noKML.py   # see script header for arguments

# London / HoliCity
python scripts/holicity/export_las_blocks_noKML.py

This also produces the per-tile DSM and BEV render.

Step 3 — Fetch satellite + semantic maps (your own Google key)

python scripts/melbourne/Obtain_corresponding_map_signed.py   # reads keys from env vars

This retrieves the satellite image and the styled map for each tile and parses the per-class semantic masks.

Step 4 — Generate the DSM (and BEV render)

The DSM is rasterized from the point-cloud elevation (no Google data involved); it is produced by the export/tiling scripts (see the DSM variant) or the dedicated step in build_dataset.py.

Step 5 — Assemble the final dataset

python scripts/build_dataset.py   # orchestrates steps 2–4 into the per-tile layout above

---

Splits

Train / validation / test tile IDs are listed in metadata/splits/. Splits are spatially separated (≥150 m between regions) to prevent geographic leakage.

---

Licenses & attribution

• Pipeline code & metadata in this repo: MIT — see LICENSE.
• City of Melbourne 3D Point Cloud 2018: distributed via the City of Melbourne Open Data Portal. Confirm the exact license on the portal (City of Melbourne open data is generally Creative Commons Attribution 4.0) and provide the required attribution to the City of Melbourne.
• HoliCity: non-commercial / academic use only, subject to the HoliCity Terms of Use. CAD models © AccuCities Inc.; street-view panoramas © Google. Commercial use requires permission from the respective owners.
• Google Maps content: governed by the Google Maps Platform ToS; not redistributed here. See docs/GOOGLE_MAPS_NOTICE.md.

Because the London/HoliCity portion is non-commercial and the satellite/semantic imagery is Google-derived, City3D-MultiGen as a whole cannot be redistributed as a single open archive — which is exactly why this repository ships a reconstruction recipe rather than the assembled data.

---

Citation

@inproceedings{wang2026gridflow,
  title     = {GridFlow: Structured Latent Flow for Seamless City-Scale 3D Point Cloud Generation},
  author    = {Wang, Xinyu and Ibrahim, Muhammad and Mansoor, Atif and Mian, Ajmal},
  booktitle = {European Conference on Computer Vision (ECCV)},
  year      = {2026}
}