code/build_plateau.py

#!/usr/bin/env python3
"""
STER — PLATEAU (Japan) Benchmark Builder.

Downloads PLATEAU CityGML data for specified cities/wards, converts to CityJSON,
extracts LOD1 + LOD2 building geometries, computes 25 geometric properties via
the official ObjectPropertiesProcessor, and saves per-city parquet + joblib + manifest.

Cross-LoD paradigm: LOD1 = coarse source (cands), LOD2 = detailed source (index).
Same building ID across LODs = positive match (automatic ground truth).

Usage:
  python3 build_plateau.py --city chiyoda
  python3 build_plateau.py --all
"""
import argparse, json, os, sys, time, logging
from collections import defaultdict
from pathlib import Path
import numpy as np
import pandas as pd
import joblib

sys.path.insert(0, '/root/autodl-tmp')

import plateaukit as pk
from object_properties import ObjectPropertiesProcessor, PROP_NAMES

logger = logging.getLogger("plateau_build")
logger.setLevel(logging.INFO)
h = logging.StreamHandler(sys.stdout)
h.setFormatter(logging.Formatter('%(asctime)s [%(levelname)s] %(message)s'))
logger.addHandler(h)

# ============================================================
# Tokyo ward dataset IDs (latest version, 2023/2024)
# ============================================================
TOKYO_WARDS = {
    "chiyoda":    "plateau-13101-chiyoda-ku-2023",
    "chuo":       "plateau-13102-chuo-ku-2023",
    "minato":     "plateau-13103-minato-ku-2023",
    "shinjuku":   "plateau-13104-shinjuku-ku-2023",
    "bunkyo":     "plateau-13105-bunkyo-ku-2023",
    "taito":      "plateau-13106-taito-ku-2024",
    "sumida":     "plateau-13107-sumida-ku-2024",
    "koto":       "plateau-13108-koto-ku-2023",
    "shinagawa":  "plateau-13109-shinagawa-ku-2024",
    "meguro":     "plateau-13110-meguro-ku-2023",
    "ota":        "plateau-13111-ota-ku-2023",
    "setagaya":   "plateau-13112-setagaya-ku-2023",
    "shibuya":    "plateau-13113-shibuya-ku-2023",
    "nakano":     "plateau-13114-nakano-ku-2023",
    "suginami":   "plateau-13115-suginami-ku-2024",
    "toshima":    "plateau-13116-toshima-ku-2023",
    "kita":       "plateau-13117-kita-ku-2023",
    "arakawa":    "plateau-13118-arakawa-ku-2023",
    "itabashi":   "plateau-13119-itabashi-ku-2023",
    "nerima":     "plateau-13120-nerima-ku-2023",
    "adachi":     "plateau-13121-adachi-ku-2023",
    "katsushika": "plateau-13122-katsushika-ku-2023",
    "edogawa":    "plateau-13123-edogawa-ku-2023",

    "osaka":      "plateau-27100-osaka-shi-2024",
    "kyoto":      "plateau-26100-kyoto-shi-2024",
    "sakai":      "plateau-27140-sakai-shi-2024",
}

# Morphology-selected wards (diverse urban typologies)
DEFAULT_WARDS = ["chiyoda", "shinjuku", "setagaya", "chuo", "ota"]

DATA_DIR = Path("/root/autodl-tmp/data")
PLATEAU_TMP = Path("/root/autodl-tmp/plateau_data")
BATCH_SIZE = 5000
MIN_FACES = 10

# ============================================================
# CityJSON -> polygon_mesh conversion
# ============================================================
def extract_polygon_mesh(geometry_list, vertices, lod_target):
    """
    Extract polygon_mesh surfaces from CityJSON geometry for a given LOD.
    Solid: boundaries = [shell] = [[face]] = [[[ring]]]
    MultiSurface: boundaries = [surface] = [[ring]]
    """
    surfaces = []
    for geom in geometry_list:
        if str(geom.get('lod')) != str(lod_target):
            continue
        gtype = geom.get('type')
        boundaries = geom.get('boundaries', [])
        
        if gtype == 'Solid':
            for shell in boundaries:
                for face in shell:
                    if not face: continue
                    ring = face[0]
                    if len(ring) < 3: continue
                    surfaces.append([list(vertices[vi]) for vi in ring])
        
        elif gtype == 'MultiSurface':
            for surf in boundaries:
                if not surf: continue
                ring = surf[0]
                if len(ring) < 3: continue
                surfaces.append([list(vertices[vi]) for vi in ring])
    
    return surfaces


def extract_building_meshes(cityjson_path):
    """Parse PLATEAU CityJSON -> {building_id: {lod1_mesh, lod2_mesh, attrs}}."""
    with open(cityjson_path) as f:
        cj = json.load(f)
    
    vertices = cj.get('vertices', [])
    cobjs = cj.get('CityObjects', {})
    
    records = {}
    skipped_no_lod1 = 0
    skipped_no_lod2 = 0
    skipped_few_faces = 0
    
    for key, obj in cobjs.items():
        geoms = obj.get('geometry', [])
        attrs = obj.get('attributes', {})
        building_id = attrs.get('building_id', key)
        
        lod1_mesh = extract_polygon_mesh(geoms, vertices, '1')
        lod2_mesh = extract_polygon_mesh(geoms, vertices, '2')
        
        if not lod1_mesh:
            skipped_no_lod1 += 1; continue
        if not lod2_mesh:
            skipped_no_lod2 += 1; continue
        if len(lod1_mesh) < MIN_FACES or len(lod2_mesh) < MIN_FACES:
            skipped_few_faces += 1; continue
        
        records[building_id] = {
            'lod1_mesh': lod1_mesh,
            'lod2_mesh': lod2_mesh,
            'attrs': attrs,
        }
    
    return records, skipped_no_lod1, skipped_no_lod2, skipped_few_faces


# ============================================================
# Property computation (batched)
# ============================================================
def compute_properties_for_side(records, side_key='lod1_mesh'):
    """Compute 25 properties for one LOD side (batched)."""
    all_ids = list(records.keys())
    n_buildings = len(all_ids)
    n_batches = (n_buildings + BATCH_SIZE - 1) // BATCH_SIZE
    
    accum = {p: {} for p in PROP_NAMES}
    
    for bi in range(n_batches):
        batch_ids = all_ids[bi*BATCH_SIZE:(bi+1)*BATCH_SIZE]
        batch_od = {"obj": {}}
        for bid in batch_ids:
            batch_od["obj"][bid] = {"polygon_mesh": records[bid][side_key]}
        
        proc = ObjectPropertiesProcessor(batch_od, vector_normalization=True)
        side = proc.prop_vals_dict
        
        for p in PROP_NAMES:
            p_side = side.get(p, {}).get("obj", {})
            for bid in batch_ids:
                val = p_side.get(bid)
                if val is not None:
                    accum[p][bid] = val
        
        if (bi + 1) % 20 == 0 or bi == n_batches - 1:
            logger.info(f"  [{side_key}] batch {bi+1}/{n_batches} ({len(batch_ids)} bldgs)")
    
    return accum


# ============================================================
# Save outputs
# ============================================================
def save_city_output(city_name, records, lod1_props, lod2_props):
    """Save parquet + joblib + manifest."""
    out_dir = DATA_DIR / city_name
    out_dir.mkdir(parents=True, exist_ok=True)
    
    # Build merged DataFrame
    rows = []
    for bid in records:
        row = {"building_id": bid}
        for p in PROP_NAMES:
            row[f"lod1_{p}"] = lod1_props.get(p, {}).get(bid, None)
            row[f"lod2_{p}"] = lod2_props.get(p, {}).get(bid, None)
        row["attrs"] = json.dumps(records[bid]["attrs"], ensure_ascii=False)
        row["n_faces_lod1"] = len(records[bid]["lod1_mesh"])
        row["n_faces_lod2"] = len(records[bid]["lod2_mesh"])
        rows.append(row)
    
    df = pd.DataFrame(rows)
    parquet_path = out_dir / "buildings.parquet"
    df.to_parquet(parquet_path)
    logger.info(f"Saved {parquet_path} ({len(df)} rows)")
    
    # Save per-LOD object_dicts as joblib
    lod1_od = {"obj": {}}
    lod2_od = {"obj": {}}
    for bid in records:
        lod1_od["obj"][bid] = records[bid]["lod1_mesh"]
        lod2_od["obj"][bid] = records[bid]["lod2_mesh"]
    
    joblib.dump(lod1_od, out_dir / "object_dict_lod1.joblib")
    joblib.dump(lod2_od, out_dir / "object_dict_lod2.joblib")
    
    # Combined (cands=lod1, index=lod2 for cross-LoD matching)
    comb_od = {"cands": {}, "index": {}}
    for bid in records:
        comb_od["cands"][bid] = records[bid]["lod1_mesh"]
        comb_od["index"][bid] = records[bid]["lod2_mesh"]
    joblib.dump(comb_od, out_dir / "object_dict_combined.joblib")
    
    # Manifest
    manifest = {
        "city": city_name,
        "source": "PLATEAU (Japan MLIT)",
        "dataset_id": TOKYO_WARDS.get(city_name, ""),
        "n_buildings": len(records),
        "n_lod1_faces": sum(len(r["lod1_mesh"]) for r in records.values()),
        "n_lod2_faces": sum(len(r["lod2_mesh"]) for r in records.values()),
        "properties": PROP_NAMES,
        "lod1_label": "LOD1 (Solid, coarse block model)",
        "lod2_label": "LOD2 (MultiSurface, detailed roof model)",
        "coordinate_system": "JGD2011 (EPSG:6697)",
        "min_faces_filter": MIN_FACES,
        "batch_size": BATCH_SIZE,
    }
    with open(out_dir / "manifest.json", "w") as f:
        json.dump(manifest, f, indent=2, ensure_ascii=False)
    
    logger.info(f"Manifest: n_buildings={len(records)}")
    
    # Cross-LoD pairs (all pos pairs for matching task)
    pairs = []
    bldg_ids = list(records.keys())
    for i, bid in enumerate(bldg_ids):
        pairs.append({"cand_idx": i, "index_idx": i, "label": 1,
                       "cand_id": bid, "index_id": bid})
    pairs_df = pd.DataFrame(pairs)
    pairs_df.to_parquet(out_dir / "crosslod_pairs.parquet")
    
    return out_dir


# ============================================================
# Main pipeline
# ============================================================
def build_city(city_name, skip_download=False):
    """Full pipeline for one city."""
    dataset_id = TOKYO_WARDS[city_name]
    cj_path = PLATEAU_TMP / f"{city_name}_alllod.city.json"
    
    t0 = time.time()
    
    # Step 1-2: Download + prebuild + export CityJSON
    if not skip_download or not cj_path.exists():
        logger.info(f"[{city_name}] Installing {dataset_id}...")
        pk.install_dataset(dataset_id)
        
        logger.info(f"[{city_name}] Prebuilding...")
        os.system(f"plateaukit prebuild {dataset_id} 2>&1")
        
        logger.info(f"[{city_name}] Exporting CityJSON (all LODs)...")
        ds = pk.load_dataset(dataset_id)
        PLATEAU_TMP.mkdir(parents=True, exist_ok=True)
        ds.to_cityjson(str(cj_path), types=['bldg'], lod_mode='all', seq=False, split=1)
        logger.info(f"[{city_name}] CityJSON: {cj_path.stat().st_size/1e6:.1f} MB")
    else:
        logger.info(f"[{city_name}] Using cached CityJSON: {cj_path}")
    
    # Step 3: Extract polygon meshes
    logger.info(f"[{city_name}] Extracting building meshes...")
    records, no_lod1, no_lod2, few_faces = extract_building_meshes(str(cj_path))
    logger.info(f"[{city_name}] {len(records)} buildings with both LODs "
                f"(skipped: no_lod1={no_lod1}, no_lod2={no_lod2}, <{MIN_FACES}faces={few_faces})")
    
    if len(records) == 0:
        logger.error(f"[{city_name}] No valid buildings!")
        return None
    
    # Step 4-5: Compute properties
    logger.info(f"[{city_name}] Computing LOD1 properties...")
    lod1_props = compute_properties_for_side(records, 'lod1_mesh')
    
    logger.info(f"[{city_name}] Computing LOD2 properties...")
    lod2_props = compute_properties_for_side(records, 'lod2_mesh')
    
    # Step 6: Save
    logger.info(f"[{city_name}] Saving outputs...")
    out_dir = save_city_output(city_name, records, lod1_props, lod2_props)
    
    elapsed = time.time() - t0
    logger.info(f"[{city_name}] DONE in {elapsed:.0f}s -> {out_dir}")
    
    return out_dir


# ============================================================
# CLI
# ============================================================
if __name__ == '__main__':
    parser = argparse.ArgumentParser(description='PLATEAU Benchmark Builder')
    parser.add_argument('--city', type=str, help='City name (key in TOKYO_WARDS)')
    parser.add_argument('--all', action='store_true', help='Build all default wards')
    parser.add_argument('--skip-download', action='store_true', help='Reuse cached CityJSON')
    args = parser.parse_args()
    
    if args.city:
        cities = [args.city]
    elif args.all:
        cities = DEFAULT_WARDS
    else:
        cities = DEFAULT_WARDS
        logger.info(f"Using defaults: {cities}")
    
    for city in cities:
        if city not in TOKYO_WARDS:
            logger.error(f"Unknown city: {city}. Available: {list(TOKYO_WARDS.keys())}")
            continue
        try:
            build_city(city, skip_download=args.skip_download)
        except Exception as e:
            logger.exception(f"[{city}] FAILED: {e}")
    
    logger.info("All done.")