README.md

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

```bash
pip install -r requirements.txt
```

**System dependency — PDAL.** The tiling scripts call [PDAL](https://pdal.io/) (`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:

```bash
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**):

```bash
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`](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](https://cloud.google.com/maps-platform/terms).
> See [`docs/GOOGLE_MAPS_NOTICE.md`](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`](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](https://www.cloudcompare.org/)
(*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:

```bash
# 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)

```bash
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

```bash
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/`](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`](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`](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

```bibtex
@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}
}
```