Initial release: reconstruction pipeline + metadata

.gitignore

@@ -0,0 +1,46 @@
+# ---------------------------------------------------------------------------
+# SAFETY: never commit Google-derived imagery or source/third-party data.
+# These patterns prevent accidental redistribution of content that this repo
+# is deliberately NOT allowed to host (see docs/GOOGLE_MAPS_NOTICE.md).
+# ---------------------------------------------------------------------------
+
+# Google Maps Static API imagery and styled renders
+*_sat.png
+*_map.png
+
+# Semantic masks parsed from Google map renders (Google-derived)
+*_Building.png
+*_RoadSurface.png
+*_Railway.png
+*_VegetationLand.png
+*_UrbanLand.png
+*_WaterSurface.png
+
+# Source / reconstructed point clouds and rasters (link to source instead)
+*.las
+*.laz
+*.fbx
+*_dsm.tif
+*_dsm.png
+*_bev.png
+
+# Assembled per-tile output directories
+output/
+output_*/
+
+# ---------------------------------------------------------------------------
+# Secrets — never commit API keys or signing secrets
+# ---------------------------------------------------------------------------
+.env
+*.key
+*secret*
+credentials*.json
+
+# ---------------------------------------------------------------------------
+# Python
+# ---------------------------------------------------------------------------
+__pycache__/
+*.pyc
+.venv/
+venv/
+.DS_Store

LICENSE

@@ -0,0 +1,31 @@
+MIT License
+
+Copyright (c) 2026 Xinyu Wang, Muhammad Ibrahim, Atif Mansoor, Ajmal Mian
+(The University of Western Australia)
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+-------------------------------------------------------------------------------
+NOTE: This license covers ONLY the pipeline code and the tile-coordinate
+metadata authored by the City3D-MultiGen authors. It does NOT cover:
+  - Google Maps Platform content (satellite/semantic imagery) — governed by the
+    Google Maps Platform Terms of Service; not redistributed here.
+  - The City of Melbourne 3D Point Cloud — governed by its own license.
+  - HoliCity data — governed by its own terms of use.
+See README.md and docs/GOOGLE_MAPS_NOTICE.md.

README.md

@@ -0,0 +1,217 @@
+---
+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. You
+> must recreate this map style in your own Google Cloud account and set its map-style ID above.
+> The exact class→colour mapping is defined in `CLASS_COLORS_HEX` at the top of
+> `Obtain_corresponding_map_signed.py` — reproduce those colours in your style.
+
+> 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}
+}
+```

docs/GOOGLE_MAPS_NOTICE.md

@@ -0,0 +1,21 @@
+# Google Maps Platform — Usage Notice
+
+City3D-MultiGen uses imagery retrieved from the **Google Maps Static API** as its satellite
+and semantic-map conditions. Under the
+[Google Maps Platform Terms of Service](https://cloud.google.com/maps-platform/terms), this
+content **cannot be cached, stored, redistributed, or used to create derivative works** that
+are distributed to third parties.
+
+Accordingly:
+
+- This repository **does not contain** any Google Maps imagery (`*_sat.png`, `*_map.png`) or
+  the semantic masks derived from it (`*_<Class>.png`).
+- The provided scripts retrieve this content **at run time, through live API calls made under
+  your own Google Maps Platform account and API key**.
+- **You** are solely responsible for complying with the Google Maps Platform Terms of Service,
+  including any restrictions on caching, storage, redistribution, and derivative works, and for
+  any usage costs incurred on your account.
+
+If you intend to redistribute a fully assembled copy of the dataset (including the imagery),
+you must first obtain the necessary rights from Google and from the source-data providers. The
+authors of City3D-MultiGen do not grant any rights to Google Maps content.

metadata/README.md

@@ -0,0 +1,23 @@
+# Tile metadata
+
+Per-tile geographic coordinates are **regenerated by the pipeline** rather than shipped as a
+static file. (An earlier exported grid file did not match the released tile set, so it was
+removed to avoid confusion.)
+
+## Files
+
+| File | Description |
+|------|-------------|
+| `melbourne_tile_index.kml` | Tile index for Melbourne, viewable in any GIS tool; input to `scripts/melbourne/grid_from_kml.py`. |
+| `splits/` | Train / validation / test tile-ID lists. Generate with `scripts/make_splits.py` (see `splits/README.md`). |
+
+## Regenerating the tile grid
+
+The tiling scripts derive each tile's geographic extent directly from the source LAS, so no
+pre-computed grid file is required. If you want an explicit grid as JSON, run:
+
+```bash
+python scripts/melbourne/grid_from_kml.py     # writes output_grids.json from the tile index KML
+```
+
+Each entry provides the tile id, grid row/column, and geographic bounding box (UTM + WGS84).

metadata/splits/README.md

@@ -0,0 +1,10 @@
+# Train / validation / test splits
+
+The split is **deterministic** (no shuffling, no random seed): tiles are globbed
+recursively, sorted by path, and sliced sequentially into 80% train / 10% val /
+10% test. Regenerate the exact split used in the paper with:
+
+    python ../../scripts/make_splits.py --data_root /path/to/output \
+        --train_split 0.8 --val_split 0.1 --out_dir .
+
+This writes `train.txt`, `val.txt`, `test.txt` (one `grid_<id>` per line).

requirements.txt

@@ -0,0 +1,13 @@
+# Dependencies for the City3D-MultiGen reproduction pipeline.
+# (Derived from the actual imports in scripts/.)
+numpy
+scipy
+requests
+Pillow
+tqdm
+pyproj
+laspy            # LAS/LAZ point-cloud I/O
+# System dependencies (NOT pip — install separately; see README):
+#   - PDAL            : tiling scripts call `pdal translate` / PDAL pipelines
+#                       (conda install -c conda-forge pdal)
+#   - CloudCompare    : HoliCity FBX -> point-cloud sampling (manual, GUI)

scripts/README.md

@@ -0,0 +1,36 @@
+# Pipeline scripts
+
+These scripts reconstruct City3D-MultiGen from the source data, organized by city.
+Only the canonical (non-duplicate) version of each stage is kept.
+
+## `melbourne/`
+Processing for the City of Melbourne 3D Point Cloud.
+
+| Script | Role |
+|--------|------|
+| `export_las_blocks_noKML.py` | The full tiler: partitions the source LAS into 150 m tiles and produces the per-tile point cloud, **DSM**, and BEV render. |
+| `grid_from_kml.py` | Builds the tile grid (`metadata/*_grids.json`) from the KML tile index. |
+| `Obtain_corresponding_map_signed.py` | Fetches satellite + styled map from the Google Maps Static API and parses the per-class semantic masks. **Reads `GOOGLE_MAPS_API_KEY` and `GOOGLE_MAPS_URL_SIGNING_SECRET` from environment variables.** |
+
+## `holicity/`
+Processing for HoliCity (London) FBX meshes.
+
+| Script | Role |
+|--------|------|
+| `export_las_blocks_noKML.py` | Samples point clouds from the meshes and tiles them (same full tiler as Melbourne). |
+| `convert_coord.py` | Converts HoliCity local coordinates to geographic coordinates. |
+| `add_coord_head.py` | Writes the geographic coordinate header onto each tile. |
+| `check_coord.py` | Sanity-checks the coordinate alignment of generated tiles (optional utility). |
+| `Obtain_corresponding_map_signed.py` | Fetches satellite + semantic maps (same Google API, your own key). |
+
+## `build_dataset.py`
+Top-level orchestrator: tiling → map fetching → DSM/BEV, assembling the per-tile
+layout described in the top-level README.
+
+---
+
+### ⚠️ Before running
+- Set your Google credentials as environment variables (see top-level README).
+- API keys/secrets have been removed from these scripts and are read from the
+  environment. **Do not re-introduce hardcoded credentials** — this repo is public.
+- Edit the input/output paths at the top of each script to match your local layout.

scripts/build_dataset.py

@@ -0,0 +1,87 @@
+#!/usr/bin/env python3
+"""
+City3D-MultiGen — pipeline runner.
+
+This runs the reconstruction stages for one city in order. It does NOT host any
+data: it drives the same scripts documented in the README to rebuild the aligned
+multi-modal tiles locally from (1) source 3D data you downloaded yourself and
+(2) live Google Maps Static API calls made under your own key.
+
+Manual prerequisites (NOT automated here — see README.md):
+  1. Download the source 3D data:
+       - Melbourne: City of Melbourne 3D Point Cloud 2018 (LAS).
+       - HoliCity (London): FBX meshes, then sample a point cloud to LAS with
+         CloudCompare, and georeference it with holicity/convert_coord.py and
+         holicity/add_coord_head.py.
+  2. Install PDAL (conda install -c conda-forge pdal) — the tiler calls it.
+  3. Export your Google credentials:
+       GOOGLE_MAPS_API_KEY, GOOGLE_MAPS_URL_SIGNING_SECRET, GOOGLE_MAPS_STYLE_MAP_ID
+  4. Set the input/output paths at the top of each stage script (the tilers read
+     their LAS input dir and output dir from module-level constants).
+
+Stages run by this script (per city):
+  A. <city>/export_las_blocks_noKML.py  -> tiles + per-tile DSM + BEV
+  B. <city>/Obtain_corresponding_map_signed.py -> satellite + 6 semantic masks
+  C. make_splits.py                     -> train/val/test tile lists
+
+Usage:
+  python scripts/build_dataset.py --city melbourne
+  python scripts/build_dataset.py --city holicity --data_root ./output --skip_splits
+"""
+import argparse
+import os
+import shutil
+import subprocess
+import sys
+
+HERE = os.path.dirname(os.path.abspath(__file__))
+ENV_VARS = ("GOOGLE_MAPS_API_KEY", "GOOGLE_MAPS_URL_SIGNING_SECRET", "GOOGLE_MAPS_STYLE_MAP_ID")
+
+
+def check_prereqs():
+    missing = [k for k in ENV_VARS if not os.environ.get(k)]
+    if missing:
+        sys.exit(f"[error] Missing environment variables: {', '.join(missing)}. See README.md.")
+    if shutil.which("pdal") is None:
+        sys.exit("[error] PDAL not found on PATH. Install it: conda install -c conda-forge pdal")
+
+
+def run(script_rel, *cli_args):
+    path = os.path.join(HERE, script_rel)
+    cmd = [sys.executable, path, *cli_args]
+    print(f"\n>>> {' '.join(cmd)}", flush=True)
+    subprocess.run(cmd, check=True)
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Run the City3D-MultiGen reconstruction stages.")
+    ap.add_argument("--city", choices=["melbourne", "holicity"], required=True)
+    ap.add_argument("--data_root", default="./output",
+                    help="Directory holding the assembled tiles (used for the split step).")
+    ap.add_argument("--skip_splits", action="store_true", help="Do not run make_splits.py.")
+    args = ap.parse_args()
+
+    check_prereqs()
+    print(f"[info] Running the {args.city} pipeline. Ensure the manual prerequisites in this "
+          f"script's docstring are done and paths are configured at the top of each stage script.")
+
+    # Stage A — tile the (already downloaded / sampled) source point clouds.
+    run(f"{args.city}/export_las_blocks_noKML.py")
+
+    # Stage B — fetch satellite + semantic maps for the tiles produced in Stage A.
+    if args.city == "melbourne":
+        run("melbourne/Obtain_corresponding_map_signed.py", "--folder", args.data_root)
+    else:
+        run("holicity/Obtain_corresponding_map_signed.py")
+
+    # Stage C — generate the train/val/test split lists.
+    if not args.skip_splits:
+        run("make_splits.py", "--data_root", args.data_root,
+            "--out_dir", os.path.join(HERE, "..", "metadata", "splits"))
+
+    print("\n[done] Reminder: Google Maps imagery is subject to the Google Maps Platform ToS; "
+          "do not redistribute the fetched *_sat.png / *_map.png / *_<Class>.png files.")
+
+
+if __name__ == "__main__":
+    main()

scripts/holicity/Obtain_corresponding_map_signed.py

@@ -0,0 +1,343 @@
+"""
+Fetch satellite and styled basemap imagery and derive per-class semantic masks
+(HoliCity / London variant of the City3D-MultiGen reconstruction pipeline).
+
+Pipeline role:
+    For each 150 m tile this script downloads a satellite image and a custom-styled
+    Google "roadmap" basemap from the Google Maps Static API (using URL signing),
+    crops both to the tile's WGS84 bounding box, and parses the styled basemap into
+    binary semantic masks by exact/tolerant color matching against CLASS_COLORS_HEX.
+
+Inputs:
+    - A folder (default ``./output``) of per-tile JSON files, each providing the tile
+      corners ``wgs84_nw`` = [west_lon, north_lat] and ``wgs84_se`` = [east_lon, south_lat].
+
+Outputs (written next to each ``<base>.json``, sharing its base name):
+    - ``<base>_sat.png``  : cropped satellite image of the tile.
+    - ``<base>_map.png``  : cropped custom-styled basemap of the tile.
+    - Six binary masks ``<base>_<Class>.png`` for Building, RoadSurface, Railway,
+      VegetationLand, UrbanLand and WaterSurface (255 = class pixel, 0 = background).
+
+Key steps:
+    1. Compute the tile center and download satellite + styled basemap tiles (zoom 18).
+    2. Web-Mercator project the bounding box and crop both images to the tile extent.
+    3. Match styled-map colors per class (exact match, tolerant + 1px dilation for Railway)
+       and save one mask per class. Already-processed tiles are skipped.
+
+Required environment variables (no defaults; the script reads them as-is):
+    - GOOGLE_MAPS_API_KEY            : Google Maps Static API key.
+    - GOOGLE_MAPS_URL_SIGNING_SECRET : URL signing secret used to sign each request.
+    - GOOGLE_MAPS_STYLE_MAP_ID       : Cloud-based map style ID defining the semantic-class
+      colors. You must recreate the custom styled map in your own Google Cloud account.
+"""
+import os
+import json
+import math
+import io
+import time
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+import hashlib
+import hmac
+import base64
+import urllib.parse as urlparse
+
+CLASS_COLORS_HEX = {
+    "RoadSurface":      ["1e1e1e"],
+    "Building":         ["ff0000"],
+    "Railway":          ["0073ff"],
+    "VegetationLand":   ["c3f1d5"],
+    "UrbanLand":        ["f5f0e5", "d3f8e2"],
+    "WaterSurface":     ["90daee"],
+}
+
+def hex_to_rgb(hex_str):
+    h = hex_str.strip().lower()
+    return (
+        int(h[0:2], 16),
+        int(h[2:4], 16),
+        int(h[4:6], 16),
+    )
+
+CLASS_COLORS_RGB = {
+    class_name: [hex_to_rgb(code) for code in hex_list]
+    for class_name, hex_list in CLASS_COLORS_HEX.items()
+}
+
+def sign_url(input_url, secret):
+    if not input_url or not secret:
+        raise Exception("Both input_url and secret are required")
+
+    url = urlparse.urlparse(input_url)
+    url_to_sign = url.path + "?" + url.query
+    decoded_key = base64.urlsafe_b64decode(secret)
+    signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1)
+    encoded_signature = base64.urlsafe_b64encode(signature.digest())
+    original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query
+    return original_url + "&signature=" + encoded_signature.decode()
+
+def dilate_mask_1px(mask_arr):
+    h, w = mask_arr.shape
+    out = np.zeros((h, w), dtype=np.uint8)
+    ys, xs = np.nonzero(mask_arr > 0)
+    for y, x in zip(ys, xs):
+        y0 = max(y - 1, 0)
+        y1 = min(y + 1, h - 1)
+        x0 = max(x - 1, 0)
+        x1 = min(x + 1, w - 1)
+        out[y0:y1+1, x0:x1+1] = 255
+    return out
+
+def match_mask_exact(arr, rgb_triplet):
+    r, g, b = rgb_triplet
+    return (
+        (arr[:, :, 0] == r) &
+        (arr[:, :, 1] == g) &
+        (arr[:, :, 2] == b)
+    )
+
+def channel_bounds_with_margin(channel_val, margin_ratio):
+    low = int(round(channel_val * (1.0 - margin_ratio)))
+    high = int(round(channel_val * (1.0 + margin_ratio)))
+    if low < 0:
+        low = 0
+    if high > 255:
+        high = 255
+    return low, high
+
+def match_mask_tolerant(arr, rgb_triplet, margin_ratio):
+    r, g, b = rgb_triplet
+    rl, rh = channel_bounds_with_margin(r, margin_ratio)
+    gl, gh = channel_bounds_with_margin(g, margin_ratio)
+    bl, bh = channel_bounds_with_margin(b, margin_ratio)
+    return (
+        (arr[:, :, 0] >= rl) & (arr[:, :, 0] <= rh) &
+        (arr[:, :, 1] >= gl) & (arr[:, :, 1] <= gh) &
+        (arr[:, :, 2] >= bl) & (arr[:, :, 2] <= bh)
+    )
+
+def generate_masks_from_roadmap(crop_road_img, base_output_path_no_ext):
+    rgb = crop_road_img.convert("RGB")
+    arr = np.array(rgb, dtype=np.uint8)
+
+    for class_name, rgb_list in CLASS_COLORS_RGB.items():
+        class_mask_total = np.zeros(arr.shape[:2], dtype=np.uint8)
+
+        for rgb_triplet in rgb_list:
+            if class_name == "Railway":
+                match = match_mask_tolerant(arr, rgb_triplet, margin_ratio=0.1)
+            else:
+                match = match_mask_exact(arr, rgb_triplet)
+            class_mask_total[match] = 255
+
+        if class_name == "Railway":
+            class_mask_total = dilate_mask_1px(class_mask_total)
+
+        out_path = f"{base_output_path_no_ext}_{class_name}.png"
+        img = Image.fromarray(class_mask_total)
+        img.save(out_path)
+
+def save_bbox_satellite_and_roadmap(
+    north_lat,
+    west_lon,
+    south_lat,
+    east_lon,
+    out_path_sat,
+    out_path_road,
+    api_key,
+    url_signing_secret,
+    style_map_id
+):
+    def mercator_project(lon_deg, lat_deg, zoom):
+        scale = 256 * (2 ** zoom)
+        x = (lon_deg + 180.0) / 360.0 * scale
+        lat_rad = math.radians(lat_deg)
+        y = (1.0 - math.log(math.tan(lat_rad) + 1.0 / math.cos(lat_rad)) / math.pi) / 2.0 * scale
+        return x, y
+
+    def bbox_center(n_lat, s_lat, w_lon, e_lon):
+        return (
+            (n_lat + s_lat) / 2.0,
+            (w_lon + e_lon) / 2.0
+        )
+
+    def download_static(center_lat, center_lon, zoom, size_px, maptype, api_key, url_signing_secret, style_map_id=None):
+        session = requests.Session()
+        retry_strategy = Retry(
+            total=5,
+            backoff_factor=2,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET"]
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        
+        base = "https://maps.googleapis.com/maps/api/staticmap"
+        params = {
+            "center": f"{center_lat},{center_lon}",
+            "zoom": str(18),
+            "size": f"{size_px}x{size_px}",
+            "format": "png",
+            "key": api_key,
+        }
+        if maptype == "satellite":
+            params["maptype"] = "satellite"
+        else:
+            params["map_id"] = style_map_id
+        
+        query_string = "&".join([f"{k}={urlparse.quote(str(v), safe='')}" for k, v in params.items()])
+        unsigned_url = f"{base}?{query_string}"
+        signed_url = sign_url(unsigned_url, url_signing_secret)
+        
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                resp = session.get(signed_url, timeout=30)
+                resp.raise_for_status()
+                time.sleep(0.5)
+                return Image.open(io.BytesIO(resp.content)).convert("RGBA")
+            except (requests.exceptions.ConnectionError, 
+                    requests.exceptions.Timeout,
+                    requests.exceptions.RequestException) as e:
+                if attempt < max_retries - 1:
+                    wait_time = (attempt + 1) * 5
+                    print(f"\nRequest failed, retrying in {wait_time} seconds...")
+                    time.sleep(wait_time)
+                else:
+                    raise
+
+    def crop_bbox_from_image(img, zoom, img_px, center_lat, center_lon,
+                             n_lat, s_lat, w_lon, e_lon):
+        center_x, center_y = mercator_project(center_lon, center_lat, zoom)
+        img_left_world  = center_x - img_px / 2.0
+        img_top_world   = center_y - img_px / 2.0
+
+        w_x, _ = mercator_project(w_lon, center_lat, zoom)
+        e_x, _ = mercator_project(e_lon, center_lat, zoom)
+        _, n_y = mercator_project(center_lon, n_lat, zoom)
+        _, s_y = mercator_project(center_lon, s_lat, zoom)
+
+        xmin = w_x - img_left_world
+        xmax = e_x - img_left_world
+        ymin = n_y - img_top_world
+        ymax = s_y - img_top_world
+
+        box = (
+            int(round(xmin)),
+            int(round(ymin)),
+            int(round(xmax)),
+            int(round(ymax)),
+        )
+
+        box = (
+            max(0, box[0]),
+            max(0, box[1]),
+            min(img_px, box[2]),
+            min(img_px, box[3]),
+        )
+
+        return img.crop(box)
+
+    zoom = 18
+    img_px = 600
+
+    center_lat, center_lon = bbox_center(north_lat, south_lat, west_lon, east_lon)
+
+    img_sat = download_static(center_lat, center_lon, zoom, img_px, "satellite", api_key, url_signing_secret, style_map_id=None)
+    img_road = download_static(center_lat, center_lon, zoom, img_px, "roadmap", api_key, url_signing_secret, style_map_id=style_map_id)
+
+    crop_sat = crop_bbox_from_image(
+        img_sat, zoom, img_px, center_lat, center_lon,
+        north_lat, south_lat, west_lon, east_lon
+    )
+    crop_road = crop_bbox_from_image(
+        img_road, zoom, img_px, center_lat, center_lon,
+        north_lat, south_lat, west_lon, east_lon
+    )
+
+    crop_sat.save(out_path_sat)
+    crop_road.save(out_path_road)
+
+    return crop_sat, crop_road
+
+def process_folder(
+    folder_path,
+    api_key,
+    url_signing_secret,
+    style_map_id
+):
+    json_files = [f for f in os.listdir(folder_path) if f.lower().endswith(".json")]
+    
+    skipped = 0
+    failed = 0
+    failed_files = []
+    
+    for filename in tqdm(json_files, desc="Processing files", unit="file"):
+        try:
+            json_path = os.path.join(folder_path, filename)
+            base_name = os.path.splitext(filename)[0]
+
+            out_sat = os.path.join(folder_path, base_name + "_sat.png")
+            out_map = os.path.join(folder_path, base_name + "_map.png")
+            
+            expected_files = [out_sat, out_map]
+            for class_name in CLASS_COLORS_RGB.keys():
+                expected_files.append(os.path.join(folder_path, f"{base_name}_{class_name}.png"))
+            
+            if all(os.path.exists(f) for f in expected_files):
+                skipped += 1
+                continue
+
+            with open(json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            wgs84_nw = data["wgs84_nw"]
+            wgs84_se = data["wgs84_se"]
+
+            west_lon  = float(wgs84_nw[0])
+            north_lat = float(wgs84_nw[1])
+            east_lon  = float(wgs84_se[0])
+            south_lat = float(wgs84_se[1])
+
+            crop_sat, crop_road = save_bbox_satellite_and_roadmap(
+                north_lat = north_lat,
+                west_lon  = west_lon,
+                south_lat = south_lat,
+                east_lon  = east_lon,
+                out_path_sat  = out_sat,
+                out_path_road = out_map,
+                api_key       = api_key,
+                url_signing_secret = url_signing_secret,
+                style_map_id  = style_map_id
+            )
+
+            base_mask_prefix = os.path.join(folder_path, base_name)
+            generate_masks_from_roadmap(crop_road, base_mask_prefix)
+            
+        except Exception as e:
+            failed += 1
+            failed_files.append(filename)
+            print(f"\nFailed to process {filename}: {str(e)}")
+            continue
+    
+    print(f"\nProcessing complete!")
+    if skipped > 0:
+        print(f"Skipped {skipped} already processed files")
+    if failed > 0:
+        print(f"Failed to process {failed} files:")
+        for f in failed_files:
+            print(f"  - {f}")
+
+if __name__ == "__main__":
+    folder = "./output"
+    api_key = os.environ.get("GOOGLE_MAPS_API_KEY")
+    url_signing_secret = os.environ.get("GOOGLE_MAPS_URL_SIGNING_SECRET")
+    # Your own Google Cloud map-style ID (defines the semantic-class colors).
+    # See README: you must recreate the styled map in your own account.
+    style_map_id = os.environ.get("GOOGLE_MAPS_STYLE_MAP_ID")
+    process_folder(folder, api_key, url_signing_secret, style_map_id)

scripts/holicity/add_coord_head.py

@@ -0,0 +1,137 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Stamp a spatial reference (EPSG) into the headers of LAS/LAZ point clouds.
+
+Role in the pipeline:
+    After HoliCity (London) tiles have been translated into real-world projected
+    coordinates, some files still lack a CRS recorded in their LAS header. This
+    utility writes the target EPSG into each file's header WITHOUT modifying any
+    point coordinates, so the tiles are correctly tagged for QGIS / satellite
+    imagery alignment before tiling.
+
+Behavior:
+    - Recursively scans a directory for .las/.laz files (skipping macOS "._*"
+      AppleDouble sidecar files).
+    - For each file, first attempts to write the CRS with laspy
+      (header.add_crs, falling back to header.epsg).
+    - If laspy cannot write the SRS, falls back to the PDAL CLI
+      (`pdal translate ... --writers.las.a_srs=EPSG:<code>`), which embeds the
+      SRS into the LAS header while leaving coordinates unchanged.
+    - Verifies each result by reading back the header EPSG and reprojecting the
+      bbox center to WGS84 for a printed sanity check.
+
+Inputs:  directory of .las/.laz files (CLI: -d/--dir).
+Outputs: either overwritten files (--overwrite) or copies with a suffix
+         (default *_srs.las, configurable via --suffix), each carrying TARGET_EPSG.
+External tools: laspy, pyproj, and PDAL (`pdal translate`) as a fallback.
+"""
+
+import os
+import sys
+import argparse
+import subprocess
+from pathlib import Path
+
+import laspy
+from pyproj import CRS, Transformer
+
+TARGET_EPSG = 27700  # OSGB36 / British National Grid (commonly used for London)
+
+def is_mac_dot_underscore(p: Path) -> bool:
+    return p.name.startswith("._")
+
+def try_write_epsg_with_laspy(in_path: Path, out_path: Path, epsg: int) -> bool:
+    """Write the CRS using laspy first; return True on success."""
+    las = laspy.read(str(in_path))
+    ok = False
+    # Option A: add_crs (laspy 2.3+)
+    try:
+        las.header.add_crs(CRS.from_epsg(epsg))
+        ok = True
+    except Exception:
+        pass
+    # Option B: write header.epsg directly (works on some versions)
+    if not ok:
+        try:
+            las.header.epsg = int(epsg)
+            ok = True
+        except Exception:
+            ok = False
+    if ok:
+        las.write(str(out_path))
+    return ok
+
+def try_write_epsg_with_pdal(in_path: Path, out_path: Path, epsg: int) -> bool:
+    """Fall back to PDAL to write the SRS into the LAS header; coordinates unchanged."""
+    try:
+        cmd = [
+            "pdal", "translate", str(in_path), str(out_path),
+            "-f", "writers.las",
+            f"--writers.las.a_srs=EPSG:{epsg}",
+            "--writers.las.compression=false"
+        ]
+        subprocess.check_call(cmd, stdout=subprocess.DEVNULL, stderr=subprocess.STDOUT)
+        return True
+    except Exception:
+        return False
+
+def center_wgs84(path: Path, epsg: int):
+    """Read the bbox center and reproject to WGS84, for printed verification only."""
+    with laspy.open(str(path)) as f:
+        hdr = f.header
+        mins = getattr(hdr, "mins", getattr(hdr, "min", (0,0,0)))
+        maxs = getattr(hdr, "maxs", getattr(hdr, "max", (0,0,0)))
+        cx = (mins[0] + maxs[0]) * 0.5
+        cy = (mins[1] + maxs[1]) * 0.5
+        tr = Transformer.from_crs(f"EPSG:{epsg}", "EPSG:4326", always_xy=True)
+        lon, lat = tr.transform(cx, cy)
+        return (lon, lat), (cx, cy), getattr(hdr, "epsg", None)
+
+def process_file(p: Path, overwrite: bool, keep_suffix: str):
+    out_path = p if overwrite else p.with_name(p.stem + keep_suffix)
+    # Try laspy first
+    ok = try_write_epsg_with_laspy(p, out_path, TARGET_EPSG)
+    method = "laspy"
+    # Then fall back to PDAL
+    if not ok:
+        ok = try_write_epsg_with_pdal(p, out_path, TARGET_EPSG)
+        method = "pdal"
+
+    if not ok:
+        print(f"[FAIL] {p.name}: failed to write EPSG (neither laspy nor pdal available)")
+        return
+
+    # Read back to verify
+    (lon, lat), (cx, cy), epsg_now = center_wgs84(out_path, TARGET_EPSG)
+    print(f"[OK]   {p.name} -> {out_path.name}  via {method} "
+          f"| EPSG: {epsg_now} | center_xy=({cx:.3f},{cy:.3f}) | WGS84=({lon:.6f},{lat:.6f})")
+
+def main():
+    ap = argparse.ArgumentParser(description="Batch-write EPSG into LAS/LAZ headers (without changing coordinates) and print a center-point verification.")
+    ap.add_argument("-d", "--dir", default=".", help="Directory to scan (recursive)")
+    ap.add_argument("--overwrite", action="store_true", help="Overwrite the original files (default writes *_srs.las)")
+    ap.add_argument("--suffix", default="_srs.las", help="Output suffix when not overwriting (default _srs.las)")
+    args = ap.parse_args()
+
+    root = Path(args.dir).resolve()
+    if not root.exists():
+        print(f"Directory does not exist: {root}", file=sys.stderr); sys.exit(1)
+
+    files = [p for p in root.rglob("*")
+             if p.is_file()
+             and p.suffix.lower() in (".las", ".laz")
+             and not is_mac_dot_underscore(p)]
+
+    if not files:
+        print("No .las/.laz files found (._* filtered out)"); return
+
+    print(f"Target EPSG: {TARGET_EPSG}  | Scan directory: {root}\n")
+    for p in sorted(files):
+        try:
+            process_file(p, overwrite=args.overwrite, keep_suffix=args.suffix)
+        except Exception as e:
+            print(f"[ERR]  {p.name}: {e}")
+
+if __name__ == "__main__":
+    main()

scripts/holicity/check_coord.py

@@ -0,0 +1,262 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Sanity-check the coordinates and CRS of georeferenced LAS/LAZ point clouds.
+
+Role in the pipeline:
+    A verification utility that confirms the HoliCity (London) tiles have been
+    georeferenced correctly before tiling. It inspects each LAS/LAZ file's header
+    and bounding box, reprojects the bbox center to WGS84, and checks whether that
+    center falls within an approximate London bounding box.
+
+Behavior:
+    - Recursively scans a directory for .las/.laz files.
+    - Reads header stats (EPSG, bbox, point count, point format, scale, offset)
+      and detects degenerate "near (0,0)" coordinates.
+    - If the file has an EPSG, reprojects its center to WGS84 and flags whether it
+      lies in the London region.
+    - If no EPSG is present, tries a list of candidate CRSs (BNG / UTM 30N / Web
+      Mercator / WGS84) and reports the first one whose center lands in London.
+    - Emits a per-file status (OK / WARN / BAD / ERR) plus a hint, printed as a
+      table and optionally exported to CSV.
+
+Inputs:  directory of .las/.laz files (CLI: -d/--dir), optional CSV path (-o/--output).
+Outputs: a console report table and an optional CSV file. No files are modified.
+External tools: laspy, numpy, pyproj.
+"""
+
+import os
+import sys
+import csv
+import math
+import argparse
+from pathlib import Path
+
+import laspy
+import numpy as np
+from pyproj import CRS, Transformer
+
+# ----------- Tunable parameters -----------
+# London region (WGS84)
+LON_MIN, LON_MAX = -0.6, 0.4
+LAT_MIN, LAT_MAX = 51.2, 51.8
+
+# Common candidate CRSs (used to guess when no EPSG is present)
+CANDIDATE_EPSGS = [
+    27700,   # OSGB36 / British National Grid
+    32630,   # WGS84 / UTM zone 30N
+    3857,    # Web Mercator
+    4326,    # WGS84 (lat/lon)
+]
+
+# Rough "plausible ranges" for the UK / London (quick sanity check; approximate only)
+RANGE_HINTS = {
+    27700: {"E": (0, 700000), "N": (0, 1300000), "name": "OSGB36 / BNG"},
+    32630: {"E": (160000, 840000), "N": (5550000, 5900000), "name": "UTM 30N"},
+    3857: {"X": (-500000, 500000), "Y": (6200000, 7300000), "name": "WebMerc"},
+    4326: {"Lon": (-10, 10), "Lat": (45, 60), "name": "WGS84 deg"},
+}
+# Approximate reference for the center of London (used only for printed hints)
+LONDON_WGS84 = (-0.1, 51.51)
+
+# --------------------------------
+
+def in_london(lon, lat):
+    return (LON_MIN <= lon <= LON_MAX) and (LAT_MIN <= lat <= LAT_MAX)
+
+def safe_epsg_str(epsg):
+    try:
+        return f"EPSG:{int(epsg)}"
+    except Exception:
+        return "None"
+
+def read_stats(path: Path, sample_n: int = 200000):
+    """Read the bbox and center point; for large clouds only the header bbox is read; sample some points for QC if needed."""
+    with laspy.open(str(path)) as f:
+        hdr = f.header
+        mins = np.array(getattr(hdr, "mins", getattr(hdr, "min", (0, 0, 0))), dtype=float)
+        maxs = np.array(getattr(hdr, "maxs", getattr(hdr, "max", (0, 0, 0))), dtype=float)
+        epsg = None
+        try:
+            epsg = hdr.epsg
+        except Exception:
+            pass
+
+        # Center point (the bbox midpoint is sufficient)
+        cx = (mins[0] + maxs[0]) * 0.5
+        cy = (mins[1] + maxs[1]) * 0.5
+        cz = (mins[2] + maxs[2]) * 0.5
+
+        # Check whether everything sits near (0,0)
+        zeroish = (abs(cx) < 1e-6 and abs(cy) < 1e-6) or \
+                  (abs(mins[0]) < 1e-6 and abs(maxs[0]) < 1e-6 and
+                   abs(mins[1]) < 1e-6 and abs(maxs[1]) < 1e-6)
+
+        return {
+            "epsg": epsg,
+            "mins": mins, "maxs": maxs,
+            "center": (cx, cy, cz),
+            "zeroish": zeroish,
+            "point_count": int(getattr(hdr, "point_count", 0)),
+            "point_format": str(getattr(hdr.point_format, "id", hdr.point_format)),
+            "scale": tuple(hdr.scales),
+            "offset": tuple(hdr.offsets),
+        }
+
+def transform_to_wgs84(x, y, epsg):
+    """Reproject (x,y) from the given EPSG to WGS84 lon/lat. Return None on failure."""
+    try:
+        src = CRS.from_epsg(int(epsg))
+        dst = CRS.from_epsg(4326)
+        tr = Transformer.from_crs(src, dst, always_xy=True)
+        lon, lat = tr.transform(x, y)
+        return lon, lat
+    except Exception:
+        return None
+
+def guess_and_transform_to_wgs84(x, y, candidates=CANDIDATE_EPSGS):
+    """When no EPSG is set, try each candidate CRS in turn; return the first projection that falls within the London region, along with its epsg."""
+    tried = []
+    for epsg in candidates:
+        res = transform_to_wgs84(x, y, epsg)
+        if res is None: 
+            tried.append((epsg, None))
+            continue
+        lon, lat = res
+        tried.append((epsg, (lon, lat)))
+        if in_london(lon, lat):
+            return (lon, lat), epsg, tried
+    return None, None, tried
+
+def range_hint_text(epsg, mins, maxs):
+    h = RANGE_HINTS.get(int(epsg)) if epsg is not None else None
+    if not h:
+        return ""
+    if epsg in (27700, 32630):
+        E = (mins[0], maxs[0]); N = (mins[1], maxs[1])
+        return f"RangeHint {h['name']}: E∈{h['E']} vs {E}, N∈{h['N']} vs {N}"
+    elif epsg == 3857:
+        X = (mins[0], maxs[0]); Y = (mins[1], maxs[1])
+        return f"RangeHint {h['name']}: X∈{h['X']} vs {X}, Y∈{h['Y']} vs {Y}"
+    elif epsg == 4326:
+        Lon = (mins[0], maxs[0]); Lat = (mins[1], maxs[1])
+        return f"RangeHint {h['name']}: Lon∈{h['Lon']} vs {Lon}, Lat∈{h['Lat']} vs {Lat}"
+    return ""
+
+def analyze_file(path: Path):
+    size_mb = path.stat().st_size / (1024 * 1024)
+    stats = read_stats(path)
+    epsg = stats["epsg"]
+    cx, cy, cz = stats["center"]
+    mins, maxs = stats["mins"], stats["maxs"]
+
+    result = {
+        "file": str(path.name),
+        "size_mb": f"{size_mb:.2f}",
+        "epsg": safe_epsg_str(epsg),
+        "pt_fmt": stats["point_format"],
+        "pts": stats["point_count"],
+        "scale": stats["scale"],
+        "offset": stats["offset"],
+        "center_xy": (cx, cy),
+        "center_wgs84": None,
+        "in_london": False,
+        "status": "",
+        "hint": "",
+    }
+
+    # 0) All-zero / near-zero
+    if stats["zeroish"]:
+        result["status"] = "BAD"
+        result["hint"] = "Coordinates near (0,0); likely unassigned or wrong projection. Check the coordinate transform and EPSG write."
+        return result
+
+    # 1) Has EPSG: project and check directly
+    if epsg is not None:
+        wgs = transform_to_wgs84(cx, cy, int(epsg))
+        if wgs is None:
+            result["status"] = "WARN"
+            result["hint"] = f"Could not project the center from {safe_epsg_str(epsg)} to WGS84; the EPSG may be invalid."
+            return result
+        lon, lat = wgs
+        result["center_wgs84"] = (round(lon, 6), round(lat, 6))
+        result["in_london"] = in_london(lon, lat)
+        if result["in_london"]:
+            result["status"] = "OK"
+            result["hint"] = f"Center is within the London region; {range_hint_text(int(epsg), mins, maxs)}"
+        else:
+            result["status"] = "WARN"
+            result["hint"] = f"Center is outside the London region ({lon:.5f},{lat:.5f}); if it should be in London, the EPSG or translation may be wrong. {range_hint_text(int(epsg), mins, maxs)}"
+        return result
+
+    # 2) No EPSG: try to guess and check whether it lands in London
+    guessed, gepsg, tried = guess_and_transform_to_wgs84(cx, cy)
+    if guessed is not None:
+        lon, lat = guessed
+        result["center_wgs84"] = (round(lon, 6), round(lat, 6))
+        result["in_london"] = True
+        result["status"] = "WARN"
+        result["hint"] = (f"No EPSG written, but {safe_epsg_str(gepsg)} is inferred to fall in the London region. "
+                          f"Suggest writing {safe_epsg_str(gepsg)} and retrying.")
+    else:
+        result["status"] = "BAD"
+        tried_text = "; ".join(
+            f"EPSG:{e} -> {('None' if v is None else f'({v[0]:.5f},{v[1]:.5f})')}" for e, v in tried
+        )
+        result["hint"] = ("No EPSG written, and none of the common candidate CRSs project the center into the London region. "
+                          "Check whether a wrong translation/rotation/unit was used, or whether a different EPSG is needed. "
+                          f"Attempts: {tried_text}")
+    return result
+
+def print_table(rows):
+    headers = ["file","size_mb","epsg","pt_fmt","pts","center_xy","center_wgs84","in_london","status","hint"]
+    colw = {h: max(len(h), max((len(str(r[h])) for r in rows), default=0)) for h in headers}
+    sep = " | "
+    print(sep.join(h.ljust(colw[h]) for h in headers))
+    print("-" * (sum(colw.values()) + len(sep)*(len(headers)-1)))
+    for r in rows:
+        print(sep.join(str(r[h]).ljust(colw[h]) for h in headers))
+
+def main():
+    ap = argparse.ArgumentParser(description="Check whether LAS/LAZ files have correct coordinates and CRS, and whether they fall within the London region.")
+    ap.add_argument("-d","--dir", default=".", help="Directory to scan (default: current directory)")
+    ap.add_argument("-o","--output", default=None, help="CSV export path (optional)")
+    args = ap.parse_args()
+
+    root = Path(args.dir).resolve()
+    if not root.exists():
+        print(f"Directory does not exist: {root}", file=sys.stderr); sys.exit(1)
+
+    files = []
+    for p in root.rglob("*"):
+        if p.is_file() and p.suffix.lower() in (".las",".laz"):
+            files.append(p)
+
+    if not files:
+        print("No .las/.laz files found"); return
+
+    rows = []
+    for p in sorted(files):
+        try:
+            rows.append(analyze_file(p))
+        except Exception as e:
+            rows.append({
+                "file": p.name, "size_mb":"?", "epsg":"?", "pt_fmt":"?", "pts":"?",
+                "center_xy":"?", "center_wgs84":"?", "in_london":"?", "status":"ERR",
+                "hint": f"Parse failed: {e}"
+            })
+
+    print(f"Scan directory: {root}\n")
+    print_table(rows)
+
+    if args.output:
+        out = Path(args.output).resolve()
+        out.parent.mkdir(parents=True, exist_ok=True)
+        with out.open("w", newline="", encoding="utf-8") as f:
+            writer = csv.DictWriter(f, fieldnames=list(rows[0].keys()))
+            writer.writeheader()
+            writer.writerows(rows)
+        print(f"\nCSV written: {out}")
+
+if __name__ == "__main__":
+    main()

scripts/holicity/convert_coord.py

@@ -0,0 +1,163 @@
+#!/usr/bin/env python3
+# -*- coding: utf-8 -*-
+"""
+Georeference HoliCity (London) LAS tiles into a real-world projected CRS.
+
+Role in the pipeline:
+    HoliCity point clouds are sampled (via CloudCompare) from FBX meshes in a
+    local coordinate frame with no spatial reference. This script geo-registers
+    the four 500x500 m tiles (NW/NE/SW/SE) of a HoliCity block onto the London
+    map so they line up with satellite imagery before tiling.
+
+Method:
+    - The WGS84 latitude/longitude of the NW tile's top-left (north-west) corner
+      is known and hard-coded below (NW_LAT/NW_LON; west longitude is negative).
+    - That anchor is projected from WGS84 (EPSG:4326) into the target projected
+      CRS (default EPSG:27700, OSGB36 / British National Grid).
+    - The remaining tiles are placed by a fixed 500 m east/south offset.
+    - For each tile, the local top-left corner (minX, maxY) is read from the LAS
+      header bounding box, and a planar XY translation is computed to move that
+      corner onto its target projected coordinate.
+
+Inputs:
+    The four LAS files listed in INPUT_FILES, located in the current directory.
+Outputs:
+    For each input, a translated copy named *_georef.las with the target EPSG
+    written into its header.
+
+External tools: laspy (LAS I/O), pyproj (CRS transform), numpy.
+"""
+
+import os
+from pathlib import Path
+import laspy
+import numpy as np
+from pyproj import Transformer
+
+# ==== Parameters to confirm / adjust ====
+# Known WGS84 lat/lon of the NW tile's top-left (north-west) corner
+NW_LAT = 51.512499
+NW_LON = -0.099173  # WGS84 longitude; west of Greenwich is negative
+
+# Real-world size of a single tile (meters)
+TILE_SIZE_M = 500.0
+
+# Target projected CRS (British National Grid recommended for London)
+TARGET_EPSG = 27700  # OSGB36 / British National Grid
+SOURCE_CRS = "EPSG:4326"  # NW_LAT/NW_LON are given in WGS84
+
+# The 4 files to process (filenames must distinguish the direction)
+INPUT_FILES = [
+    "TQ3280_NW.las",
+    "TQ3280NE.las",
+    "TQ3280SW.las",
+    "TQ3280SE.las",
+]
+# Output filename suffix
+OUT_SUFFIX = "_georef.las"
+
+# =================================
+
+def read_bbox(path: Path):
+    with laspy.open(str(path)) as f:
+        hdr = f.header
+        mins = np.array(getattr(hdr, "mins", getattr(hdr, "min", (0,0,0))), dtype=float)
+        maxs = np.array(getattr(hdr, "maxs", getattr(hdr, "max", (0,0,0))), dtype=float)
+        scales = np.array(hdr.scales)
+        offsets = np.array(hdr.offsets)
+    return mins, maxs, scales, offsets
+
+def apply_translation(in_path: Path, out_path: Path, tx: float, ty: float, target_epsg: int):
+    las = laspy.read(str(in_path))
+    # Translate (X/Y only; if a Z datum correction is needed, add a Z offset here)
+    las.x = las.x + tx
+    las.y = las.y + ty
+
+    # Write the EPSG (laspy 2.x: header.epsg)
+    try:
+        las.header.epsg = int(target_epsg)
+    except Exception:
+        # Some versions may require writing via a VLR; keep the simplest setting here
+        pass
+
+    # Optional: tag generation metadata
+    try:
+        las.header.system_identifier = "GeorefByScript"
+        las.header.generating_software = "laspy_pyproj_georef"
+    except Exception:
+        pass
+
+    las.write(str(out_path))
+
+def main():
+    root = Path(".").resolve()
+    # 1) Project the NW top-left corner (WGS84) into target CRS coords (easting, northing)
+    transformer = Transformer.from_crs(SOURCE_CRS, f"EPSG:{TARGET_EPSG}", always_xy=True)
+    # always_xy=True => input order is longitude, latitude (lon, lat)
+    nw_e, nw_n = transformer.transform(NW_LON, NW_LAT)
+
+    # 2) Build the target "top-left" coords for the four directions (top-left = north-west)
+    # NE: +500m east of NW
+    # SW: +500m south of NW
+    # SE: +500m east and +500m south of NW
+    targets = {
+        "NW": (nw_e,               nw_n),
+        "NE": (nw_e + TILE_SIZE_M, nw_n),
+        "SW": (nw_e,               nw_n - TILE_SIZE_M),
+        "SE": (nw_e + TILE_SIZE_M, nw_n - TILE_SIZE_M),
+    }
+
+    # 3) Per file: compute translation from local top-left (minX, maxY) to target top-left
+    for fname in INPUT_FILES:
+        in_path = root / fname
+        if not in_path.exists():
+            print(f"[SKIP] File not found: {in_path}")
+            continue
+
+        # Determine the direction from the filename
+        up = fname.upper()
+        if "NW" in up and "TQ3280NW" in up:
+            key = "NW"
+        elif "NE" in up:
+            key = "NE"
+        elif "SW" in up:
+            key = "SW"
+        elif "SE" in up:
+            key = "SE"
+        elif "NW" in up:
+            # Case where the name contains _NW
+            key = "NW"
+        else:
+            print(f"[WARN] Cannot infer direction from filename; treating as NW: {fname}")
+            key = "NW"
+
+        tgt_e, tgt_n = targets[key]
+
+        # Read the local bbox
+        mins, maxs, scales, offsets = read_bbox(in_path)
+        minX, minY = float(mins[0]), float(mins[1])
+        maxX, maxY = float(maxs[0]), float(maxs[1])
+
+        # Local top-left corner (north-west) = (minX, maxY)
+        local_left_top = np.array([minX, maxY], dtype=float)
+        target_left_top = np.array([tgt_e, tgt_n], dtype=float)
+
+        # Translation t = target - local
+        t = target_left_top - local_left_top
+        tx, ty = float(t[0]), float(t[1])
+
+        # Print diagnostic info
+        print(f"\n=== {fname} ===")
+        print(f"Local bbox X:[{minX:.3f}, {maxX:.3f}]  Y:[{minY:.3f}, {maxY:.3f}]")
+        print(f"Local top-left (NW local) = ({local_left_top[0]:.3f}, {local_left_top[1]:.3f})")
+        print(f"Target top-left (NW target EPSG:{TARGET_EPSG}) = ({target_left_top[0]:.3f}, {target_left_top[1]:.3f})")
+        print(f"Translation (tx, ty) = ({tx:.3f}, {ty:.3f})  [units: meters, projected coords]")
+
+        out_path = in_path.with_name(in_path.stem + OUT_SUFFIX)
+        apply_translation(in_path, out_path, tx, ty, TARGET_EPSG)
+        print(f"Written: {out_path.name} (EPSG:{TARGET_EPSG} set)")
+
+    print("\nDone. Load *_georef.las into QGIS and set the project CRS to EPSG:%d (or enable on-the-fly reprojection)." % TARGET_EPSG)
+
+if __name__ == "__main__":
+    main()

scripts/holicity/export_las_blocks_noKML.py

@@ -0,0 +1,1048 @@
+"""
+HoliCity (London) LAS tiler for the City3D-MultiGen reconstruction pipeline.
+
+Pipeline role:
+    This script implements the per-block tiling stage of the City3D-MultiGen
+    dataset pipeline used in the ECCV 2026 "GridFlow" paper. For the HoliCity
+    (London) source, dense point clouds are first sampled from the original FBX
+    meshes using CloudCompare and saved as LAS/LAZ. This script then partitions
+    those point clouds into regular 150m x 150m ground blocks and renders the
+    per-tile products consumed by downstream training/evaluation.
+
+Inputs:
+    - LAS/LAZ point clouds sampled from HoliCity FBX meshes via CloudCompare,
+      placed in TILE_DIR. Files are auto-scanned (or listed explicitly), and
+      their georeferencing/CRS is read from the LAS headers (London uses the
+      OSGB / EPSG:27700 family; UTM is auto-detected as a fallback).
+
+Outputs (one set per grid cell, written to OUTPUT_DIR):
+    - Per-tile cropped point cloud (grid_NNNNNN.las / .laz)
+    - DSM as GeoTIFF + normalized PNG (grid_NNNNNN_dsm.tif / _dsm.png)
+    - BEV top-down RGBA render (grid_NNNNNN_bev.png)
+    - Per-tile JSON log plus a global processing_summary.json and an
+      output_grids.kml visualization of the generated grid layout.
+
+Key steps:
+    1. Read each input LAS boundary and build one WGS84 polygon per file.
+    2. Generate a regular grid of cells (with configurable overlap/spacing)
+       restricted to cells whose center falls inside an input polygon.
+    3. Optionally scan all tiles for a global elevation range (for DSM scaling).
+    4. For each cell: find overlapping tiles, crop the points, optionally voxel
+       downsample, then render the BEV and DSM and write logs. Supports resume
+       mode to skip already-completed cells.
+
+External tools:
+    - PDAL is invoked via subprocess (`pdal pipeline`) to crop/merge tiles.
+    - GDAL/OSR (osgeo) is used to write georeferenced DSM GeoTIFFs.
+    - laspy, numpy, Pillow, scipy, pyproj and tqdm provide IO and processing.
+"""
+
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from pyproj import Transformer
+from typing import List, Tuple, Dict
+import laspy
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+from scipy.ndimage import uniform_filter
+
+GRID_SIZE = 150
+GRID_SPACING = -145
+INPUT_LAS_FILES = None
+TILE_DIR = "./LAS"
+OUTPUT_DIR = "./output"
+VOXEL_SIZE = 0.05
+TEST_MODE_LIMIT = None
+DEBUG_MODE = False
+USE_VOXEL_FILTER = False
+PYTHON_VOXEL_DEDUP = False
+OUTPUT_COMPRESSED = False
+
+RESUME_MODE = True
+FORCE_REPROCESS = False
+
+BEV_POINT_SIZE = 8
+BEV_TRANSPARENT_BG = True
+BEV_USE_RGB = True
+BEV_POINT_OPACITY = 1.0
+BEV_OPACITY_MODE = "fixed"
+
+BEV_ADAPTIVE_POINT_SIZE = True
+BEV_POINT_SIZE_MIN = 1
+BEV_POINT_SIZE_MAX = 15
+BEV_DENSITY_WINDOW = 10
+
+MEMORY_OPTIMIZATION = True
+BEV_RESOLUTION = 1024
+MAX_POINTS_IN_MEMORY = 10000000
+
+GENERATE_DSM = True
+DSM_RESOLUTION = 256
+DSM_POINT_SIZE = 3
+DSM_USE_GLOBAL_RANGE = True
+
+def parse_las_boundaries(las_files: List[str], tile_dir: str) -> Tuple[List[List[Tuple[float, float]]], str]:
+    if las_files is None or len(las_files) == 0:
+        print(f"AUTO-SCAN MODE: Scanning all LAS files in {tile_dir}")
+        las_paths = list(Path(tile_dir).glob("*.las")) + list(Path(tile_dir).glob("*.laz"))
+        las_paths = [f for f in las_paths if not f.name.startswith("grid_")]
+        las_files = [f.name for f in las_paths]
+        
+        if len(las_files) == 0:
+            raise ValueError(f"No LAS files found in {tile_dir}")
+        
+        print(f"Found {len(las_files)} LAS files:")
+        for f in las_files:
+            print(f"  - {f}")
+    else:
+        print(f"MANUAL MODE: Using {len(las_files)} specified files")
+    
+    print(f"\nReading boundaries from {len(las_files)} LAS files")
+    print("Creating individual polygons for each input file to preserve neighboring relationships")
+    
+    all_bounds = []
+    crs_list = []
+    
+    for las_file in las_files:
+        las_path = os.path.join(tile_dir, las_file)
+        if not os.path.exists(las_path):
+            print(f"Warning: File not found: {las_path}")
+            continue
+            
+        try:
+            with laspy.open(las_path) as f:
+                header = f.header
+                bounds = {
+                    'file': las_file,
+                    'min_x': header.x_min,
+                    'max_x': header.x_max,
+                    'min_y': header.y_min,
+                    'max_y': header.y_max
+                }
+                all_bounds.append(bounds)
+                
+                if hasattr(header, 'parse_crs'):
+                    crs = header.parse_crs()
+                    if crs:
+                        crs_list.append(str(crs))
+                
+                print(f"  {las_file}: X=[{bounds['min_x']:.2f}, {bounds['max_x']:.2f}], Y=[{bounds['min_y']:.2f}, {bounds['max_y']:.2f}]")
+        except Exception as e:
+            print(f"Error reading {las_file}: {e}")
+            continue
+    
+    if not all_bounds:
+        raise ValueError("No valid LAS files found")
+    
+    overall_min_x = min(b['min_x'] for b in all_bounds)
+    overall_max_x = max(b['max_x'] for b in all_bounds)
+    overall_min_y = min(b['min_y'] for b in all_bounds)
+    overall_max_y = max(b['max_y'] for b in all_bounds)
+    
+    print(f"\nOverall boundary: X=[{overall_min_x:.2f}, {overall_max_x:.2f}], Y=[{overall_min_y:.2f}, {overall_max_y:.2f}]")
+    
+    if crs_list:
+        detected_crs = crs_list[0]
+        print(f"Detected CRS: {detected_crs}")
+        if 'EPSG:' in detected_crs:
+            utm_crs = detected_crs.split('EPSG:')[1].split()[0]
+            utm_crs = f"EPSG:{utm_crs}"
+        else:
+            print("Warning: Could not parse EPSG code, using auto-detection")
+            center_x = (overall_min_x + overall_max_x) / 2
+            center_y = (overall_min_y + overall_max_y) / 2
+            utm_crs = auto_detect_utm_from_coords(center_x, center_y)
+    else:
+        print("Warning: No CRS found in LAS headers, using auto-detection")
+        center_x = (overall_min_x + overall_max_x) / 2
+        center_y = (overall_min_y + overall_max_y) / 2
+        utm_crs = auto_detect_utm_from_coords(center_x, center_y)
+    
+    print(f"Using UTM CRS: {utm_crs}")
+    
+    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    
+    polygons_wgs84 = []
+    for i, bounds in enumerate(all_bounds):
+        rectangle_utm = [
+            (bounds['min_x'], bounds['max_y']),
+            (bounds['max_x'], bounds['max_y']),
+            (bounds['max_x'], bounds['min_y']),
+            (bounds['min_x'], bounds['min_y'])
+        ]
+        
+        rectangle_wgs84 = []
+        for x, y in rectangle_utm:
+            lon, lat = transformer_to_wgs.transform(x, y)
+            rectangle_wgs84.append((lon, lat))
+        
+        polygons_wgs84.append(rectangle_wgs84)
+        print(f"  Created polygon {i+1} for {bounds['file']}")
+    
+    print(f"\nCreated {len(polygons_wgs84)} individual polygons (one per input file)")
+    print("Grids will only be generated where they overlap with these polygons")
+    
+    return polygons_wgs84, utm_crs
+
+def auto_detect_utm_from_coords(x: float, y: float) -> str:
+    if 100000 < x < 900000 and 1000000 < y < 10000000:
+        if y > 5000000:
+            zone = int((x + 500000) / 1000000) + 30
+            return f"EPSG:326{zone:02d}"
+        else:
+            zone = int((x + 500000) / 1000000) + 30
+            return f"EPSG:327{zone:02d}"
+    else:
+        print(f"Warning: Coordinates ({x}, {y}) do not match typical UTM range")
+        return "EPSG:32650"
+
+def get_utm_zone(lon: float, lat: float) -> str:
+    zone = int((lon + 180) / 6) + 1
+    hemisphere = 'north' if lat >= 0 else 'south'
+    return f"EPSG:326{zone:02d}" if hemisphere == 'north' else f"EPSG:327{zone:02d}"
+
+def point_in_polygon(point: Tuple[float, float], polygon: List[Tuple[float, float]]) -> bool:
+    x, y = point
+    n = len(polygon)
+    inside = False
+    
+    p1x, p1y = polygon[0]
+    for i in range(1, n + 1):
+        p2x, p2y = polygon[i % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                if x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= xinters:
+                        inside = not inside
+        p1x, p1y = p2x, p2y
+    
+    return inside
+
+def generate_grids(polygons_wgs84: List[List[Tuple[float, float]]], 
+                   grid_size: float, 
+                   spacing: float,
+                   utm_crs: str,
+                   transformer_to_utm,
+                   transformer_to_wgs) -> List[Dict]:
+    
+    polygons_utm = []
+    for poly_wgs in polygons_wgs84:
+        poly_utm = [transformer_to_utm.transform(lon, lat) for lon, lat in poly_wgs]
+        polygons_utm.append(poly_utm)
+    
+    all_utm_points = [p for poly in polygons_utm for p in poly]
+    min_x = min(p[0] for p in all_utm_points)
+    max_x = max(p[0] for p in all_utm_points)
+    min_y = min(p[1] for p in all_utm_points)
+    max_y = max(p[1] for p in all_utm_points)
+    
+    print(f"Grid generation boundary: X=[{min_x:.2f}, {max_x:.2f}], Y=[{min_y:.2f}, {max_y:.2f}]")
+    print(f"Area size: {max_x-min_x:.2f}m x {max_y-min_y:.2f}m")
+    
+    grids = []
+    grid_id = 0
+    
+    y = min_y
+    row = 0
+    while y < max_y:
+        x = min_x
+        col = 0
+        while x < max_x:
+            center_x = x + grid_size / 2
+            center_y = y + grid_size / 2
+            center_lon, center_lat = transformer_to_wgs.transform(center_x, center_y)
+            
+            is_in_any_polygon = False
+            for poly_wgs in polygons_wgs84:
+                if point_in_polygon((center_lon, center_lat), poly_wgs):
+                    is_in_any_polygon = True
+                    break
+            
+            if is_in_any_polygon:
+                nw_lon, nw_lat = transformer_to_wgs.transform(x, y + grid_size)
+                se_lon, se_lat = transformer_to_wgs.transform(x + grid_size, y)
+                
+                grid = {
+                    'id': grid_id,
+                    'row': row,
+                    'col': col,
+                    'utm_nw': (x, y + grid_size),
+                    'utm_se': (x + grid_size, y),
+                    'wgs84_nw': (nw_lon, nw_lat),
+                    'wgs84_se': (se_lon, se_lat),
+                    'center_wgs84': (center_lon, center_lat)
+                }
+                grids.append(grid)
+                grid_id += 1
+            
+            x += (grid_size + spacing)
+            col += 1
+        
+        y += (grid_size + spacing)
+        row += 1
+    
+    print(f"Generated {len(grids)} grids that overlap with input polygons")
+    return grids
+
+def create_kml(grids: List[Dict], output_path: str):
+    kml_header = '''<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+  <Document>
+    <name>Grid Boundaries</name>
+    <Style id="gridStyle">
+      <LineStyle>
+        <color>ff0000ff</color>
+        <width>2</width>
+      </LineStyle>
+      <PolyStyle>
+        <color>330000ff</color>
+      </PolyStyle>
+    </Style>
+'''
+    
+    kml_footer = '''  </Document>
+</kml>'''
+    
+    with open(output_path, 'w') as f:
+        f.write(kml_header)
+        
+        for grid in grids:
+            nw_lon, nw_lat = grid['wgs84_nw']
+            se_lon, se_lat = grid['wgs84_se']
+            
+            ne_lon, ne_lat = se_lon, nw_lat
+            sw_lon, sw_lat = nw_lon, se_lat
+            
+            placemark = f'''    <Placemark>
+      <name>Grid {grid['id']:06d}</name>
+      <description>Row: {grid['row']}, Col: {grid['col']}</description>
+      <styleUrl>#gridStyle</styleUrl>
+      <Polygon>
+        <outerBoundaryIs>
+          <LinearRing>
+            <coordinates>
+              {nw_lon},{nw_lat},0
+              {ne_lon},{ne_lat},0
+              {se_lon},{se_lat},0
+              {sw_lon},{sw_lat},0
+              {nw_lon},{nw_lat},0
+            </coordinates>
+          </LinearRing>
+        </outerBoundaryIs>
+      </Polygon>
+    </Placemark>
+'''
+            f.write(placemark)
+        
+        f.write(kml_footer)
+    
+    print(f"KML file created: {output_path}")
+
+def get_tile_bounds(tile_dir: str) -> Dict[str, Dict]:
+    tile_bounds = {}
+    las_files = list(Path(tile_dir).glob("*.las")) + list(Path(tile_dir).glob("*.laz"))
+    las_files = [f for f in las_files if not f.name.startswith("grid_")]
+    
+    print(f"Scanning {len(las_files)} tiles for bounds...")
+    
+    for las_file in las_files:
+        try:
+            with laspy.open(str(las_file)) as f:
+                header = f.header
+                tile_bounds[las_file.name] = {
+                    'min_x': header.x_min,
+                    'max_x': header.x_max,
+                    'min_y': header.y_min,
+                    'max_y': header.y_max
+                }
+        except Exception as e:
+            print(f"Error reading {las_file.name}: {e}")
+    
+    print(f"Successfully scanned {len(tile_bounds)} tiles")
+    return tile_bounds
+
+def scan_global_elevation_range(tile_dir: str, tile_bounds: Dict) -> Tuple[float, float]:
+    print("\n" + "="*60)
+    print("Scanning global elevation range from all tiles...")
+    print("="*60)
+    
+    global_min_z = float('inf')
+    global_max_z = float('-inf')
+    tiles_processed = 0
+    
+    for tile_file in tqdm(tile_bounds.keys(), desc="Scanning tiles", unit="tile"):
+        tile_path = os.path.join(tile_dir, tile_file)
+        try:
+            with laspy.open(tile_path) as f:
+                las = f.read()
+                if las.header.point_count > 0:
+                    z = np.array(las.z)
+                    tile_min = float(z.min())
+                    tile_max = float(z.max())
+                    global_min_z = min(global_min_z, tile_min)
+                    global_max_z = max(global_max_z, tile_max)
+                    tiles_processed += 1
+        except Exception as e:
+            print(f"Error reading {tile_file}: {e}")
+            continue
+    
+    if global_min_z == float('inf') or global_max_z == float('-inf'):
+        print("Warning: Could not determine global elevation range, will use local ranges")
+        return None, None
+    
+    print(f"\nGlobal elevation range from {tiles_processed} tiles:")
+    print(f"  Min elevation: {global_min_z:.2f}m")
+    print(f"  Max elevation: {global_max_z:.2f}m")
+    print(f"  Range: {global_max_z - global_min_z:.2f}m")
+    
+    return global_min_z, global_max_z
+
+def find_overlapping_tiles(grid: Dict, tile_bounds: Dict) -> List[str]:
+    grid_min_x, grid_max_y = grid['utm_nw']
+    grid_max_x, grid_min_y = grid['utm_se']
+    
+    overlapping = []
+    for tile_name, bounds in tile_bounds.items():
+        if not (bounds['max_x'] < grid_min_x or bounds['min_x'] > grid_max_x or
+                bounds['max_y'] < grid_min_y or bounds['min_y'] > grid_max_y):
+            overlapping.append(tile_name)
+    
+    return overlapping
+
+def crop_las_with_pdal(tile_files: List[str], grid: Dict, output_path: str, tile_dir: str) -> Dict:
+    try:
+        min_x, max_y = grid['utm_nw']
+        max_x, min_y = grid['utm_se']
+        
+        input_files = [os.path.join(tile_dir, f) for f in tile_files]
+        
+        pipeline = {
+            "pipeline": []
+        }
+        
+        for input_file in input_files:
+            pipeline["pipeline"].append(input_file)
+        
+        bounds_str = f"([{min_x}, {max_x}], [{min_y}, {max_y}])"
+        
+        filters = [
+            {
+                "type": "filters.crop",
+                "bounds": bounds_str
+            }
+        ]
+        
+        if USE_VOXEL_FILTER and len(tile_files) > 1:
+            filters.append({
+                "type": "filters.voxelcenternearestneighbor",
+                "cell": VOXEL_SIZE
+            })
+        
+        filters.append({
+            "type": "writers.las",
+            "filename": output_path,
+            "compression": "laszip" if OUTPUT_COMPRESSED else "none"
+        })
+        
+        pipeline["pipeline"].extend(filters)
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+            json.dump(pipeline, f, indent=2)
+            pipeline_file = f.name
+        
+        try:
+            result = subprocess.run(
+                ['pdal', 'pipeline', pipeline_file],
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+            
+            if result.returncode != 0:
+                return {
+                    'success': False,
+                    'error': f"PDAL error: {result.stderr}",
+                    'point_count': 0
+                }
+            
+            if not os.path.exists(output_path):
+                return {
+                    'success': False,
+                    'error': 'Output file not created',
+                    'point_count': 0
+                }
+            
+            with laspy.open(output_path) as f:
+                point_count = f.header.point_count
+            
+            return {
+                'success': True,
+                'point_count': point_count,
+                'tiles_used': tile_files
+            }
+            
+        finally:
+            if os.path.exists(pipeline_file):
+                os.remove(pipeline_file)
+        
+    except subprocess.TimeoutExpired:
+        return {
+            'success': False,
+            'error': 'PDAL pipeline timeout',
+            'point_count': 0
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e),
+            'point_count': 0
+        }
+
+def voxel_downsample_python(input_las: str, output_las: str, voxel_size: float) -> int:
+    with laspy.open(input_las) as f:
+        las = f.read()
+    
+    x = np.array(las.x)
+    y = np.array(las.y)
+    z = np.array(las.z)
+    
+    voxel_x = np.floor(x / voxel_size).astype(np.int32)
+    voxel_y = np.floor(y / voxel_size).astype(np.int32)
+    voxel_z = np.floor(z / voxel_size).astype(np.int32)
+    
+    voxel_keys = np.column_stack([voxel_x, voxel_y, voxel_z])
+    unique_voxels, unique_indices = np.unique(voxel_keys, axis=0, return_index=True)
+    
+    las_filtered = laspy.LasData(las.header)
+    las_filtered.points = las.points[unique_indices]
+    
+    las_filtered.write(output_las)
+    
+    return len(unique_indices)
+
+def generate_bev_png(las_path: str, output_path: str, grid: Dict):
+    try:
+        with laspy.open(las_path) as f:
+            las = f.read()
+        
+        if las.header.point_count == 0:
+            if DEBUG_MODE:
+                print(f"    BEV: Empty point cloud")
+            img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+            img.save(output_path)
+            return
+        
+        x = np.array(las.x)
+        y = np.array(las.y)
+        
+        minx = grid['utm_nw'][0]
+        maxx = grid['utm_se'][0]
+        miny = grid['utm_se'][1]
+        maxy = grid['utm_nw'][1]
+        
+        px = ((x - minx) / (maxx - minx) * (BEV_RESOLUTION - 1)).astype(np.int32)
+        py = ((maxy - y) / (maxy - miny) * (BEV_RESOLUTION - 1)).astype(np.int32)
+        
+        valid = (px >= 0) & (px < BEV_RESOLUTION) & (py >= 0) & (py < BEV_RESOLUTION)
+        px = px[valid]
+        py = py[valid]
+        
+        if len(px) == 0:
+            if DEBUG_MODE:
+                print(f"    BEV: No valid points")
+            img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+            img.save(output_path)
+            return
+        
+        if BEV_USE_RGB and hasattr(las, 'red'):
+            r = np.array(las.red)[valid] // 256
+            g = np.array(las.green)[valid] // 256
+            b = np.array(las.blue)[valid] // 256
+        else:
+            r = g = b = None
+        
+        img_array = np.zeros((BEV_RESOLUTION, BEV_RESOLUTION, 4), dtype=np.uint8)
+        if not BEV_TRANSPARENT_BG:
+            img_array[:, :, :3] = 255
+            img_array[:, :, 3] = 255
+        
+        if BEV_ADAPTIVE_POINT_SIZE:
+            density_map = np.zeros((BEV_RESOLUTION, BEV_RESOLUTION), dtype=np.int32)
+            for i in range(len(px)):
+                density_map[py[i], px[i]] += 1
+            
+            density_smoothed = uniform_filter(density_map.astype(np.float32), size=BEV_DENSITY_WINDOW)
+            max_density = density_smoothed.max()
+            if max_density > 0:
+                density_normalized = density_smoothed / max_density
+            else:
+                density_normalized = density_smoothed
+        
+        for i in range(len(px)):
+            if BEV_ADAPTIVE_POINT_SIZE:
+                density_value = density_normalized[py[i], px[i]]
+                point_size = int(BEV_POINT_SIZE_MIN + (BEV_POINT_SIZE_MAX - BEV_POINT_SIZE_MIN) * (1 - density_value))
+            else:
+                point_size = BEV_POINT_SIZE
+            
+            half_size = point_size // 2
+            x_start = max(0, px[i] - half_size)
+            x_end = min(BEV_RESOLUTION, px[i] + half_size + 1)
+            y_start = max(0, py[i] - half_size)
+            y_end = min(BEV_RESOLUTION, py[i] + half_size + 1)
+            
+            if BEV_OPACITY_MODE == "fixed":
+                alpha = int(BEV_POINT_OPACITY * 255)
+            else:
+                alpha = 255
+            
+            if r is not None:
+                color = [r[i], g[i], b[i]]
+            else:
+                color = [0, 0, 0]
+            
+            img_array[y_start:y_end, x_start:x_end, :3] = color
+            img_array[y_start:y_end, x_start:x_end, 3] = alpha
+        
+        img = Image.fromarray(img_array)
+        img.save(output_path)
+        if DEBUG_MODE:
+            print(f"    BEV: Saved to {output_path}")
+        
+    except Exception as e:
+        print(f"    BEV: Error generating BEV: {e}")
+        if DEBUG_MODE:
+            import traceback
+            traceback.print_exc()
+        img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+        img.save(output_path)
+
+def generate_dsm(las_path: str, output_geotiff: str, output_png: str, grid: Dict, 
+                 resolution: int = 1024, global_min_z: float = None, global_max_z: float = None) -> Dict:
+    try:
+        from osgeo import gdal, osr
+        
+        with laspy.open(las_path) as f:
+            las = f.read()
+        
+        if las.header.point_count == 0:
+            if DEBUG_MODE:
+                print(f"    DSM: Empty point cloud")
+            return None
+        
+        x = np.array(las.x)
+        y = np.array(las.y)
+        z = np.array(las.z)
+        
+        minx = grid['utm_nw'][0]
+        maxx = grid['utm_se'][0]
+        miny = grid['utm_se'][1]
+        maxy = grid['utm_nw'][1]
+        
+        cell_size_x = (maxx - minx) / resolution
+        cell_size_y = (maxy - miny) / resolution
+        
+        px = ((x - minx) / (maxx - minx) * (resolution - 1)).astype(np.int32)
+        py = ((maxy - y) / (maxy - miny) * (resolution - 1)).astype(np.int32)
+        
+        valid = (px >= 0) & (px < resolution) & (py >= 0) & (py < resolution)
+        px = px[valid]
+        py = py[valid]
+        z = z[valid]
+        
+        if len(px) == 0:
+            if DEBUG_MODE:
+                print(f"    DSM: No valid points")
+            return None
+        
+        dsm = np.full((resolution, resolution), -9999.0, dtype=np.float32)
+        
+        half_size = DSM_POINT_SIZE // 2
+        
+        for i in range(len(px)):
+            cy, cx = py[i], px[i]
+            
+            for dy in range(-half_size, half_size + 1):
+                for dx in range(-half_size, half_size + 1):
+                    ny = cy + dy
+                    nx = cx + dx
+                    
+                    if 0 <= ny < resolution and 0 <= nx < resolution:
+                        current_z = dsm[ny, nx]
+                        if current_z == -9999.0 or z[i] > current_z:
+                            dsm[ny, nx] = z[i]
+        
+        mask = dsm != -9999.0
+        if not mask.any():
+            if DEBUG_MODE:
+                print(f"    DSM: All cells empty")
+            return None
+        
+        local_min_elevation = float(dsm[mask].min())
+        local_max_elevation = float(dsm[mask].max())
+        
+        if DSM_USE_GLOBAL_RANGE and global_min_z is not None and global_max_z is not None:
+            use_min = global_min_z
+            use_max = global_max_z
+            if DEBUG_MODE:
+                print(f"    DSM: Using global range {use_min:.2f}-{use_max:.2f}m (local: {local_min_elevation:.2f}-{local_max_elevation:.2f}m)")
+        else:
+            use_min = local_min_elevation
+            use_max = local_max_elevation
+            if DEBUG_MODE:
+                print(f"    DSM: Using local range {use_min:.2f}-{use_max:.2f}m")
+        
+        driver = gdal.GetDriverByName('GTiff')
+        dataset = driver.Create(output_geotiff, resolution, resolution, 1, gdal.GDT_Float32)
+        
+        geotransform = (minx, cell_size_x, 0, maxy, 0, -cell_size_y)
+        dataset.SetGeoTransform(geotransform)
+        
+        srs = osr.SpatialReference()
+        epsg_code = int(grid.get('utm_crs', 'EPSG:27700').split(':')[1]) if 'utm_crs' in grid else 27700
+        srs.ImportFromEPSG(epsg_code)
+        dataset.SetProjection(srs.ExportToWkt())
+        
+        band = dataset.GetRasterBand(1)
+        band.SetNoDataValue(-9999.0)
+        band.WriteArray(dsm)
+        
+        dataset.FlushCache()
+        dataset = None
+        
+        dsm_normalized = np.where(dsm == -9999.0, 0, 
+                                   np.clip((dsm - use_min) / (use_max - use_min), 0, 1) * 65535)
+        dsm_img = dsm_normalized.astype(np.uint16)
+        
+        img = Image.fromarray(dsm_img)
+        img.save(output_png)
+        
+        if DEBUG_MODE:
+            print(f"    DSM: GeoTIFF and PNG saved")
+        
+        return {
+            'min_elevation': local_min_elevation,
+            'max_elevation': local_max_elevation,
+            'global_min_used': use_min,
+            'global_max_used': use_max,
+            'resolution': resolution,
+            'cell_size_x': cell_size_x,
+            'cell_size_y': cell_size_y
+        }
+        
+    except ImportError:
+        print(f"    DSM: Error - GDAL not installed. Install with: pip install gdal")
+        return None
+    except Exception as e:
+        print(f"    DSM: Error - {e}")
+        if DEBUG_MODE:
+            import traceback
+            traceback.print_exc()
+        return None
+
+def check_grid_already_processed(grid_id: int, output_dir: str) -> Dict:
+    file_ext = ".laz" if OUTPUT_COMPRESSED else ".las"
+    output_las = os.path.join(output_dir, f"grid_{grid_id:06d}{file_ext}")
+    output_bev = os.path.join(output_dir, f"grid_{grid_id:06d}_bev.png")
+    output_log = os.path.join(output_dir, f"grid_{grid_id:06d}.json")
+    
+    required_files = [output_las, output_bev, output_log]
+    
+    if GENERATE_DSM:
+        output_dsm_tif = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.tif")
+        output_dsm_png = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.png")
+        required_files.extend([output_dsm_tif, output_dsm_png])
+    
+    if all(os.path.exists(f) for f in required_files):
+        try:
+            with open(output_log, 'r') as f:
+                log_data = json.load(f)
+            
+            if all(os.path.getsize(f) > 0 for f in required_files):
+                return {
+                    'grid_id': grid_id,
+                    'status': 'success',
+                    'point_count': log_data.get('point_count', 0),
+                    'tiles_used': len(log_data.get('tiles_used', [])),
+                    'resumed': True
+                }
+        except Exception as e:
+            if DEBUG_MODE:
+                tqdm.write(f"  DEBUG: Failed to read log for grid {grid_id}: {e}")
+            return None
+    
+    return None
+
+def process_single_grid(grid: Dict, tile_bounds: Dict, tile_dir: str, output_dir: str, 
+                       utm_crs: str, global_min_z: float = None, global_max_z: float = None) -> Dict:
+    grid_id = grid['id']
+    
+    if RESUME_MODE and not FORCE_REPROCESS:
+        existing_result = check_grid_already_processed(grid_id, output_dir)
+        if existing_result:
+            return existing_result
+    
+    if DEBUG_MODE:
+        print(f"\n  DEBUG: Grid bounds UTM: NW={grid['utm_nw']}, SE={grid['utm_se']}")
+    
+    overlapping_tiles = find_overlapping_tiles(grid, tile_bounds)
+    
+    if DEBUG_MODE:
+        print(f"  DEBUG: Found {len(overlapping_tiles)} overlapping tiles: {overlapping_tiles[:3]}...")
+    
+    if not overlapping_tiles:
+        return {
+            'grid_id': grid_id,
+            'status': 'no_tiles',
+            'message': 'No overlapping tiles found'
+        }
+    
+    file_ext = ".laz" if OUTPUT_COMPRESSED else ".las"
+    output_las = os.path.join(output_dir, f"grid_{grid_id:06d}{file_ext}")
+    output_bev = os.path.join(output_dir, f"grid_{grid_id:06d}_bev.png")
+    output_log = os.path.join(output_dir, f"grid_{grid_id:06d}.json")
+    
+    crop_result = crop_las_with_pdal(overlapping_tiles, grid, output_las, tile_dir)
+    
+    if not crop_result['success']:
+        error_msg = crop_result.get('error', 'Unknown error')
+        return {
+            'grid_id': grid_id,
+            'status': 'failed',
+            'message': error_msg,
+            'tiles_checked': overlapping_tiles
+        }
+    
+    if crop_result['point_count'] == 0:
+        return {
+            'grid_id': grid_id,
+            'status': 'empty',
+            'message': 'No points in cropped area',
+            'tiles_used': overlapping_tiles
+        }
+    
+    if PYTHON_VOXEL_DEDUP and len(overlapping_tiles) > 1:
+        temp_output = output_las + ".temp"
+        os.rename(output_las, temp_output)
+        final_count = voxel_downsample_python(temp_output, output_las, VOXEL_SIZE)
+        os.remove(temp_output)
+        crop_result['point_count'] = final_count
+        if DEBUG_MODE:
+            print(f"  DEBUG: Python voxel downsampled to {final_count} points")
+    
+    generate_bev_png(output_las, output_bev, grid)
+    
+    dsm_info = None
+    if GENERATE_DSM:
+        output_dsm_tif = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.tif")
+        output_dsm_png = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.png")
+        grid_with_crs = grid.copy()
+        grid_with_crs['utm_crs'] = utm_crs
+        dsm_info = generate_dsm(output_las, output_dsm_tif, output_dsm_png, grid_with_crs, 
+                               DSM_RESOLUTION, global_min_z, global_max_z)
+    
+    log_data = {
+        'grid_id': grid_id,
+        'row': grid['row'],
+        'col': grid['col'],
+        'utm_nw': grid['utm_nw'],
+        'utm_se': grid['utm_se'],
+        'wgs84_nw': grid['wgs84_nw'],
+        'wgs84_se': grid['wgs84_se'],
+        'point_count': crop_result['point_count'],
+        'tiles_used': crop_result['tiles_used'],
+        'output_files': {
+            'las': os.path.basename(output_las),
+            'bev': os.path.basename(output_bev)
+        }
+    }
+    
+    if GENERATE_DSM and dsm_info:
+        log_data['elevation'] = {
+            'local_min_elevation': dsm_info['min_elevation'],
+            'local_max_elevation': dsm_info['max_elevation'],
+            'global_min_used': dsm_info['global_min_used'],
+            'global_max_used': dsm_info['global_max_used'],
+            'elevation_range': dsm_info['max_elevation'] - dsm_info['min_elevation']
+        }
+        log_data['output_files']['dsm_geotiff'] = os.path.basename(output_dsm_tif)
+        log_data['output_files']['dsm_png'] = os.path.basename(output_dsm_png)
+    
+    with open(output_log, 'w') as f:
+        json.dump(log_data, f, indent=2)
+    
+    return {
+        'grid_id': grid_id,
+        'status': 'success',
+        'point_count': crop_result['point_count'],
+        'tiles_used': len(overlapping_tiles)
+    }
+
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    if os.path.abspath(OUTPUT_DIR) == os.path.abspath(TILE_DIR):
+        print("ERROR: OUTPUT_DIR and TILE_DIR must be different!")
+        print(f"OUTPUT_DIR: {os.path.abspath(OUTPUT_DIR)}")
+        print(f"TILE_DIR: {os.path.abspath(TILE_DIR)}")
+        print("Please set OUTPUT_DIR to a different directory to avoid confusion.")
+        return
+    
+    print("="*60)
+    print("STEP 1: Reading LAS boundaries and generating grids")
+    print("="*60)
+    
+    polygons, utm_crs = parse_las_boundaries(INPUT_LAS_FILES, TILE_DIR)
+    
+    transformer_to_utm = Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
+    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    
+    grids = generate_grids(polygons, GRID_SIZE, GRID_SPACING, 
+                          utm_crs, transformer_to_utm, transformer_to_wgs)
+    
+    print("\n" + "="*60)
+    print("STEP 2: Generating KML visualization")
+    print("="*60)
+    
+    kml_output = os.path.join(OUTPUT_DIR, "output_grids.kml")
+    create_kml(grids, kml_output)
+    
+    print("\n" + "="*60)
+    print("STEP 3: Scanning all LAS tiles")
+    print("="*60)
+    
+    tile_bounds = get_tile_bounds(TILE_DIR)
+    
+    if not tile_bounds:
+        print("ERROR: No valid tiles found!")
+        return
+    
+    global_min_z = None
+    global_max_z = None
+    
+    if GENERATE_DSM and DSM_USE_GLOBAL_RANGE:
+        global_min_z, global_max_z = scan_global_elevation_range(TILE_DIR, tile_bounds)
+    
+    print("\n" + "="*60)
+    print("STEP 4: Processing grids and generating outputs")
+    print("="*60)
+    
+    grids_to_process = grids[:TEST_MODE_LIMIT] if TEST_MODE_LIMIT else grids
+    
+    if TEST_MODE_LIMIT:
+        print(f"\n*** TEST MODE: Processing only first {len(grids_to_process)} grids ***\n")
+    else:
+        print(f"\nProcessing all {len(grids_to_process)} grids\n")
+    
+    if RESUME_MODE and not FORCE_REPROCESS:
+        print(f"*** RESUME MODE: Skipping already processed grids ***\n")
+    elif FORCE_REPROCESS:
+        print(f"*** FORCE REPROCESS: Reprocessing all grids ***\n")
+    
+    if GENERATE_DSM:
+        print(f"DSM Configuration:")
+        print(f"  Resolution: {DSM_RESOLUTION}x{DSM_RESOLUTION}")
+        print(f"  Point size: {DSM_POINT_SIZE}x{DSM_POINT_SIZE} pixels per point")
+        print(f"  Use global range: {DSM_USE_GLOBAL_RANGE}")
+        if DSM_USE_GLOBAL_RANGE and global_min_z is not None:
+            print(f"  Global range: {global_min_z:.2f}m - {global_max_z:.2f}m\n")
+    
+    results = []
+    resumed_count = 0
+    processed_count = 0
+    
+    with tqdm(total=len(grids_to_process), desc="Processing grids", unit="grid") as pbar:
+        for i, grid in enumerate(grids_to_process):
+            grid_id = grid['id']
+            pbar.set_description(f"Processing grid {grid_id:06d}")
+            
+            result = process_single_grid(grid, tile_bounds, TILE_DIR, OUTPUT_DIR, utm_crs, 
+                                        global_min_z, global_max_z)
+            results.append(result)
+            
+            if result.get('resumed', False):
+                resumed_count += 1
+                tqdm.write(f"Grid {grid_id:06d}: RESUMED - {result.get('point_count', 0):,} points (skipped)")
+            else:
+                processed_count += 1
+                if result['status'] == 'failed':
+                    tqdm.write(f"Grid {grid_id:06d}: FAILED - {result.get('message', 'Unknown error')}")
+                elif result['status'] == 'success':
+                    tqdm.write(f"Grid {grid_id:06d}: SUCCESS - {result.get('point_count', 0):,} points from {result.get('tiles_used', 0)} tiles")
+                elif result['status'] == 'empty':
+                    tqdm.write(f"Grid {grid_id:06d}: EMPTY - No points in area")
+                elif result['status'] == 'no_tiles':
+                    tqdm.write(f"Grid {grid_id:06d}: NO TILES - No overlapping tiles found")
+            
+            pbar.update(1)
+    
+    print("\n" + "="*60)
+    print("STEP 5: Generating final summary")
+    print("="*60)
+    
+    summary = {
+        'config': {
+            'grid_size_m': GRID_SIZE,
+            'grid_spacing_m': GRID_SPACING,
+            'voxel_size_m': VOXEL_SIZE,
+            'use_voxel_filter': USE_VOXEL_FILTER,
+            'python_voxel_dedup': PYTHON_VOXEL_DEDUP,
+            'output_compressed': OUTPUT_COMPRESSED,
+            'bev_point_size': BEV_POINT_SIZE,
+            'bev_transparent_bg': BEV_TRANSPARENT_BG,
+            'bev_use_rgb': BEV_USE_RGB,
+            'bev_point_opacity': BEV_POINT_OPACITY,
+            'bev_opacity_mode': BEV_OPACITY_MODE,
+            'bev_adaptive_point_size': BEV_ADAPTIVE_POINT_SIZE,
+            'bev_point_size_min': BEV_POINT_SIZE_MIN,
+            'bev_point_size_max': BEV_POINT_SIZE_MAX,
+            'bev_density_window': BEV_DENSITY_WINDOW,
+            'generate_dsm': GENERATE_DSM,
+            'dsm_resolution': DSM_RESOLUTION,
+            'dsm_point_size': DSM_POINT_SIZE,
+            'dsm_use_global_range': DSM_USE_GLOBAL_RANGE,
+            'global_elevation_range': {
+                'min': global_min_z,
+                'max': global_max_z
+            } if global_min_z is not None else None,
+            'utm_crs': utm_crs,
+            'test_mode': TEST_MODE_LIMIT is not None,
+            'test_mode_limit': TEST_MODE_LIMIT,
+            'resume_mode': RESUME_MODE,
+            'force_reprocess': FORCE_REPROCESS
+        },
+        'statistics': {
+            'total_grids_generated': len(grids),
+            'grids_processed': len(grids_to_process),
+            'newly_processed': processed_count,
+            'resumed_skipped': resumed_count,
+            'successful': sum(1 for r in results if r['status'] == 'success'),
+            'failed': sum(1 for r in results if r['status'] == 'failed'),
+            'empty': sum(1 for r in results if r['status'] == 'empty'),
+            'no_tiles': sum(1 for r in results if r['status'] == 'no_tiles')
+        },
+        'results': results
+    }
+    
+    summary_path = os.path.join(OUTPUT_DIR, "processing_summary.json")
+    with open(summary_path, 'w') as f:
+        json.dump(summary, f, indent=2)
+    
+    print(f"\nSummary saved to: {summary_path}")
+    print(f"KML visualization: {kml_output}")
+    if TEST_MODE_LIMIT:
+        print(f"Test mode: Processed {len(grids_to_process)}/{len(grids)} grids")
+    if RESUME_MODE and resumed_count > 0:
+        print(f"Resumed: Skipped {resumed_count} already processed grids")
+        print(f"Newly processed: {processed_count} grids")
+    print(f"Success: {summary['statistics']['successful']}/{len(grids_to_process)}")
+    print("\nProcessing complete!")
+
+if __name__ == "__main__":
+    main()

scripts/make_splits.py

@@ -0,0 +1,65 @@
+#!/usr/bin/env python3
+"""
+Generate the exact train / val / test split used by City3D-MultiGen.
+
+This replicates the deterministic split from the training dataloader:
+
+    all_files = sorted(list(Path(data_root).glob('**/grid_*.las')))
+    n_train = int(n_total * train_split)
+    n_val   = int(n_total * val_split)
+    train = all_files[:n_train]
+    val   = all_files[n_train:n_train + n_val]
+    test  = all_files[n_train + n_val:]
+
+There is **no shuffling and no random seed** — the split is a sequential slice of
+the path-sorted tile list. Running this on the same assembled `output/` directory
+therefore reproduces exactly the split used to produce the paper's results.
+
+Because tile filenames (`grid_<id>`) are ordered along the spatial grid, this
+path-sorted sequential split yields spatially contiguous train/val/test regions.
+
+Usage:
+    python scripts/make_splits.py \
+        --data_root /path/to/output \
+        --train_split 0.8 --val_split 0.1 \
+        --out_dir metadata/splits
+"""
+import argparse
+from pathlib import Path
+
+
+def main():
+    ap = argparse.ArgumentParser(description="Reproduce the City3D-MultiGen tile split.")
+    ap.add_argument("--data_root", required=True,
+                    help="Directory containing the assembled tiles (grid_*/grid_*.las).")
+    ap.add_argument("--train_split", type=float, default=0.8)
+    ap.add_argument("--val_split", type=float, default=0.1)
+    ap.add_argument("--out_dir", default="metadata/splits")
+    args = ap.parse_args()
+
+    # Identical to the training dataloader: recursive glob, sorted by path.
+    all_files = sorted(list(Path(args.data_root).glob("**/grid_*.las")))
+    n = len(all_files)
+    if n == 0:
+        raise SystemExit(f"No grid_*.las files found under {args.data_root}")
+
+    n_train = int(n * args.train_split)
+    n_val = int(n * args.val_split)
+    splits = {
+        "train": all_files[:n_train],
+        "val":   all_files[n_train:n_train + n_val],
+        "test":  all_files[n_train + n_val:],
+    }
+
+    out = Path(args.out_dir)
+    out.mkdir(parents=True, exist_ok=True)
+    for name, files in splits.items():
+        ids = [f.stem for f in files]          # e.g. "grid_120256"
+        (out / f"{name}.txt").write_text("\n".join(ids) + "\n")
+        print(f"{name:5s}: {len(ids):6d} tiles -> {out / (name + '.txt')}")
+    print(f"total: {n} tiles "
+          f"(train={n_train}, val={n_val}, test={n - n_train - n_val})")
+
+
+if __name__ == "__main__":
+    main()

scripts/melbourne/Obtain_corresponding_map_signed.py

@@ -0,0 +1,490 @@
+"""Fetch per-tile imagery and derive semantic masks for the City3D-MultiGen
+reconstruction pipeline (GridFlow, ECCV 2026).
+
+Pipeline role:
+    For each 150 m tile this script downloads two co-registered rasters from the
+    signed Google Maps Static API -- a satellite image and a custom-styled
+    "roadmap" image -- then parses the styled roadmap into per-class binary
+    semantic masks using fixed color thresholds.
+
+Inputs:
+    Tile geo-extents read from per-tile JSON metadata files (``wgs84_nw`` /
+    ``wgs84_se`` lon/lat corners). These JSONs can optionally be generated first
+    from an area bounding box (``--nw`` / ``--se``).
+
+Outputs (written next to each JSON, keyed by the tile base name):
+    ``<base>_sat.png``  satellite crop, ``<base>_map.png`` styled roadmap crop,
+    and six mask images ``<base>_<Class>.png`` for the classes Building,
+    RoadSurface, Railway, VegetationLand, UrbanLand and WaterSurface.
+
+Key steps:
+    1. Build the Static Maps URL, sign it with the URL-signing secret (HMAC-SHA1).
+    2. Fetch satellite and styled-roadmap tiles, then crop to the exact extent.
+    3. Parse the roadmap crop into masks via the CLASS_COLORS_HEX color thresholds
+       (exact match per class; tolerant match plus 1 px dilation for Railway).
+
+Required environment variables (each may be overridden by a CLI flag):
+    GOOGLE_MAPS_API_KEY              Static Maps API key.
+    GOOGLE_MAPS_URL_SIGNING_SECRET  URL-signing secret for the signed requests.
+    GOOGLE_MAPS_STYLE_MAP_ID        Map ID of the custom roadmap style.
+
+Note: the custom Google map style referenced by GOOGLE_MAPS_STYLE_MAP_ID is not
+distributed here; you must recreate it in the Google Cloud console so the styled
+roadmap colors match the CLASS_COLORS_HEX values used for mask parsing.
+"""
+
+import os
+import json
+import math
+import io
+import time
+import argparse
+import requests
+from requests.adapters import HTTPAdapter
+from urllib3.util.retry import Retry
+from PIL import Image
+import numpy as np
+from tqdm import tqdm
+import hashlib
+import hmac
+import base64
+import urllib.parse as urlparse
+from pyproj import Transformer
+
+CLASS_COLORS_HEX = {
+    "RoadSurface":      ["1e1e1e"],
+    "Building":         ["ff0000"],
+    "Railway":          ["0073ff"],
+    "VegetationLand":   ["c3f1d5"],
+    "UrbanLand":        ["f5f0e5", "d3f8e2"],
+    "WaterSurface":     ["90daee"],
+}
+
+def hex_to_rgb(hex_str):
+    h = hex_str.strip().lower()
+    return (
+        int(h[0:2], 16),
+        int(h[2:4], 16),
+        int(h[4:6], 16),
+    )
+
+CLASS_COLORS_RGB = {
+    class_name: [hex_to_rgb(code) for code in hex_list]
+    for class_name, hex_list in CLASS_COLORS_HEX.items()
+}
+
+def sign_url(input_url, secret):
+    if not input_url or not secret:
+        raise Exception("Both input_url and secret are required")
+
+    url = urlparse.urlparse(input_url)
+    url_to_sign = url.path + "?" + url.query
+    decoded_key = base64.urlsafe_b64decode(secret)
+    signature = hmac.new(decoded_key, str.encode(url_to_sign), hashlib.sha1)
+    encoded_signature = base64.urlsafe_b64encode(signature.digest())
+    original_url = url.scheme + "://" + url.netloc + url.path + "?" + url.query
+    return original_url + "&signature=" + encoded_signature.decode()
+
+def dilate_mask_1px(mask_arr):
+    h, w = mask_arr.shape
+    out = np.zeros((h, w), dtype=np.uint8)
+    ys, xs = np.nonzero(mask_arr > 0)
+    for y, x in zip(ys, xs):
+        y0 = max(y - 1, 0)
+        y1 = min(y + 1, h - 1)
+        x0 = max(x - 1, 0)
+        x1 = min(x + 1, w - 1)
+        out[y0:y1+1, x0:x1+1] = 255
+    return out
+
+def match_mask_exact(arr, rgb_triplet):
+    r, g, b = rgb_triplet
+    return (
+        (arr[:, :, 0] == r) &
+        (arr[:, :, 1] == g) &
+        (arr[:, :, 2] == b)
+    )
+
+def channel_bounds_with_margin(channel_val, margin_ratio):
+    low = int(round(channel_val * (1.0 - margin_ratio)))
+    high = int(round(channel_val * (1.0 + margin_ratio)))
+    if low < 0:
+        low = 0
+    if high > 255:
+        high = 255
+    return low, high
+
+def match_mask_tolerant(arr, rgb_triplet, margin_ratio):
+    r, g, b = rgb_triplet
+    rl, rh = channel_bounds_with_margin(r, margin_ratio)
+    gl, gh = channel_bounds_with_margin(g, margin_ratio)
+    bl, bh = channel_bounds_with_margin(b, margin_ratio)
+    return (
+        (arr[:, :, 0] >= rl) & (arr[:, :, 0] <= rh) &
+        (arr[:, :, 1] >= gl) & (arr[:, :, 1] <= gh) &
+        (arr[:, :, 2] >= bl) & (arr[:, :, 2] <= bh)
+    )
+
+def generate_masks_from_roadmap(crop_road_img, base_output_path_no_ext):
+    rgb = crop_road_img.convert("RGB")
+    arr = np.array(rgb, dtype=np.uint8)
+
+    for class_name, rgb_list in CLASS_COLORS_RGB.items():
+        class_mask_total = np.zeros(arr.shape[:2], dtype=np.uint8)
+
+        for rgb_triplet in rgb_list:
+            if class_name == "Railway":
+                match = match_mask_tolerant(arr, rgb_triplet, margin_ratio=0.1)
+            else:
+                match = match_mask_exact(arr, rgb_triplet)
+            class_mask_total[match] = 255
+
+        if class_name == "Railway":
+            class_mask_total = dilate_mask_1px(class_mask_total)
+
+        out_path = f"{base_output_path_no_ext}_{class_name}.png"
+        img = Image.fromarray(class_mask_total)
+        img.save(out_path)
+
+def save_bbox_satellite_and_roadmap(
+    north_lat,
+    west_lon,
+    south_lat,
+    east_lon,
+    out_path_sat,
+    out_path_road,
+    api_key,
+    url_signing_secret,
+    style_map_id
+):
+    def mercator_project(lon_deg, lat_deg, zoom):
+        scale = 256 * (2 ** zoom)
+        x = (lon_deg + 180.0) / 360.0 * scale
+        lat_rad = math.radians(lat_deg)
+        y = (1.0 - math.log(math.tan(lat_rad) + 1.0 / math.cos(lat_rad)) / math.pi) / 2.0 * scale
+        return x, y
+
+    def bbox_center(n_lat, s_lat, w_lon, e_lon):
+        return (
+            (n_lat + s_lat) / 2.0,
+            (w_lon + e_lon) / 2.0
+        )
+
+    def download_static(center_lat, center_lon, zoom, size_px, maptype, api_key, url_signing_secret, style_map_id=None):
+        session = requests.Session()
+        retry_strategy = Retry(
+            total=5,
+            backoff_factor=2,
+            status_forcelist=[429, 500, 502, 503, 504],
+            allowed_methods=["GET"]
+        )
+        adapter = HTTPAdapter(max_retries=retry_strategy)
+        session.mount("https://", adapter)
+        session.mount("http://", adapter)
+        
+        base = "https://maps.googleapis.com/maps/api/staticmap"
+        params = {
+            "center": f"{center_lat},{center_lon}",
+            "zoom": str(18),
+            "size": f"{size_px}x{size_px}",
+            "format": "png",
+            "key": api_key,
+        }
+        if maptype == "satellite":
+            params["maptype"] = "satellite"
+        else:
+            params["map_id"] = style_map_id
+        
+        query_string = "&".join([f"{k}={urlparse.quote(str(v), safe='')}" for k, v in params.items()])
+        unsigned_url = f"{base}?{query_string}"
+        signed_url = sign_url(unsigned_url, url_signing_secret)
+        
+        max_retries = 3
+        for attempt in range(max_retries):
+            try:
+                resp = session.get(signed_url, timeout=30)
+                resp.raise_for_status()
+                time.sleep(0.5)
+                return Image.open(io.BytesIO(resp.content)).convert("RGBA")
+            except (requests.exceptions.ConnectionError, 
+                    requests.exceptions.Timeout,
+                    requests.exceptions.RequestException) as e:
+                if attempt < max_retries - 1:
+                    wait_time = (attempt + 1) * 5
+                    print(f"\nRequest failed, retrying in {wait_time} seconds...")
+                    time.sleep(wait_time)
+                else:
+                    raise
+
+    def crop_bbox_from_image(img, zoom, img_px, center_lat, center_lon,
+                             n_lat, s_lat, w_lon, e_lon):
+        center_x, center_y = mercator_project(center_lon, center_lat, zoom)
+        img_left_world  = center_x - img_px / 2.0
+        img_top_world   = center_y - img_px / 2.0
+
+        w_x, _ = mercator_project(w_lon, center_lat, zoom)
+        e_x, _ = mercator_project(e_lon, center_lat, zoom)
+        _, n_y = mercator_project(center_lon, n_lat, zoom)
+        _, s_y = mercator_project(center_lon, s_lat, zoom)
+
+        xmin = w_x - img_left_world
+        xmax = e_x - img_left_world
+        ymin = n_y - img_top_world
+        ymax = s_y - img_top_world
+
+        box = (
+            int(round(xmin)),
+            int(round(ymin)),
+            int(round(xmax)),
+            int(round(ymax)),
+        )
+
+        box = (
+            max(0, box[0]),
+            max(0, box[1]),
+            min(img_px, box[2]),
+            min(img_px, box[3]),
+        )
+
+        return img.crop(box)
+
+    zoom = 18
+    img_px = 600
+
+    center_lat, center_lon = bbox_center(north_lat, south_lat, west_lon, east_lon)
+
+    img_sat = download_static(center_lat, center_lon, zoom, img_px, "satellite", api_key, url_signing_secret, style_map_id=None)
+    img_road = download_static(center_lat, center_lon, zoom, img_px, "roadmap", api_key, url_signing_secret, style_map_id=style_map_id)
+
+    crop_sat = crop_bbox_from_image(
+        img_sat, zoom, img_px, center_lat, center_lon,
+        north_lat, south_lat, west_lon, east_lon
+    )
+    crop_road = crop_bbox_from_image(
+        img_road, zoom, img_px, center_lat, center_lon,
+        north_lat, south_lat, west_lon, east_lon
+    )
+
+    crop_sat.save(out_path_sat)
+    crop_road.save(out_path_road)
+
+    return crop_sat, crop_road
+
+def process_folder(
+    folder_path,
+    api_key,
+    url_signing_secret,
+    style_map_id
+):
+    json_files = [f for f in os.listdir(folder_path) if f.lower().endswith(".json")]
+    
+    skipped = 0
+    failed = 0
+    failed_files = []
+    
+    for filename in tqdm(json_files, desc="Processing files", unit="file"):
+        try:
+            json_path = os.path.join(folder_path, filename)
+            base_name = os.path.splitext(filename)[0]
+
+            out_sat = os.path.join(folder_path, base_name + "_sat.png")
+            out_map = os.path.join(folder_path, base_name + "_map.png")
+            
+            expected_files = [out_sat, out_map]
+            for class_name in CLASS_COLORS_RGB.keys():
+                expected_files.append(os.path.join(folder_path, f"{base_name}_{class_name}.png"))
+            
+            if all(os.path.exists(f) for f in expected_files):
+                skipped += 1
+                continue
+
+            with open(json_path, "r", encoding="utf-8") as f:
+                data = json.load(f)
+
+            wgs84_nw = data["wgs84_nw"]
+            wgs84_se = data["wgs84_se"]
+
+            west_lon  = float(wgs84_nw[0])
+            north_lat = float(wgs84_nw[1])
+            east_lon  = float(wgs84_se[0])
+            south_lat = float(wgs84_se[1])
+
+            crop_sat, crop_road = save_bbox_satellite_and_roadmap(
+                north_lat = north_lat,
+                west_lon  = west_lon,
+                south_lat = south_lat,
+                east_lon  = east_lon,
+                out_path_sat  = out_sat,
+                out_path_road = out_map,
+                api_key       = api_key,
+                url_signing_secret = url_signing_secret,
+                style_map_id  = style_map_id
+            )
+
+            base_mask_prefix = os.path.join(folder_path, base_name)
+            generate_masks_from_roadmap(crop_road, base_mask_prefix)
+            
+        except Exception as e:
+            failed += 1
+            failed_files.append(filename)
+            print(f"\nFailed to process {filename}: {str(e)}")
+            continue
+    
+    print(f"\nProcessing complete!")
+    if skipped > 0:
+        print(f"Skipped {skipped} already processed files")
+    if failed > 0:
+        print(f"Failed to process {failed} files:")
+        for f in failed_files:
+            print(f"  - {f}")
+
+def make_utm_transformers(center_lat, center_lon):
+    zone = int((center_lon + 180) / 6) + 1
+    epsg = (32600 if center_lat >= 0 else 32700) + zone
+    to_utm = Transformer.from_crs("EPSG:4326", f"EPSG:{epsg}", always_xy=True)
+    to_wgs = Transformer.from_crs(f"EPSG:{epsg}", "EPSG:4326", always_xy=True)
+    return to_utm, to_wgs, epsg
+
+
+def generate_tile_metadata_for_area(
+    nw_lat,
+    nw_lon,
+    se_lat,
+    se_lon,
+    output_folder,
+    tile_size_m=150.0,
+    grid_step_m=20.0,
+    grid_id_start=0,
+    overwrite=False,
+):
+    """Tile a lat/lon bounding box into JSON metadata files compatible with
+    the Melbourne dataset format (utm_nw / utm_se / wgs84_nw / wgs84_se / row / col).
+
+    Args:
+        nw_lat, nw_lon: northwest corner of the area (degrees).
+        se_lat, se_lon: southeast corner of the area (degrees).
+        output_folder: where JSON files will be written.
+        tile_size_m: edge length of each tile in meters (default 150, matches dataset).
+        grid_step_m: spacing between adjacent tile centers (default 20, matches dataset).
+        grid_id_start: starting grid_id for filenames (grid_NNNNNN).
+        overwrite: if False, existing JSONs are kept.
+
+    Returns:
+        list of file paths to the generated JSON files.
+    """
+    os.makedirs(output_folder, exist_ok=True)
+
+    center_lat = (nw_lat + se_lat) / 2.0
+    center_lon = (nw_lon + se_lon) / 2.0
+    to_utm, to_wgs, epsg = make_utm_transformers(center_lat, center_lon)
+
+    nw_x, nw_y = to_utm.transform(nw_lon, nw_lat)
+    se_x, se_y = to_utm.transform(se_lon, se_lat)
+    x_min, x_max = min(nw_x, se_x), max(nw_x, se_x)
+    y_min, y_max = min(nw_y, se_y), max(nw_y, se_y)
+
+    half = tile_size_m / 2.0
+    n_cols = max(1, int(math.ceil((x_max - x_min) / grid_step_m)))
+    n_rows = max(1, int(math.ceil((y_max - y_min) / grid_step_m)))
+
+    print(f"Area UTM (EPSG:{epsg}): x=[{x_min:.1f},{x_max:.1f}] "
+          f"y=[{y_min:.1f},{y_max:.1f}]")
+    print(f"Extent: {x_max-x_min:.0f}m x {y_max-y_min:.0f}m  "
+          f"-> grid {n_rows} rows x {n_cols} cols  "
+          f"({n_rows*n_cols} tiles, step={grid_step_m}m, tile={tile_size_m}m)")
+
+    written = []
+    grid_id = grid_id_start
+    for row in range(n_rows):
+        cy = y_max - half - row * grid_step_m
+        for col in range(n_cols):
+            cx = x_min + half + col * grid_step_m
+
+            utm_nw = [cx - half, cy + half]
+            utm_se = [cx + half, cy - half]
+            nw_lon_wgs, nw_lat_wgs = to_wgs.transform(utm_nw[0], utm_nw[1])
+            se_lon_wgs, se_lat_wgs = to_wgs.transform(utm_se[0], utm_se[1])
+
+            base_name = f"grid_{grid_id:06d}"
+            out_path = os.path.join(output_folder, base_name + ".json")
+            if os.path.exists(out_path) and not overwrite:
+                grid_id += 1
+                written.append(out_path)
+                continue
+
+            meta = {
+                "grid_id": grid_id,
+                "row": row,
+                "col": col,
+                "utm_nw": utm_nw,
+                "utm_se": utm_se,
+                "wgs84_nw": [nw_lon_wgs, nw_lat_wgs],
+                "wgs84_se": [se_lon_wgs, se_lat_wgs],
+                "utm_epsg": epsg,
+                "elevation": {
+                    "local_min_elevation": 0.0,
+                    "local_max_elevation": 0.0,
+                    "global_min_used": -20.0,
+                    "global_max_used": 302.0,
+                    "elevation_range": 0.0,
+                },
+            }
+            with open(out_path, "w", encoding="utf-8") as f:
+                json.dump(meta, f, indent=2)
+            written.append(out_path)
+            grid_id += 1
+
+    print(f"Wrote {len(written)} tile JSONs to {output_folder}")
+    return written
+
+
+if __name__ == "__main__":
+    parser = argparse.ArgumentParser(
+        description="Fetch satellite + styled-roadmap tiles and class masks "
+                    "for an area (DSM/point-cloud not generated)."
+    )
+    parser.add_argument("--folder", default="./output",
+                        help="Output folder. If --nw/--se given, JSONs are "
+                             "created here first; otherwise existing JSONs "
+                             "in this folder are processed.")
+    parser.add_argument("--nw", default=None,
+                        help="Northwest corner 'lat,lon' (e.g. -37.778,144.932).")
+    parser.add_argument("--se", default=None,
+                        help="Southeast corner 'lat,lon' (e.g. -37.785,144.948).")
+    parser.add_argument("--tile_size", type=float, default=150.0,
+                        help="Tile edge length in meters (default 150).")
+    parser.add_argument("--grid_step", type=float, default=20.0,
+                        help="Spacing between tile centers in meters "
+                             "(default 20 = dense dataset grid). Use a value "
+                             "close to --tile_size for non-overlapping coverage "
+                             "with far fewer API calls.")
+    parser.add_argument("--grid_id_start", type=int, default=0)
+    parser.add_argument("--api_key",
+                        default=os.environ.get("GOOGLE_MAPS_API_KEY"))
+    parser.add_argument("--url_signing_secret",
+                        default=os.environ.get("GOOGLE_MAPS_URL_SIGNING_SECRET"))
+    parser.add_argument("--style_map_id",
+                        default=os.environ.get("GOOGLE_MAPS_STYLE_MAP_ID"))
+    args = parser.parse_args()
+
+    if (args.nw is None) ^ (args.se is None):
+        parser.error("--nw and --se must be provided together.")
+
+    if args.nw and args.se:
+        nw_lat, nw_lon = [float(v) for v in args.nw.split(",")]
+        se_lat, se_lon = [float(v) for v in args.se.split(",")]
+        generate_tile_metadata_for_area(
+            nw_lat=nw_lat, nw_lon=nw_lon,
+            se_lat=se_lat, se_lon=se_lon,
+            output_folder=args.folder,
+            tile_size_m=args.tile_size,
+            grid_step_m=args.grid_step,
+            grid_id_start=args.grid_id_start,
+        )
+
+    process_folder(
+        args.folder,
+        args.api_key,
+        args.url_signing_secret,
+        args.style_map_id,
+    )

scripts/melbourne/export_las_blocks_noKML.py

@@ -0,0 +1,1047 @@
+"""
+Melbourne LAS tiler for the City3D-MultiGen reconstruction pipeline.
+
+Role in pipeline:
+    This script partitions Melbourne's source airborne LiDAR (distributed as LAS/LAZ)
+    into regular ground-plane tiles and produces the per-tile point cloud, DSM, and BEV
+    products consumed by the downstream City3D-MultiGen dataset (the GridFlow training
+    corpus). It is the Melbourne counterpart of the per-city tilers.
+
+Inputs:
+    - One or more source LAS/LAZ files in TILE_DIR (auto-scanned when INPUT_LAS_FILES
+      is None, otherwise the explicitly listed files). The CRS is read from the LAS
+      headers (falling back to UTM auto-detection from coordinates).
+
+Processing steps:
+    1. Read each input file's XY extent and build one WGS84 polygon per file.
+    2. Generate a regular grid of GRID_SIZE (150 m) tiles, keeping only tiles whose
+       center falls inside an input polygon; spacing yields overlapping tiles.
+    3. Emit a KML visualization of the grid.
+    4. Scan all tiles for bounds and (optionally) a global elevation range so DSMs
+       share a consistent vertical scale.
+    5. For each grid tile: crop the overlapping source files to the tile bounds,
+       optionally voxel-downsample, then rasterize a BEV PNG and a DSM (GeoTIFF + PNG),
+       writing a per-tile JSON log. RESUME_MODE skips tiles already fully produced.
+
+Outputs (per tile, named grid_<id>):
+    - grid_<id>.las/.laz   : cropped point cloud for the tile
+    - grid_<id>_bev.png    : top-down BEV render (RGB, optional transparency)
+    - grid_<id>_dsm.tif/png: digital surface model raster (georeferenced + 16-bit PNG)
+    - grid_<id>.json       : per-tile metadata (bounds, point count, elevations)
+    Plus output_grids.kml and processing_summary.json at the dataset level.
+
+External tools:
+    - PDAL (invoked via subprocess as `pdal pipeline`) for cropping/voxel filtering.
+    - GDAL/OSR for writing georeferenced DSM GeoTIFFs.
+    - laspy, numpy, Pillow, scipy, pyproj for I/O and rasterization.
+"""
+
+import json
+import os
+import subprocess
+import tempfile
+from pathlib import Path
+from pyproj import Transformer
+from typing import List, Tuple, Dict
+import laspy
+import numpy as np
+from PIL import Image
+from tqdm import tqdm
+from scipy.ndimage import uniform_filter
+
+GRID_SIZE = 150
+GRID_SPACING = -130   # 150 m tile - 130 m overlap = 20 m center spacing (paper setting)
+INPUT_LAS_FILES = None
+TILE_DIR = "./LAS"
+OUTPUT_DIR = "./output"
+VOXEL_SIZE = 0.05
+TEST_MODE_LIMIT = None
+DEBUG_MODE = False
+USE_VOXEL_FILTER = False
+PYTHON_VOXEL_DEDUP = False
+OUTPUT_COMPRESSED = False
+
+RESUME_MODE = True
+FORCE_REPROCESS = False
+
+BEV_POINT_SIZE = 8
+BEV_TRANSPARENT_BG = True
+BEV_USE_RGB = True
+BEV_POINT_OPACITY = 1.0
+BEV_OPACITY_MODE = "fixed"
+
+BEV_ADAPTIVE_POINT_SIZE = True
+BEV_POINT_SIZE_MIN = 3
+BEV_POINT_SIZE_MAX = 3
+BEV_DENSITY_WINDOW = 10
+
+MEMORY_OPTIMIZATION = True
+BEV_RESOLUTION = 256
+MAX_POINTS_IN_MEMORY = 10000000
+
+GENERATE_DSM = True
+DSM_RESOLUTION = 256
+DSM_POINT_SIZE = 3
+DSM_USE_GLOBAL_RANGE = True
+
+def parse_las_boundaries(las_files: List[str], tile_dir: str) -> Tuple[List[List[Tuple[float, float]]], str]:
+    if las_files is None or len(las_files) == 0:
+        print(f"AUTO-SCAN MODE: Scanning all LAS files in {tile_dir}")
+        las_paths = list(Path(tile_dir).glob("*.las")) + list(Path(tile_dir).glob("*.laz"))
+        las_paths = [f for f in las_paths if not f.name.startswith("grid_")]
+        las_files = [f.name for f in las_paths]
+        
+        if len(las_files) == 0:
+            raise ValueError(f"No LAS files found in {tile_dir}")
+        
+        print(f"Found {len(las_files)} LAS files:")
+        for f in las_files:
+            print(f"  - {f}")
+    else:
+        print(f"MANUAL MODE: Using {len(las_files)} specified files")
+    
+    print(f"\nReading boundaries from {len(las_files)} LAS files")
+    print("Creating individual polygons for each input file to preserve neighboring relationships")
+    
+    all_bounds = []
+    crs_list = []
+    
+    for las_file in las_files:
+        las_path = os.path.join(tile_dir, las_file)
+        if not os.path.exists(las_path):
+            print(f"Warning: File not found: {las_path}")
+            continue
+            
+        try:
+            with laspy.open(las_path) as f:
+                header = f.header
+                bounds = {
+                    'file': las_file,
+                    'min_x': header.x_min,
+                    'max_x': header.x_max,
+                    'min_y': header.y_min,
+                    'max_y': header.y_max
+                }
+                all_bounds.append(bounds)
+                
+                if hasattr(header, 'parse_crs'):
+                    crs = header.parse_crs()
+                    if crs:
+                        crs_list.append(str(crs))
+                
+                print(f"  {las_file}: X=[{bounds['min_x']:.2f}, {bounds['max_x']:.2f}], Y=[{bounds['min_y']:.2f}, {bounds['max_y']:.2f}]")
+        except Exception as e:
+            print(f"Error reading {las_file}: {e}")
+            continue
+    
+    if not all_bounds:
+        raise ValueError("No valid LAS files found")
+    
+    overall_min_x = min(b['min_x'] for b in all_bounds)
+    overall_max_x = max(b['max_x'] for b in all_bounds)
+    overall_min_y = min(b['min_y'] for b in all_bounds)
+    overall_max_y = max(b['max_y'] for b in all_bounds)
+    
+    print(f"\nOverall boundary: X=[{overall_min_x:.2f}, {overall_max_x:.2f}], Y=[{overall_min_y:.2f}, {overall_max_y:.2f}]")
+    
+    if crs_list:
+        detected_crs = crs_list[0]
+        print(f"Detected CRS: {detected_crs}")
+        if 'EPSG:' in detected_crs:
+            utm_crs = detected_crs.split('EPSG:')[1].split()[0]
+            utm_crs = f"EPSG:{utm_crs}"
+        else:
+            print("Warning: Could not parse EPSG code, using auto-detection")
+            center_x = (overall_min_x + overall_max_x) / 2
+            center_y = (overall_min_y + overall_max_y) / 2
+            utm_crs = auto_detect_utm_from_coords(center_x, center_y)
+    else:
+        print("Warning: No CRS found in LAS headers, using auto-detection")
+        center_x = (overall_min_x + overall_max_x) / 2
+        center_y = (overall_min_y + overall_max_y) / 2
+        utm_crs = auto_detect_utm_from_coords(center_x, center_y)
+    
+    print(f"Using UTM CRS: {utm_crs}")
+    
+    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    
+    polygons_wgs84 = []
+    for i, bounds in enumerate(all_bounds):
+        rectangle_utm = [
+            (bounds['min_x'], bounds['max_y']),
+            (bounds['max_x'], bounds['max_y']),
+            (bounds['max_x'], bounds['min_y']),
+            (bounds['min_x'], bounds['min_y'])
+        ]
+        
+        rectangle_wgs84 = []
+        for x, y in rectangle_utm:
+            lon, lat = transformer_to_wgs.transform(x, y)
+            rectangle_wgs84.append((lon, lat))
+        
+        polygons_wgs84.append(rectangle_wgs84)
+        print(f"  Created polygon {i+1} for {bounds['file']}")
+    
+    print(f"\nCreated {len(polygons_wgs84)} individual polygons (one per input file)")
+    print("Grids will only be generated where they overlap with these polygons")
+    
+    return polygons_wgs84, utm_crs
+
+def auto_detect_utm_from_coords(x: float, y: float) -> str:
+    if 100000 < x < 900000 and 1000000 < y < 10000000:
+        if y > 5000000:
+            zone = int((x + 500000) / 1000000) + 30
+            return f"EPSG:326{zone:02d}"
+        else:
+            zone = int((x + 500000) / 1000000) + 30
+            return f"EPSG:327{zone:02d}"
+    else:
+        print(f"Warning: Coordinates ({x}, {y}) do not match typical UTM range")
+        return "EPSG:32650"
+
+def get_utm_zone(lon: float, lat: float) -> str:
+    zone = int((lon + 180) / 6) + 1
+    hemisphere = 'north' if lat >= 0 else 'south'
+    return f"EPSG:326{zone:02d}" if hemisphere == 'north' else f"EPSG:327{zone:02d}"
+
+def point_in_polygon(point: Tuple[float, float], polygon: List[Tuple[float, float]]) -> bool:
+    x, y = point
+    n = len(polygon)
+    inside = False
+    
+    p1x, p1y = polygon[0]
+    for i in range(1, n + 1):
+        p2x, p2y = polygon[i % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                if x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= xinters:
+                        inside = not inside
+        p1x, p1y = p2x, p2y
+    
+    return inside
+
+def generate_grids(polygons_wgs84: List[List[Tuple[float, float]]], 
+                   grid_size: float, 
+                   spacing: float,
+                   utm_crs: str,
+                   transformer_to_utm,
+                   transformer_to_wgs) -> List[Dict]:
+    
+    polygons_utm = []
+    for poly_wgs in polygons_wgs84:
+        poly_utm = [transformer_to_utm.transform(lon, lat) for lon, lat in poly_wgs]
+        polygons_utm.append(poly_utm)
+    
+    all_utm_points = [p for poly in polygons_utm for p in poly]
+    min_x = min(p[0] for p in all_utm_points)
+    max_x = max(p[0] for p in all_utm_points)
+    min_y = min(p[1] for p in all_utm_points)
+    max_y = max(p[1] for p in all_utm_points)
+    
+    print(f"Grid generation boundary: X=[{min_x:.2f}, {max_x:.2f}], Y=[{min_y:.2f}, {max_y:.2f}]")
+    print(f"Area size: {max_x-min_x:.2f}m x {max_y-min_y:.2f}m")
+    
+    grids = []
+    grid_id = 0
+    
+    y = min_y
+    row = 0
+    while y < max_y:
+        x = min_x
+        col = 0
+        while x < max_x:
+            center_x = x + grid_size / 2
+            center_y = y + grid_size / 2
+            center_lon, center_lat = transformer_to_wgs.transform(center_x, center_y)
+            
+            is_in_any_polygon = False
+            for poly_wgs in polygons_wgs84:
+                if point_in_polygon((center_lon, center_lat), poly_wgs):
+                    is_in_any_polygon = True
+                    break
+            
+            if is_in_any_polygon:
+                nw_lon, nw_lat = transformer_to_wgs.transform(x, y + grid_size)
+                se_lon, se_lat = transformer_to_wgs.transform(x + grid_size, y)
+                
+                grid = {
+                    'id': grid_id,
+                    'row': row,
+                    'col': col,
+                    'utm_nw': (x, y + grid_size),
+                    'utm_se': (x + grid_size, y),
+                    'wgs84_nw': (nw_lon, nw_lat),
+                    'wgs84_se': (se_lon, se_lat),
+                    'center_wgs84': (center_lon, center_lat)
+                }
+                grids.append(grid)
+                grid_id += 1
+            
+            x += (grid_size + spacing)
+            col += 1
+        
+        y += (grid_size + spacing)
+        row += 1
+    
+    print(f"Generated {len(grids)} grids that overlap with input polygons")
+    return grids
+
+def create_kml(grids: List[Dict], output_path: str):
+    kml_header = '''<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+  <Document>
+    <name>Grid Boundaries</name>
+    <Style id="gridStyle">
+      <LineStyle>
+        <color>ff0000ff</color>
+        <width>2</width>
+      </LineStyle>
+      <PolyStyle>
+        <color>330000ff</color>
+      </PolyStyle>
+    </Style>
+'''
+    
+    kml_footer = '''  </Document>
+</kml>'''
+    
+    with open(output_path, 'w') as f:
+        f.write(kml_header)
+        
+        for grid in grids:
+            nw_lon, nw_lat = grid['wgs84_nw']
+            se_lon, se_lat = grid['wgs84_se']
+            
+            ne_lon, ne_lat = se_lon, nw_lat
+            sw_lon, sw_lat = nw_lon, se_lat
+            
+            placemark = f'''    <Placemark>
+      <name>Grid {grid['id']:06d}</name>
+      <description>Row: {grid['row']}, Col: {grid['col']}</description>
+      <styleUrl>#gridStyle</styleUrl>
+      <Polygon>
+        <outerBoundaryIs>
+          <LinearRing>
+            <coordinates>
+              {nw_lon},{nw_lat},0
+              {ne_lon},{ne_lat},0
+              {se_lon},{se_lat},0
+              {sw_lon},{sw_lat},0
+              {nw_lon},{nw_lat},0
+            </coordinates>
+          </LinearRing>
+        </outerBoundaryIs>
+      </Polygon>
+    </Placemark>
+'''
+            f.write(placemark)
+        
+        f.write(kml_footer)
+    
+    print(f"KML file created: {output_path}")
+
+def get_tile_bounds(tile_dir: str) -> Dict[str, Dict]:
+    tile_bounds = {}
+    las_files = list(Path(tile_dir).glob("*.las")) + list(Path(tile_dir).glob("*.laz"))
+    las_files = [f for f in las_files if not f.name.startswith("grid_")]
+    
+    print(f"Scanning {len(las_files)} tiles for bounds...")
+    
+    for las_file in las_files:
+        try:
+            with laspy.open(str(las_file)) as f:
+                header = f.header
+                tile_bounds[las_file.name] = {
+                    'min_x': header.x_min,
+                    'max_x': header.x_max,
+                    'min_y': header.y_min,
+                    'max_y': header.y_max
+                }
+        except Exception as e:
+            print(f"Error reading {las_file.name}: {e}")
+    
+    print(f"Successfully scanned {len(tile_bounds)} tiles")
+    return tile_bounds
+
+def scan_global_elevation_range(tile_dir: str, tile_bounds: Dict) -> Tuple[float, float]:
+    print("\n" + "="*60)
+    print("Scanning global elevation range from all tiles...")
+    print("="*60)
+    
+    global_min_z = float('inf')
+    global_max_z = float('-inf')
+    tiles_processed = 0
+    
+    for tile_file in tqdm(tile_bounds.keys(), desc="Scanning tiles", unit="tile"):
+        tile_path = os.path.join(tile_dir, tile_file)
+        try:
+            with laspy.open(tile_path) as f:
+                las = f.read()
+                if las.header.point_count > 0:
+                    z = np.array(las.z)
+                    tile_min = float(z.min())
+                    tile_max = float(z.max())
+                    global_min_z = min(global_min_z, tile_min)
+                    global_max_z = max(global_max_z, tile_max)
+                    tiles_processed += 1
+        except Exception as e:
+            print(f"Error reading {tile_file}: {e}")
+            continue
+    
+    if global_min_z == float('inf') or global_max_z == float('-inf'):
+        print("Warning: Could not determine global elevation range, will use local ranges")
+        return None, None
+    
+    print(f"\nGlobal elevation range from {tiles_processed} tiles:")
+    print(f"  Min elevation: {global_min_z:.2f}m")
+    print(f"  Max elevation: {global_max_z:.2f}m")
+    print(f"  Range: {global_max_z - global_min_z:.2f}m")
+    
+    return global_min_z, global_max_z
+
+def find_overlapping_tiles(grid: Dict, tile_bounds: Dict) -> List[str]:
+    grid_min_x, grid_max_y = grid['utm_nw']
+    grid_max_x, grid_min_y = grid['utm_se']
+    
+    overlapping = []
+    for tile_name, bounds in tile_bounds.items():
+        if not (bounds['max_x'] < grid_min_x or bounds['min_x'] > grid_max_x or
+                bounds['max_y'] < grid_min_y or bounds['min_y'] > grid_max_y):
+            overlapping.append(tile_name)
+    
+    return overlapping
+
+def crop_las_with_pdal(tile_files: List[str], grid: Dict, output_path: str, tile_dir: str) -> Dict:
+    try:
+        min_x, max_y = grid['utm_nw']
+        max_x, min_y = grid['utm_se']
+        
+        input_files = [os.path.join(tile_dir, f) for f in tile_files]
+        
+        pipeline = {
+            "pipeline": []
+        }
+        
+        for input_file in input_files:
+            pipeline["pipeline"].append(input_file)
+        
+        bounds_str = f"([{min_x}, {max_x}], [{min_y}, {max_y}])"
+        
+        filters = [
+            {
+                "type": "filters.crop",
+                "bounds": bounds_str
+            }
+        ]
+        
+        if USE_VOXEL_FILTER and len(tile_files) > 1:
+            filters.append({
+                "type": "filters.voxelcenternearestneighbor",
+                "cell": VOXEL_SIZE
+            })
+        
+        filters.append({
+            "type": "writers.las",
+            "filename": output_path,
+            "compression": "laszip" if OUTPUT_COMPRESSED else "none"
+        })
+        
+        pipeline["pipeline"].extend(filters)
+        
+        with tempfile.NamedTemporaryFile(mode='w', suffix='.json', delete=False) as f:
+            json.dump(pipeline, f, indent=2)
+            pipeline_file = f.name
+        
+        try:
+            result = subprocess.run(
+                ['pdal', 'pipeline', pipeline_file],
+                capture_output=True,
+                text=True,
+                timeout=300
+            )
+            
+            if result.returncode != 0:
+                return {
+                    'success': False,
+                    'error': f"PDAL error: {result.stderr}",
+                    'point_count': 0
+                }
+            
+            if not os.path.exists(output_path):
+                return {
+                    'success': False,
+                    'error': 'Output file not created',
+                    'point_count': 0
+                }
+            
+            with laspy.open(output_path) as f:
+                point_count = f.header.point_count
+            
+            return {
+                'success': True,
+                'point_count': point_count,
+                'tiles_used': tile_files
+            }
+            
+        finally:
+            if os.path.exists(pipeline_file):
+                os.remove(pipeline_file)
+        
+    except subprocess.TimeoutExpired:
+        return {
+            'success': False,
+            'error': 'PDAL pipeline timeout',
+            'point_count': 0
+        }
+    except Exception as e:
+        return {
+            'success': False,
+            'error': str(e),
+            'point_count': 0
+        }
+
+def voxel_downsample_python(input_las: str, output_las: str, voxel_size: float) -> int:
+    with laspy.open(input_las) as f:
+        las = f.read()
+    
+    x = np.array(las.x)
+    y = np.array(las.y)
+    z = np.array(las.z)
+    
+    voxel_x = np.floor(x / voxel_size).astype(np.int32)
+    voxel_y = np.floor(y / voxel_size).astype(np.int32)
+    voxel_z = np.floor(z / voxel_size).astype(np.int32)
+    
+    voxel_keys = np.column_stack([voxel_x, voxel_y, voxel_z])
+    unique_voxels, unique_indices = np.unique(voxel_keys, axis=0, return_index=True)
+    
+    las_filtered = laspy.LasData(las.header)
+    las_filtered.points = las.points[unique_indices]
+    
+    las_filtered.write(output_las)
+    
+    return len(unique_indices)
+
+def generate_bev_png(las_path: str, output_path: str, grid: Dict):
+    try:
+        with laspy.open(las_path) as f:
+            las = f.read()
+        
+        if las.header.point_count == 0:
+            if DEBUG_MODE:
+                print(f"    BEV: Empty point cloud")
+            img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+            img.save(output_path)
+            return
+        
+        x = np.array(las.x)
+        y = np.array(las.y)
+        
+        minx = grid['utm_nw'][0]
+        maxx = grid['utm_se'][0]
+        miny = grid['utm_se'][1]
+        maxy = grid['utm_nw'][1]
+        
+        px = ((x - minx) / (maxx - minx) * (BEV_RESOLUTION - 1)).astype(np.int32)
+        py = ((maxy - y) / (maxy - miny) * (BEV_RESOLUTION - 1)).astype(np.int32)
+        
+        valid = (px >= 0) & (px < BEV_RESOLUTION) & (py >= 0) & (py < BEV_RESOLUTION)
+        px = px[valid]
+        py = py[valid]
+        
+        if len(px) == 0:
+            if DEBUG_MODE:
+                print(f"    BEV: No valid points")
+            img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+            img.save(output_path)
+            return
+        
+        if BEV_USE_RGB and hasattr(las, 'red'):
+            r = np.array(las.red)[valid] // 256
+            g = np.array(las.green)[valid] // 256
+            b = np.array(las.blue)[valid] // 256
+        else:
+            r = g = b = None
+        
+        img_array = np.zeros((BEV_RESOLUTION, BEV_RESOLUTION, 4), dtype=np.uint8)
+        if not BEV_TRANSPARENT_BG:
+            img_array[:, :, :3] = 255
+            img_array[:, :, 3] = 255
+        
+        if BEV_ADAPTIVE_POINT_SIZE:
+            density_map = np.zeros((BEV_RESOLUTION, BEV_RESOLUTION), dtype=np.int32)
+            for i in range(len(px)):
+                density_map[py[i], px[i]] += 1
+            
+            density_smoothed = uniform_filter(density_map.astype(np.float32), size=BEV_DENSITY_WINDOW)
+            max_density = density_smoothed.max()
+            if max_density > 0:
+                density_normalized = density_smoothed / max_density
+            else:
+                density_normalized = density_smoothed
+        
+        for i in range(len(px)):
+            if BEV_ADAPTIVE_POINT_SIZE:
+                density_value = density_normalized[py[i], px[i]]
+                point_size = int(BEV_POINT_SIZE_MIN + (BEV_POINT_SIZE_MAX - BEV_POINT_SIZE_MIN) * (1 - density_value))
+            else:
+                point_size = BEV_POINT_SIZE
+            
+            half_size = point_size // 2
+            x_start = max(0, px[i] - half_size)
+            x_end = min(BEV_RESOLUTION, px[i] + half_size + 1)
+            y_start = max(0, py[i] - half_size)
+            y_end = min(BEV_RESOLUTION, py[i] + half_size + 1)
+            
+            if BEV_OPACITY_MODE == "fixed":
+                alpha = int(BEV_POINT_OPACITY * 255)
+            else:
+                alpha = 255
+            
+            if r is not None:
+                color = [r[i], g[i], b[i]]
+            else:
+                color = [0, 0, 0]
+            
+            img_array[y_start:y_end, x_start:x_end, :3] = color
+            img_array[y_start:y_end, x_start:x_end, 3] = alpha
+        
+        img = Image.fromarray(img_array)
+        img.save(output_path)
+        if DEBUG_MODE:
+            print(f"    BEV: Saved to {output_path}")
+        
+    except Exception as e:
+        print(f"    BEV: Error generating BEV: {e}")
+        if DEBUG_MODE:
+            import traceback
+            traceback.print_exc()
+        img = Image.new('RGBA', (BEV_RESOLUTION, BEV_RESOLUTION), (0, 0, 0, 0) if BEV_TRANSPARENT_BG else (255, 255, 255, 255))
+        img.save(output_path)
+
+def generate_dsm(las_path: str, output_geotiff: str, output_png: str, grid: Dict, 
+                 resolution: int = 1024, global_min_z: float = None, global_max_z: float = None) -> Dict:
+    try:
+        from osgeo import gdal, osr
+        
+        with laspy.open(las_path) as f:
+            las = f.read()
+        
+        if las.header.point_count == 0:
+            if DEBUG_MODE:
+                print(f"    DSM: Empty point cloud")
+            return None
+        
+        x = np.array(las.x)
+        y = np.array(las.y)
+        z = np.array(las.z)
+        
+        minx = grid['utm_nw'][0]
+        maxx = grid['utm_se'][0]
+        miny = grid['utm_se'][1]
+        maxy = grid['utm_nw'][1]
+        
+        cell_size_x = (maxx - minx) / resolution
+        cell_size_y = (maxy - miny) / resolution
+        
+        px = ((x - minx) / (maxx - minx) * (resolution - 1)).astype(np.int32)
+        py = ((maxy - y) / (maxy - miny) * (resolution - 1)).astype(np.int32)
+        
+        valid = (px >= 0) & (px < resolution) & (py >= 0) & (py < resolution)
+        px = px[valid]
+        py = py[valid]
+        z = z[valid]
+        
+        if len(px) == 0:
+            if DEBUG_MODE:
+                print(f"    DSM: No valid points")
+            return None
+        
+        dsm = np.full((resolution, resolution), -9999.0, dtype=np.float32)
+        
+        half_size = DSM_POINT_SIZE // 2
+        
+        for i in range(len(px)):
+            cy, cx = py[i], px[i]
+            
+            for dy in range(-half_size, half_size + 1):
+                for dx in range(-half_size, half_size + 1):
+                    ny = cy + dy
+                    nx = cx + dx
+                    
+                    if 0 <= ny < resolution and 0 <= nx < resolution:
+                        current_z = dsm[ny, nx]
+                        if current_z == -9999.0 or z[i] > current_z:
+                            dsm[ny, nx] = z[i]
+        
+        mask = dsm != -9999.0
+        if not mask.any():
+            if DEBUG_MODE:
+                print(f"    DSM: All cells empty")
+            return None
+        
+        local_min_elevation = float(dsm[mask].min())
+        local_max_elevation = float(dsm[mask].max())
+        
+        if DSM_USE_GLOBAL_RANGE and global_min_z is not None and global_max_z is not None:
+            use_min = global_min_z
+            use_max = global_max_z
+            if DEBUG_MODE:
+                print(f"    DSM: Using global range {use_min:.2f}-{use_max:.2f}m (local: {local_min_elevation:.2f}-{local_max_elevation:.2f}m)")
+        else:
+            use_min = local_min_elevation
+            use_max = local_max_elevation
+            if DEBUG_MODE:
+                print(f"    DSM: Using local range {use_min:.2f}-{use_max:.2f}m")
+        
+        driver = gdal.GetDriverByName('GTiff')
+        dataset = driver.Create(output_geotiff, resolution, resolution, 1, gdal.GDT_Float32)
+        
+        geotransform = (minx, cell_size_x, 0, maxy, 0, -cell_size_y)
+        dataset.SetGeoTransform(geotransform)
+        
+        srs = osr.SpatialReference()
+        epsg_code = int(grid.get('utm_crs', 'EPSG:27700').split(':')[1]) if 'utm_crs' in grid else 27700
+        srs.ImportFromEPSG(epsg_code)
+        dataset.SetProjection(srs.ExportToWkt())
+        
+        band = dataset.GetRasterBand(1)
+        band.SetNoDataValue(-9999.0)
+        band.WriteArray(dsm)
+        
+        dataset.FlushCache()
+        dataset = None
+        
+        dsm_normalized = np.where(dsm == -9999.0, 0, 
+                                   np.clip((dsm - use_min) / (use_max - use_min), 0, 1) * 65535)
+        dsm_img = dsm_normalized.astype(np.uint16)
+        
+        img = Image.fromarray(dsm_img)
+        img.save(output_png)
+        
+        if DEBUG_MODE:
+            print(f"    DSM: GeoTIFF and PNG saved")
+        
+        return {
+            'min_elevation': local_min_elevation,
+            'max_elevation': local_max_elevation,
+            'global_min_used': use_min,
+            'global_max_used': use_max,
+            'resolution': resolution,
+            'cell_size_x': cell_size_x,
+            'cell_size_y': cell_size_y
+        }
+        
+    except ImportError:
+        print(f"    DSM: Error - GDAL not installed. Install with: pip install gdal")
+        return None
+    except Exception as e:
+        print(f"    DSM: Error - {e}")
+        if DEBUG_MODE:
+            import traceback
+            traceback.print_exc()
+        return None
+
+def check_grid_already_processed(grid_id: int, output_dir: str) -> Dict:
+    file_ext = ".laz" if OUTPUT_COMPRESSED else ".las"
+    output_las = os.path.join(output_dir, f"grid_{grid_id:06d}{file_ext}")
+    output_bev = os.path.join(output_dir, f"grid_{grid_id:06d}_bev.png")
+    output_log = os.path.join(output_dir, f"grid_{grid_id:06d}.json")
+    
+    required_files = [output_las, output_bev, output_log]
+    
+    if GENERATE_DSM:
+        output_dsm_tif = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.tif")
+        output_dsm_png = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.png")
+        required_files.extend([output_dsm_tif, output_dsm_png])
+    
+    if all(os.path.exists(f) for f in required_files):
+        try:
+            with open(output_log, 'r') as f:
+                log_data = json.load(f)
+            
+            if all(os.path.getsize(f) > 0 for f in required_files):
+                return {
+                    'grid_id': grid_id,
+                    'status': 'success',
+                    'point_count': log_data.get('point_count', 0),
+                    'tiles_used': len(log_data.get('tiles_used', [])),
+                    'resumed': True
+                }
+        except Exception as e:
+            if DEBUG_MODE:
+                tqdm.write(f"  DEBUG: Failed to read log for grid {grid_id}: {e}")
+            return None
+    
+    return None
+
+def process_single_grid(grid: Dict, tile_bounds: Dict, tile_dir: str, output_dir: str, 
+                       utm_crs: str, global_min_z: float = None, global_max_z: float = None) -> Dict:
+    grid_id = grid['id']
+    
+    if RESUME_MODE and not FORCE_REPROCESS:
+        existing_result = check_grid_already_processed(grid_id, output_dir)
+        if existing_result:
+            return existing_result
+    
+    if DEBUG_MODE:
+        print(f"\n  DEBUG: Grid bounds UTM: NW={grid['utm_nw']}, SE={grid['utm_se']}")
+    
+    overlapping_tiles = find_overlapping_tiles(grid, tile_bounds)
+    
+    if DEBUG_MODE:
+        print(f"  DEBUG: Found {len(overlapping_tiles)} overlapping tiles: {overlapping_tiles[:3]}...")
+    
+    if not overlapping_tiles:
+        return {
+            'grid_id': grid_id,
+            'status': 'no_tiles',
+            'message': 'No overlapping tiles found'
+        }
+    
+    file_ext = ".laz" if OUTPUT_COMPRESSED else ".las"
+    output_las = os.path.join(output_dir, f"grid_{grid_id:06d}{file_ext}")
+    output_bev = os.path.join(output_dir, f"grid_{grid_id:06d}_bev.png")
+    output_log = os.path.join(output_dir, f"grid_{grid_id:06d}.json")
+    
+    crop_result = crop_las_with_pdal(overlapping_tiles, grid, output_las, tile_dir)
+    
+    if not crop_result['success']:
+        error_msg = crop_result.get('error', 'Unknown error')
+        return {
+            'grid_id': grid_id,
+            'status': 'failed',
+            'message': error_msg,
+            'tiles_checked': overlapping_tiles
+        }
+    
+    if crop_result['point_count'] == 0:
+        return {
+            'grid_id': grid_id,
+            'status': 'empty',
+            'message': 'No points in cropped area',
+            'tiles_used': overlapping_tiles
+        }
+    
+    if PYTHON_VOXEL_DEDUP and len(overlapping_tiles) > 1:
+        temp_output = output_las + ".temp"
+        os.rename(output_las, temp_output)
+        final_count = voxel_downsample_python(temp_output, output_las, VOXEL_SIZE)
+        os.remove(temp_output)
+        crop_result['point_count'] = final_count
+        if DEBUG_MODE:
+            print(f"  DEBUG: Python voxel downsampled to {final_count} points")
+    
+    generate_bev_png(output_las, output_bev, grid)
+    
+    dsm_info = None
+    if GENERATE_DSM:
+        output_dsm_tif = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.tif")
+        output_dsm_png = os.path.join(output_dir, f"grid_{grid_id:06d}_dsm.png")
+        grid_with_crs = grid.copy()
+        grid_with_crs['utm_crs'] = utm_crs
+        dsm_info = generate_dsm(output_las, output_dsm_tif, output_dsm_png, grid_with_crs, 
+                               DSM_RESOLUTION, global_min_z, global_max_z)
+    
+    log_data = {
+        'grid_id': grid_id,
+        'row': grid['row'],
+        'col': grid['col'],
+        'utm_nw': grid['utm_nw'],
+        'utm_se': grid['utm_se'],
+        'wgs84_nw': grid['wgs84_nw'],
+        'wgs84_se': grid['wgs84_se'],
+        'point_count': crop_result['point_count'],
+        'tiles_used': crop_result['tiles_used'],
+        'output_files': {
+            'las': os.path.basename(output_las),
+            'bev': os.path.basename(output_bev)
+        }
+    }
+    
+    if GENERATE_DSM and dsm_info:
+        log_data['elevation'] = {
+            'local_min_elevation': dsm_info['min_elevation'],
+            'local_max_elevation': dsm_info['max_elevation'],
+            'global_min_used': dsm_info['global_min_used'],
+            'global_max_used': dsm_info['global_max_used'],
+            'elevation_range': dsm_info['max_elevation'] - dsm_info['min_elevation']
+        }
+        log_data['output_files']['dsm_geotiff'] = os.path.basename(output_dsm_tif)
+        log_data['output_files']['dsm_png'] = os.path.basename(output_dsm_png)
+    
+    with open(output_log, 'w') as f:
+        json.dump(log_data, f, indent=2)
+    
+    return {
+        'grid_id': grid_id,
+        'status': 'success',
+        'point_count': crop_result['point_count'],
+        'tiles_used': len(overlapping_tiles)
+    }
+
+def main():
+    os.makedirs(OUTPUT_DIR, exist_ok=True)
+    
+    if os.path.abspath(OUTPUT_DIR) == os.path.abspath(TILE_DIR):
+        print("ERROR: OUTPUT_DIR and TILE_DIR must be different!")
+        print(f"OUTPUT_DIR: {os.path.abspath(OUTPUT_DIR)}")
+        print(f"TILE_DIR: {os.path.abspath(TILE_DIR)}")
+        print("Please set OUTPUT_DIR to a different directory to avoid confusion.")
+        return
+    
+    print("="*60)
+    print("STEP 1: Reading LAS boundaries and generating grids")
+    print("="*60)
+    
+    polygons, utm_crs = parse_las_boundaries(INPUT_LAS_FILES, TILE_DIR)
+    
+    transformer_to_utm = Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
+    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    
+    grids = generate_grids(polygons, GRID_SIZE, GRID_SPACING, 
+                          utm_crs, transformer_to_utm, transformer_to_wgs)
+    
+    print("\n" + "="*60)
+    print("STEP 2: Generating KML visualization")
+    print("="*60)
+    
+    kml_output = os.path.join(OUTPUT_DIR, "output_grids.kml")
+    create_kml(grids, kml_output)
+    
+    print("\n" + "="*60)
+    print("STEP 3: Scanning all LAS tiles")
+    print("="*60)
+    
+    tile_bounds = get_tile_bounds(TILE_DIR)
+    
+    if not tile_bounds:
+        print("ERROR: No valid tiles found!")
+        return
+    
+    global_min_z = None
+    global_max_z = None
+    
+    if GENERATE_DSM and DSM_USE_GLOBAL_RANGE:
+        global_min_z, global_max_z = scan_global_elevation_range(TILE_DIR, tile_bounds)
+    
+    print("\n" + "="*60)
+    print("STEP 4: Processing grids and generating outputs")
+    print("="*60)
+    
+    grids_to_process = grids[:TEST_MODE_LIMIT] if TEST_MODE_LIMIT else grids
+    
+    if TEST_MODE_LIMIT:
+        print(f"\n*** TEST MODE: Processing only first {len(grids_to_process)} grids ***\n")
+    else:
+        print(f"\nProcessing all {len(grids_to_process)} grids\n")
+    
+    if RESUME_MODE and not FORCE_REPROCESS:
+        print(f"*** RESUME MODE: Skipping already processed grids ***\n")
+    elif FORCE_REPROCESS:
+        print(f"*** FORCE REPROCESS: Reprocessing all grids ***\n")
+    
+    if GENERATE_DSM:
+        print(f"DSM Configuration:")
+        print(f"  Resolution: {DSM_RESOLUTION}x{DSM_RESOLUTION}")
+        print(f"  Point size: {DSM_POINT_SIZE}x{DSM_POINT_SIZE} pixels per point")
+        print(f"  Use global range: {DSM_USE_GLOBAL_RANGE}")
+        if DSM_USE_GLOBAL_RANGE and global_min_z is not None:
+            print(f"  Global range: {global_min_z:.2f}m - {global_max_z:.2f}m\n")
+    
+    results = []
+    resumed_count = 0
+    processed_count = 0
+    
+    with tqdm(total=len(grids_to_process), desc="Processing grids", unit="grid") as pbar:
+        for i, grid in enumerate(grids_to_process):
+            grid_id = grid['id']
+            pbar.set_description(f"Processing grid {grid_id:06d}")
+            
+            result = process_single_grid(grid, tile_bounds, TILE_DIR, OUTPUT_DIR, utm_crs, 
+                                        global_min_z, global_max_z)
+            results.append(result)
+            
+            if result.get('resumed', False):
+                resumed_count += 1
+                tqdm.write(f"Grid {grid_id:06d}: RESUMED - {result.get('point_count', 0):,} points (skipped)")
+            else:
+                processed_count += 1
+                if result['status'] == 'failed':
+                    tqdm.write(f"Grid {grid_id:06d}: FAILED - {result.get('message', 'Unknown error')}")
+                elif result['status'] == 'success':
+                    tqdm.write(f"Grid {grid_id:06d}: SUCCESS - {result.get('point_count', 0):,} points from {result.get('tiles_used', 0)} tiles")
+                elif result['status'] == 'empty':
+                    tqdm.write(f"Grid {grid_id:06d}: EMPTY - No points in area")
+                elif result['status'] == 'no_tiles':
+                    tqdm.write(f"Grid {grid_id:06d}: NO TILES - No overlapping tiles found")
+            
+            pbar.update(1)
+    
+    print("\n" + "="*60)
+    print("STEP 5: Generating final summary")
+    print("="*60)
+    
+    summary = {
+        'config': {
+            'grid_size_m': GRID_SIZE,
+            'grid_spacing_m': GRID_SPACING,
+            'voxel_size_m': VOXEL_SIZE,
+            'use_voxel_filter': USE_VOXEL_FILTER,
+            'python_voxel_dedup': PYTHON_VOXEL_DEDUP,
+            'output_compressed': OUTPUT_COMPRESSED,
+            'bev_point_size': BEV_POINT_SIZE,
+            'bev_transparent_bg': BEV_TRANSPARENT_BG,
+            'bev_use_rgb': BEV_USE_RGB,
+            'bev_point_opacity': BEV_POINT_OPACITY,
+            'bev_opacity_mode': BEV_OPACITY_MODE,
+            'bev_adaptive_point_size': BEV_ADAPTIVE_POINT_SIZE,
+            'bev_point_size_min': BEV_POINT_SIZE_MIN,
+            'bev_point_size_max': BEV_POINT_SIZE_MAX,
+            'bev_density_window': BEV_DENSITY_WINDOW,
+            'generate_dsm': GENERATE_DSM,
+            'dsm_resolution': DSM_RESOLUTION,
+            'dsm_point_size': DSM_POINT_SIZE,
+            'dsm_use_global_range': DSM_USE_GLOBAL_RANGE,
+            'global_elevation_range': {
+                'min': global_min_z,
+                'max': global_max_z
+            } if global_min_z is not None else None,
+            'utm_crs': utm_crs,
+            'test_mode': TEST_MODE_LIMIT is not None,
+            'test_mode_limit': TEST_MODE_LIMIT,
+            'resume_mode': RESUME_MODE,
+            'force_reprocess': FORCE_REPROCESS
+        },
+        'statistics': {
+            'total_grids_generated': len(grids),
+            'grids_processed': len(grids_to_process),
+            'newly_processed': processed_count,
+            'resumed_skipped': resumed_count,
+            'successful': sum(1 for r in results if r['status'] == 'success'),
+            'failed': sum(1 for r in results if r['status'] == 'failed'),
+            'empty': sum(1 for r in results if r['status'] == 'empty'),
+            'no_tiles': sum(1 for r in results if r['status'] == 'no_tiles')
+        },
+        'results': results
+    }
+    
+    summary_path = os.path.join(OUTPUT_DIR, "processing_summary.json")
+    with open(summary_path, 'w') as f:
+        json.dump(summary, f, indent=2)
+    
+    print(f"\nSummary saved to: {summary_path}")
+    print(f"KML visualization: {kml_output}")
+    if TEST_MODE_LIMIT:
+        print(f"Test mode: Processed {len(grids_to_process)}/{len(grids)} grids")
+    if RESUME_MODE and resumed_count > 0:
+        print(f"Resumed: Skipped {resumed_count} already processed grids")
+        print(f"Newly processed: {processed_count} grids")
+    print(f"Success: {summary['statistics']['successful']}/{len(grids_to_process)}")
+    print("\nProcessing complete!")
+
+if __name__ == "__main__":
+    main()

scripts/melbourne/grid_from_kml.py

@@ -0,0 +1,277 @@
+"""
+Build the 150 m tile grid for the City3D-MultiGen reconstruction pipeline.
+
+Role in the pipeline:
+    This script turns a coarse tile-index footprint into the fine, regularly
+    spaced grid of 150 m x 150 m tiles that drives the rest of the pipeline.
+    Each generated tile later defines the geographic extent used to crop the
+    source city point cloud and to fetch aligned satellite/semantic maps.
+
+Input:
+    A KML tile-index file (default "Tile_Index.kml") whose polygons describe
+    the WGS84 (lon/lat) coverage area of the source city data.
+
+Outputs:
+    - output_grids.kml: a colorized KML visualization of the generated tiles.
+    - output_grids.json: the machine-readable grid consumed downstream. It
+      stores grid_size_m, grid_spacing_m, input_polygons, total_grids, and a
+      "grids" list where each entry has id, row, col, and both UTM and WGS84
+      corner coordinates (utm_nw/utm_se, wgs84_nw/wgs84_se).
+
+Key steps:
+    Parse the KML polygons, pick a UTM zone from the data centroid, project the
+    polygons into metric UTM coordinates, tile the bounding box on a fixed
+    pitch, keep tiles whose center falls inside a footprint polygon, then
+    project the tile corners back to WGS84 for output.
+
+Coordinate-system handling:
+    All distances/sizes are computed in metric UTM (zone chosen automatically
+    from the centroid via EPSG:326xx/327xx). pyproj Transformers (always_xy)
+    convert between EPSG:4326 (WGS84 lon/lat) and the chosen UTM CRS.
+"""
+
+import json
+import math
+from xml.etree import ElementTree as ET
+from pyproj import Transformer, CRS
+from typing import List, Tuple
+
+GRID_SIZE = 150
+GRID_SPACING = -130   # 150 m tile - 130 m overlap = 20 m center spacing (paper setting)
+
+def parse_kml_polygons(kml_path: str) -> List[List[Tuple[float, float]]]:
+    tree = ET.parse(kml_path)
+    root = tree.getroot()
+    
+    polygons = []
+    
+    for elem in root.iter():
+        if elem.tag.endswith('coordinates'):
+            coords_text = elem.text
+            if coords_text:
+                coords = []
+                for line in coords_text.strip().split():
+                    parts = line.split(',')
+                    if len(parts) >= 2:
+                        lon, lat = float(parts[0]), float(parts[1])
+                        coords.append((lon, lat))
+                if coords:
+                    polygons.append(coords)
+    
+    print(f"Parsed {len(polygons)} polygons from KML")
+    return polygons
+
+def get_utm_zone(lon: float, lat: float) -> str:
+    zone = int((lon + 180) / 6) + 1
+    hemisphere = 'north' if lat >= 0 else 'south'
+    return f"EPSG:326{zone:02d}" if hemisphere == 'north' else f"EPSG:327{zone:02d}"
+
+def point_in_polygon(point: Tuple[float, float], polygon: List[Tuple[float, float]]) -> bool:
+    x, y = point
+    n = len(polygon)
+    inside = False
+    
+    p1x, p1y = polygon[0]
+    for i in range(1, n + 1):
+        p2x, p2y = polygon[i % n]
+        if y > min(p1y, p2y):
+            if y <= max(p1y, p2y):
+                if x <= max(p1x, p2x):
+                    if p1y != p2y:
+                        xinters = (y - p1y) * (p2x - p1x) / (p2y - p1y) + p1x
+                    if p1x == p2x or x <= xinters:
+                        inside = not inside
+        p1x, p1y = p2x, p2y
+    
+    return inside
+
+def generate_grid(polygons_wgs84: List[List[Tuple[float, float]]], 
+                  grid_size: float, 
+                  spacing: float) -> List[dict]:
+    
+    all_points = [p for poly in polygons_wgs84 for p in poly]
+    center_lon = sum(p[0] for p in all_points) / len(all_points)
+    center_lat = sum(p[1] for p in all_points) / len(all_points)
+    
+    utm_crs = get_utm_zone(center_lon, center_lat)
+    print(f"Using coordinate system: {utm_crs}")
+    
+    transformer_to_utm = Transformer.from_crs("EPSG:4326", utm_crs, always_xy=True)
+    transformer_to_wgs = Transformer.from_crs(utm_crs, "EPSG:4326", always_xy=True)
+    
+    polygons_utm = []
+    for poly_wgs in polygons_wgs84:
+        poly_utm = [transformer_to_utm.transform(lon, lat) for lon, lat in poly_wgs]
+        polygons_utm.append(poly_utm)
+    
+    all_utm_points = [p for poly in polygons_utm for p in poly]
+    min_x = min(p[0] for p in all_utm_points)
+    max_x = max(p[0] for p in all_utm_points)
+    min_y = min(p[1] for p in all_utm_points)
+    max_y = max(p[1] for p in all_utm_points)
+    
+    print(f"Overall boundary in UTM: X=[{min_x:.2f}, {max_x:.2f}], Y=[{min_y:.2f}, {max_y:.2f}]")
+    print(f"Area size: {max_x-min_x:.2f}m x {max_y-min_y:.2f}m")
+    
+    grids = []
+    grid_id = 0
+    total_candidates = 0
+    
+    y = min_y
+    row = 0
+    while y < max_y:
+        x = min_x
+        col = 0
+        while x < max_x:
+            total_candidates += 1
+            
+            center_x = x + grid_size / 2
+            center_y = y + grid_size / 2
+            center_utm = (center_x, center_y)
+            
+            is_inside = False
+            for poly_utm in polygons_utm:
+                if point_in_polygon(center_utm, poly_utm):
+                    is_inside = True
+                    break
+            
+            if is_inside:
+                nw_utm = (x, y + grid_size)
+                ne_utm = (x + grid_size, y + grid_size)
+                se_utm = (x + grid_size, y)
+                sw_utm = (x, y)
+                
+                nw_wgs = transformer_to_wgs.transform(*nw_utm)
+                ne_wgs = transformer_to_wgs.transform(*ne_utm)
+                se_wgs = transformer_to_wgs.transform(*se_utm)
+                sw_wgs = transformer_to_wgs.transform(*sw_utm)
+                
+                color_index = (row + col) % 2
+                
+                grids.append({
+                    'id': grid_id,
+                    'row': row,
+                    'col': col,
+                    'color_index': color_index,
+                    'utm': {
+                        'nw': nw_utm,
+                        'ne': ne_utm,
+                        'se': se_utm,
+                        'sw': sw_utm
+                    },
+                    'wgs84': {
+                        'nw': nw_wgs,
+                        'ne': ne_wgs,
+                        'se': se_wgs,
+                        'sw': sw_wgs
+                    }
+                })
+                
+                grid_id += 1
+            
+            x += grid_size + spacing
+            col += 1
+        
+        y += grid_size + spacing
+        row += 1
+    
+    print(f"Generated {len(grids)} grids from {total_candidates} candidates")
+    return grids
+
+def create_kml(grids: List[dict], output_path: str):
+    kml_header = '''<?xml version="1.0" encoding="UTF-8"?>
+<kml xmlns="http://www.opengis.net/kml/2.2">
+<Document>
+<name>Grid Output</name>
+<Style id="color0">
+  <LineStyle><color>ff0000ff</color><width>2</width></LineStyle>
+  <PolyStyle><color>4d0000ff</color></PolyStyle>
+</Style>
+<Style id="color1">
+  <LineStyle><color>ff00ff00</color><width>2</width></LineStyle>
+  <PolyStyle><color>4d00ff00</color></PolyStyle>
+</Style>
+'''
+    
+    kml_footer = '''</Document>
+</kml>'''
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        f.write(kml_header)
+        
+        for grid in grids:
+            wgs = grid['wgs84']
+            color_id = f"color{grid['color_index']}"
+            
+            f.write(f'''<Placemark>
+  <name>Grid_{grid['id']}</name>
+  <styleUrl>#{color_id}</styleUrl>
+  <Polygon>
+    <outerBoundaryIs>
+      <LinearRing>
+        <coordinates>
+          {wgs['nw'][0]},{wgs['nw'][1]},0
+          {wgs['ne'][0]},{wgs['ne'][1]},0
+          {wgs['se'][0]},{wgs['se'][1]},0
+          {wgs['sw'][0]},{wgs['sw'][1]},0
+          {wgs['nw'][0]},{wgs['nw'][1]},0
+        </coordinates>
+      </LinearRing>
+    </outerBoundaryIs>
+  </Polygon>
+</Placemark>
+''')
+        
+        f.write(kml_footer)
+    
+    print(f"KML file saved to: {output_path}")
+
+def create_json(grids: List[dict], output_path: str, input_polygon_count: int = 1):
+    output_data = {
+        'grid_size_m': GRID_SIZE,
+        'grid_spacing_m': GRID_SPACING,
+        'input_polygons': input_polygon_count,
+        'total_grids': len(grids),
+        'grids': [
+            {
+                'id': g['id'],
+                'row': g['row'],
+                'col': g['col'],
+                'utm_nw': g['utm']['nw'],
+                'utm_se': g['utm']['se'],
+                'wgs84_nw': g['wgs84']['nw'],
+                'wgs84_se': g['wgs84']['se']
+            }
+            for g in grids
+        ]
+    }
+    
+    with open(output_path, 'w', encoding='utf-8') as f:
+        json.dump(output_data, f, indent=2, ensure_ascii=False)
+    
+    print(f"JSON file saved to: {output_path}")
+
+def main(input_kml: str, output_kml: str, output_json: str):
+    print(f"Reading input KML: {input_kml}")
+    print(f"Grid size: {GRID_SIZE}m, Spacing: {GRID_SPACING}m")
+    print("-" * 60)
+    
+    polygons = parse_kml_polygons(input_kml)
+    
+    if not polygons:
+        raise ValueError("No polygons found in input KML")
+    
+    grids = generate_grid(polygons, GRID_SIZE, GRID_SPACING)
+    
+    create_kml(grids, output_kml)
+    create_json(grids, output_json, len(polygons))
+    
+    print("-" * 60)
+    print("Grid generation completed successfully!")
+
+if __name__ == "__main__":
+    INPUT_KML = "Tile_Index.kml"
+    OUTPUT_KML = "output_grids.kml"
+    OUTPUT_JSON = "output_grids.json"
+    
+    main(INPUT_KML, OUTPUT_KML, OUTPUT_JSON)