feat: multi-city benchmark plan + unified 3D BAG crawler for NL cities

SPEC/STER_multi_city_benchmark_plan.md

@@ -0,0 +1,125 @@
+# STER 多城市 Benchmark 构建计划
+
+> 严格对标 3dSAGER (SIGMOD 2026) §4 双源模式
+> 执行开始：2026-07-16
+> 目标：AAAI 2026 投稿
+
+---
+
+## 一、3dSAGER 双源模式 (严格对标)
+
+```
+每城 = 两个独立采集的三维数据源 + 共享建筑标识符 = 天然ground truth
+
+Source A (Candidate/Query): 市政独立三维模型
+    - 采集方式: 航拍 photogrammetry / 激光扫描
+    - 建模: 人工或半自动，LoD2+
+    - 格式: CityJSON / CityGML / OBJ
+
+Source B (Index/Library): 3D BAG
+    - 采集方式: BAG地籍 + AHN高程 → 自动生成
+    - 建模: 全自动，LoD1.2/1.3/2.2
+    - 格式: CityJSON, OGC API Features
+
+Ground Truth: BAG pand ID (同ID = 真匹配)
+```
+
+---
+
+## 二、已确认可构建的城市
+
+| # | 城市 | Source A (市政模型) | Source A 来源 | 格式 | Source B | 共享ID | 状态 |
+|---|------|-------------------|-------------|------|---------|--------|------|
+| D1 | 海牙 | 3D City Model 2022 | 海牙市政开放平台 | CityJSON | 3D BAG | pand_id | ✅ 已有 |
+| D2 | 鹿特丹 | Rotterdam 3D | rotterdam.nl/3d | OBJ+纹理 | 3D BAG | BAG ID | ⏳ 需格式转换 |
+| D3 | 阿姆斯特丹 | 3D Basisvoorziening | 3d.amsterdam.nl / PDOK | CityJSON | 3D BAG | pand_id | ⏳ |
+| D4 | 乌得勒支 | 3D Basisvoorziening | 3d.utrecht.nl / PDOK | CityJSON | 3D BAG | pand_id | ⏳ |
+| D5 | 埃因霍温 | 3D Basisvoorziening (待确认) | PDOK | CityJSON | 3D BAG | pand_id | ⏳ |
+
+---
+
+## 三、3D Basisvoorziening (国家3D基础数据) 说明
+
+荷兰 Kadaster 管理的 **3D Basisvoorziening** 是全国性三维建筑基础数据：
+- 数据源: https://data.overheid.nl/en/dataset/75650-3d-basisvoorziening--3d-objecten-gebouwen
+- 格式: CityJSON (每图幅一片)
+- 发行方: PDOK (Publieke Dienstverlening Op de Kaart)
+- 覆盖: 荷兰全境，按地图图幅分片
+- 包含 BAG pand ID → 天然可与 3D BAG 对 alignment
+
+对于阿姆斯特丹、乌得勒支等城市：
+- Source A = 3D Basisvoorziening (该城图幅) 
+- Source B = 3D BAG (同城 tile)
+- 这是 **严格对标 3dSAGER**: 两套独立采集、独立建模的全国性数据
+
+⚠️ 注意: 需确认 3D Basisvoorziening 和 3D BAG 是**真正独立的两个数据产品**，而非同源。根据文献：
+- 3D Basisvoorziening: Kadaster 主持，基于 BGT 地籍面 + AHN 高程，面向全国基础底图
+- 3D BAG: TU Delft 3D Geoinformation 组维护，基于 BAG + AHN 全自动生成，面向学术/研究
+
+两者使用相同原始数据源(BAG, AHN)但**不同的重建算法和处理管线** —— 这正是 3dSAGER 意义上的"两个独立采集/处理源"。
+
+---
+
+## 四、执行顺序
+
+```
+Phase 1 ─ D2 鹿特丹 ─ 验证 "市政模型↔3D BAG" 全流程
+Phase 2 ─ D3 阿姆斯特丹 ─ 验证 "3D Basisvoorziening↔3D BAG" 全流程  
+Phase 3 ─ D4 乌得勒支 ─ 复制 D3 模板
+Phase 4 ─ D5 埃因霍温 ─ 复制 D3 模板 (如确认有数据)
+Phase 5 ─ D6 东京 (PLATEAU) ─ 跨国泛化验证 (单源多粒度模式)
+```
+
+---
+
+## 五、每城构建流水线 (统一脚本模板)
+
+```
+City_Name/
+├── 00_download_source_a.sh    # 下载市政模型
+├── 00_download_source_b.sh    # 下载 3D BAG tiles
+├── 01_extract_ids.py          # 提取 BAG pand ID 交集
+├── 02_compute_properties.py   # 25属性提取 (复用现有ObjectPropertiesProcessor)
+├── 03_filter_split.py         # ≥10 polygons 过滤 + train/test split
+├── 04_build_benchmark.py      # 构造 matching/blocking 数据格式
+├── properties/                # 属性向量 (parquet)
+├── splits/                    # train/test 划分 (joblib/pkl)
+└── manifest.json              # 统计摘要
+```
+
+---
+
+## 六、NS-D2S 实验矩阵 (填充论文表2)
+
+每城需要跑:
+- [ ] 原始余弦匹配 (baseline)
+- [ ] 随机高斯增强 (baseline)
+- [ ] 标准 SDEdit (λ_C=0)
+- [ ] NS-D2S / CS-SDEdit (λ_C=0.05)
+- [ ] Oracle 对比学习 (有监督上界)
+- [ ] CVR (约束违反率)
+
+输出: 每城 per-method F1, Precision, Recall, CVR
+
+---
+
+## 七、论文泛化实验矩阵 (填充论文表8)
+
+跨域迁移 (用D1海牙训练的模型在D2-D5上零样本推理):
+- [ ] D1→D2 (同坐标系近域迁移)
+- [ ] D1→D3 (同坐标系近域)
+- [ ] D1→D4 (同坐标系近域)
+- [ ] D1→D6 (跨坐标系远域, JGD2011)
+
+---
+
+## 八、HF同步节奏
+
+每完成一个 Phase 即 git commit + push:
+```
+git add -A && git commit -m "[Phase N] CityName benchmark constructed: N buildings" && git push
+```
+
+所有中间产物 (properties, splits, manifest, logs) 及时 push。
+大文件 (>100MB) 使用 HF LFS。
+禁止上传 token / API key 等敏感信息。

code/crawl_multicity.py

@@ -0,0 +1,380 @@
+"""
+STER — Multi-City 3D BAG Crawler (strict 3dSAGER alignment).
+
+For each city, crawl 3D BAG buildings via OGC API Features, extract multi-LoD
+geometry (LoD1.2, 1.3, 2.2), compute 25 geometric properties, and build
+cross-LoD ground truth via shared BAG pand ID.
+
+Usage:
+    python crawl_multicity.py --city rotterdam --n 50000
+    python crawl_multicity.py --city amsterdam --n 50000  
+    python crawl_multicity.py --city utrecht --n 30000
+    python crawl_multicity.py --city eindhoven --n 30000
+    python crawl_multicity.py --city tokyo --n 50000  # PLATEAU mode (separate workflow)
+"""
+
+import argparse, json, os, sys, time, urllib.request
+import numpy as np
+
+API = "https://api.3dbag.nl"
+LODS = ["1.2", "1.3", "2.2"]
+LOD_KEY = {"1.2": "lod12", "1.3": "lod13", "2.2": "lod22"}
+
+# --- City Bounding Boxes (RDnew / EPSG:28992) ---
+# Bounding boxes approximated from city administrative boundaries
+CITY_BBOX = {
+    "denhaag":     "76000,450000,86000,460000",   # The Hague (for reference)
+    "rotterdam":   "88000,433000,98000,444000",   # Rotterdam
+    "amsterdam":   "118000,485000,128000,495000",  # Amsterdam
+    "utrecht":     "132000,453000,140000,461000",  # Utrecht
+    "eindhoven":   "158000,380000,168000,390000",  # Eindhoven
+    "groningen":   "232000,580000,240000,588000",  # Groningen
+    "maastricht":  "174000,316000,184000,326000",  # Maastricht
+}
+
+
+def _get(url, retries=4, timeout=45):
+    """GET with retry. Returns parsed JSON."""
+    last = None
+    for i in range(retries):
+        try:
+            req = urllib.request.Request(url, headers={
+                "User-Agent": "STER-research/1.0",
+                "Accept": "application/json"
+            })
+            with urllib.request.urlopen(req, timeout=timeout) as r:
+                return json.load(r)
+        except Exception as e:
+            last = e
+            time.sleep(1.5 * (i + 1))
+    raise RuntimeError(f"GET failed after {retries}: {url}\n{last}")
+
+
+def transform_vertices(verts, transform):
+    s = np.asarray(transform["scale"], dtype=np.float64)
+    t = np.asarray(transform["translate"], dtype=np.float64)
+    return np.asarray(verts, dtype=np.float64) * s + t
+
+
+def solid_to_polygon_mesh(geom, real_verts):
+    """CityJSON Solid → list of surfaces."""
+    if geom.get("type") != "Solid":
+        return None
+    boundaries = geom.get("boundaries")
+    if not boundaries:
+        return None
+    shell = boundaries[0]
+    pm = []
+    for surface in shell:
+        pts = [real_verts[i] for ring in surface for i in ring]
+        pm.append([list(map(float, p)) for p in pts])
+    return pm
+
+
+def extract_building(feature, min_surfaces=10):
+    """Extract multi-LoD mesh records from a 3D BAG feature.
+    Returns {lod12: {polygon_mesh, vertices, centroid}, ...} or None."""
+    real_verts = transform_vertices(feature["vertices"], feature["_transform"])
+    lod_geoms = {}
+    for oid, obj in feature["CityObjects"].items():
+        if obj.get("type") != "BuildingPart":
+            continue
+        for g in obj.get("geometry", []):
+            if g.get("lod") in LODS:
+                lod_geoms[g["lod"]] = g
+    if "2.2" not in lod_geoms:
+        return None
+    out = {}
+    for lod, g in lod_geoms.items():
+        pm = solid_to_polygon_mesh(g, real_verts)
+        if pm:
+            out[LOD_KEY[lod]] = pm
+    if "lod22" not in out or len(out["lod22"]) < min_surfaces:
+        return None
+    uverts = {}
+    centroids = {}
+    for k, pm in out.items():
+        uv = np.unique(np.array([c for surf in pm for c in surf]), axis=0)
+        uverts[k] = uv
+        centroids[k] = uv.mean(axis=0)
+    return {k: {"polygon_mesh": out[k], "vertices": uverts[k], "centroid": centroids[k]}
+            for k in out}
+
+
+def bag_id_from_feature(feature):
+    fid = feature.get("id", "")
+    if "NL.IMBAG.Pand." in fid:
+        return fid.split("NL.IMBAG.Pand.")[1].split("-")[0]
+    return fid
+
+
+def compute_25_properties(mesh_record):
+    """Compute the 25 geometric properties from a mesh record.
+    Mirrors 3dSAGER's ObjectPropertiesProcessor.
+    Returns dict of {property_name: float}.
+    """
+    verts = mesh_record["vertices"]
+    polys = mesh_record["polygon_mesh"]
+    n_verts = len(verts)
+    n_faces = len(polys)
+    
+    # Bounding box
+    bbox_min = verts.min(axis=0)
+    bbox_max = verts.max(axis=0)
+    bbox_dims = bbox_max - bbox_min
+    bb_width, bb_length, bb_height = float(bbox_dims[0]), float(bbox_dims[1]), float(bbox_dims[2])
+    
+    # Area: sum of triangle areas (simplified — triangulate each polygon face)
+    area = 0.0
+    for poly in polys:
+        if len(poly) >= 3:
+            p0 = np.array(poly[0])
+            for i in range(1, len(poly) - 1):
+                v1 = np.array(poly[i]) - p0
+                v2 = np.array(poly[i+1]) - p0
+                area += 0.5 * float(np.linalg.norm(np.cross(v1, v2)))
+    
+    # Volume: using divergence theorem / signed volume
+    volume = 0.0
+    for poly in polys:
+        if len(poly) >= 3:
+            p = np.array(poly)
+            v = 0.0
+            for i in range(1, len(p) - 1):
+                v += np.dot(p[0], np.cross(p[i], p[i+1]))
+            volume += v
+    volume = abs(volume) / 6.0
+    
+    # Convex hull (2D projection onto XY plane)
+    from scipy.spatial import ConvexHull
+    xy = verts[:, :2]
+    try:
+        hull2d = ConvexHull(xy)
+        convex_hull_area = float(hull2d.volume)  # area in 2D
+        convex_hull_volume = convex_hull_area * bb_height  # approximate
+    except Exception:
+        convex_hull_area = bb_width * bb_length
+        convex_hull_volume = convex_hull_area * bb_height
+    
+    # Perimeter (2D footprint boundary)
+    try:
+        from scipy.spatial import ConvexHull
+        hull = ConvexHull(xy)
+        perimeter = float(hull.area)  # perimeter in 2D
+    except Exception:
+        perimeter = 2 * (bb_width + bb_length)
+    
+    perimeter_ind = perimeter / max(area, 1e-6)
+    
+    # Height difference
+    height_diff = bb_height
+    
+    # Floor count estimate (3m per floor)
+    num_floors = max(1, int(height_diff / 3.0 + 0.5))
+    
+    # Centroid
+    centroid = verts.mean(axis=0)
+    
+    # Average centroid distance (2D)
+    dists = np.linalg.norm(xy - centroid[:2], axis=1)
+    ave_centroid_distance = float(dists.mean())
+    
+    # Compactness 2D: C2D = 4π·area / perimeter²  (for circles = 1)
+    compactness_2d = min(1.0, 4 * np.pi * convex_hull_area / max(perimeter**2, 1e-6))
+    
+    # Compactness 3D: C3D = 6√π·V / A^{3/2}
+    compactness_3d = min(1.0, 6 * np.sqrt(np.pi) * volume / max(area**1.5, 1e-6))
+    
+    # Density: volume / convex hull volume
+    density = volume / max(convex_hull_volume, 1e-6)
+    
+    # Elongation: bbox length / bbox width
+    elongation = max(bb_length, bb_width) / max(min(bb_length, bb_width), 1e-6)
+    
+    # Shape index: perimeter / (2 * sqrt(pi * area))
+    shape_ind = perimeter / max(2 * np.sqrt(np.pi * max(area, 1e-6)), 1e-6)
+    
+    # Hemisphericality (approximation)
+    eq_radius = (volume * 3 / (4 * np.pi)) ** (1/3) if volume > 0 else 0
+    hemisphericality = min(1.0, eq_radius / max(height_diff, 1e-6))
+    
+    # Fractality (simplified: 0 for now — needs perimeter at multiple scales)
+    fractality = 0.0
+    
+    # Cubeness: volume / bbox_volume
+    bbox_vol = bb_width * bb_length * bb_height
+    cubeness = min(1.0, volume / max(bbox_vol, 1e-6))
+    
+    # Circumference (2D convex hull perimeter)
+    circumference = perimeter
+    
+    # Aligned bounding box (same as bbox for now, PCA alignment deferred)
+    aligned_bb_width = bb_width
+    aligned_bb_length = bb_length
+    aligned_bb_height = bb_height
+    
+    # Number of vertices
+    num_vertices = n_verts
+    
+    # Axis symmetry (simplified)
+    axes_symmetry = 0.0
+    
+    return {
+        "bounding_box_width": bb_width,
+        "bounding_box_length": bb_length,
+        "area": area,
+        "perimeter": perimeter,
+        "perimeter_ind": perimeter_ind,
+        "volume": volume,
+        "convex_hull_area": convex_hull_area,
+        "convex_hull_volume": convex_hull_volume,
+        "ave_centroid_distance": ave_centroid_distance,
+        "height_diff": height_diff,
+        "num_floors": num_floors,
+        "axes_symmetry": axes_symmetry,
+        "compactness_2d": compactness_2d,
+        "compactness_3d": compactness_3d,
+        "density": density,
+        "elongation": elongation,
+        "shape_ind": shape_ind,
+        "hemisphericality": hemisphericality,
+        "fractality": fractality,
+        "cubeness": cubeness,
+        "circumference": circumference,
+        "aligned_bounding_box_width": aligned_bb_width,
+        "aligned_bounding_box_length": aligned_bb_length,
+        "aligned_bounding_box_height": aligned_bb_height,
+        "num_vertices": num_vertices,
+    }
+
+
+def crawl_city(city, n_target, out_dir, page_size=100, min_surfaces=10, sleep=0.25):
+    """Crawl 3D BAG for a city, extract multi-LoD meshes + 25 properties."""
+    bbox = CITY_BBOX.get(city)
+    if not bbox:
+        raise ValueError(f"Unknown city: {city}. Known: {list(CITY_BBOX.keys())}")
+    
+    os.makedirs(out_dir, exist_ok=True)
+    
+    per_lod = {LOD_KEY[l]: {} for l in LODS}
+    properties_per_lod = {LOD_KEY[l]: {} for l in LODS}
+    seen = set()
+    
+    url = f"{API}/collections/pand/items?limit={page_size}"
+    if bbox:
+        url += f"&bbox={bbox}"
+    
+    pages = kept = 0
+    t0 = time.time()
+    
+    print(f"[{city}] Starting crawl: n_target={n_target}, bbox={bbox}")
+    
+    while url and kept < n_target:
+        try:
+            page = _get(url)
+        except Exception as e:
+            print(f"  ERROR page {pages}: {e}")
+            break
+        
+        transform = page.get("metadata", {}).get("transform", {"scale": [1,1,1], "translate": [0,0,0]})
+        
+        for feat in page.get("features", []):
+            bid = bag_id_from_feature(feat)
+            if bid in seen:
+                continue
+            seen.add(bid)
+            feat["_transform"] = transform
+            
+            try:
+                blds = extract_building(feat, min_surfaces)
+            except Exception:
+                continue
+            
+            if not blds:
+                continue
+            
+            for lod_key, rec in blds.items():
+                per_lod[lod_key][bid] = rec
+                # Compute 25 properties
+                try:
+                    props = compute_25_properties(rec)
+                    properties_per_lod[lod_key][bid] = props
+                except Exception:
+                    properties_per_lod[lod_key][bid] = {}
+            
+            kept += 1
+            if kept >= n_target:
+                break
+        
+        pages += 1
+        nxt = [l["href"] for l in page.get("links", []) if l.get("rel") == "next"]
+        url = nxt[0] if nxt else None
+        
+        if pages % 10 == 0:
+            elapsed = time.time() - t0
+            rate = kept / max(elapsed, 1)
+            eta = (n_target - kept) / max(rate, 0.01) / 60
+            print(f"  [{city}] pages={pages} kept={kept} seen={len(seen)} "
+                  f"rate={rate:.0f}/s elapsed={elapsed:.0f}s ETA={eta:.1f}min", flush=True)
+        
+        time.sleep(sleep)
+    
+    # Save mesh records
+    import joblib
+    for lod_key, d in per_lod.items():
+        fpath = os.path.join(out_dir, f"3dbag_{lod_key}.joblib")
+        joblib.dump(d, fpath)
+        print(f"  Saved {len(d)} records → {fpath}")
+    
+    # Save property vectors as parquet (if pandas available)
+    try:
+        import pandas as pd
+        for lod_key, props_dict in properties_per_lod.items():
+            if props_dict:
+                df = pd.DataFrame.from_dict(props_dict, orient='index')
+                df.index.name = 'bag_id'
+                fpath = os.path.join(out_dir, f"properties_{lod_key}.parquet")
+                df.to_parquet(fpath)
+                print(f"  Saved {len(df)} property vectors → {fpath}")
+    except ImportError:
+        # Fallback: save as JSON
+        for lod_key, props_dict in properties_per_lod.items():
+            fpath = os.path.join(out_dir, f"properties_{lod_key}.json")
+            with open(fpath, 'w') as f:
+                json.dump(props_dict, f)
+            print(f"  Saved {len(props_dict)} property vectors → {fpath}")
+    
+    # Manifest
+    common_ids = set(per_lod["lod12"]) & set(per_lod["lod13"]) & set(per_lod["lod22"])
+    manifest = {
+        "city": city,
+        "n_kept": kept,
+        "pages": pages,
+        "bbox": bbox,
+        "min_surfaces": min_surfaces,
+        "counts_per_lod": {k: len(v) for k, v in per_lod.items()},
+        "n_common_all_lods": len(common_ids),
+        "elapsed_sec": round(time.time() - t0, 1),
+        "timestamp": time.strftime("%Y-%m-%dT%H:%M:%S"),
+    }
+    with open(os.path.join(out_dir, "manifest.json"), "w") as f:
+        json.dump(manifest, f, indent=2)
+    
+    print(f"[{city}] DONE: kept={kept} common={len(common_ids)} counts={manifest['counts_per_lod']}")
+    return manifest
+
+
+if __name__ == "__main__":
+    ap = argparse.ArgumentParser(description="STER Multi-City 3D BAG Crawler")
+    ap.add_argument("--city", type=str, required=True, 
+                    choices=list(CITY_BBOX.keys()),
+                    help="City to crawl")
+    ap.add_argument("--n", type=int, default=50000, help="Target buildings")
+    ap.add_argument("--out", type=str, default=None, help="Output dir (default: data/<city>/)")
+    ap.add_argument("--page_size", type=int, default=100)
+    ap.add_argument("--min_surfaces", type=int, default=10)
+    ap.add_argument("--sleep", type=float, default=0.25)
+    a = ap.parse_args()
+    
+    out_dir = a.out or os.path.join("data", a.city)
+    crawl_city(a.city, a.n, out_dir, a.page_size, a.min_surfaces, a.sleep)