File size: 6,076 Bytes
a525891 | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 | """
STER — 3DBAG multi-LoD crawler & extractor (v2).
Each 3DBAG building's BuildingPart embeds LoD1.2 / 1.3 / 2.2 Solid geometries.
This yields a natural "same identity, different geometric realisation" dataset:
same BAG id across LoDs -> positive (match) ; different ids -> negative.
Selection rule: keep a building iff its finest LoD (2.2) has >= min_surfaces
surfaces (the paper's >=10-polygon complexity filter). ALL available LoDs of a
kept building are retained (LoD1.2 boxes have few faces but we still want them
for cross-LoD experiments).
Output: object_dict-compatible per-LoD dicts, so the official
ObjectPropertiesProcessor can compute the exact same 25 properties.
"""
import argparse, json, os, 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"}
HAGUE_BBOX = "76000,450000,86000,460000" # RD / EPSG:28992 (default CRS of the API)
def _get(url, retries=4, timeout=45):
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 (each = list of [x,y,z]); mirrors the
repo's _get_polygon_mesh (first shell, flatten rings). No filtering here."""
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 _mesh_record(pm):
uverts = np.unique(np.array([c for surf in pm for c in surf]), axis=0)
return {"polygon_mesh": pm, "vertices": uverts, "centroid": uverts.mean(axis=0)}
def extract_building(feature, min_surfaces=10):
"""Return {lod_key: mesh_record} for a building, iff LoD2.2 exists and has
>= min_surfaces surfaces. All available LoDs are kept."""
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
return {k: _mesh_record(pm) for k, pm in out.items()}
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 crawl(n_target, out_dir, bbox=HAGUE_BBOX, page_size=100, min_surfaces=10, sleep=0.25):
os.makedirs(out_dir, exist_ok=True)
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()
while url and kept < n_target:
page = _get(url)
transform = page["metadata"]["transform"]
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
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 % 5 == 0:
print(f" pages={pages} kept={kept} seen={len(seen)} elapsed={time.time()-t0:.0f}s", flush=True)
time.sleep(sleep)
import joblib
for lod_key, d in per_lod.items():
joblib.dump(d, os.path.join(out_dir, f"3dbag_{lod_key}.joblib"))
common = set(per_lod["lod12"]) & set(per_lod["lod13"]) & set(per_lod["lod22"])
manifest = {"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), "common_ids": sorted(common),
"elapsed_sec": round(time.time() - t0, 1)}
with open(os.path.join(out_dir, "manifest.json"), "w") as f:
json.dump(manifest, f, indent=2)
print(f"DONE kept={kept} common_all_lods={len(common)} counts={manifest['counts_per_lod']} -> {out_dir}",
flush=True)
return manifest
if __name__ == "__main__":
ap = argparse.ArgumentParser()
ap.add_argument("--n", type=int, default=800)
ap.add_argument("--out", type=str, required=True)
ap.add_argument("--bbox", type=str, default=HAGUE_BBOX)
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()
crawl(a.n, a.out, a.bbox, a.page_size, a.min_surfaces, a.sleep)
|