Files
cad-building-showcase/scripts/assemble_campus.py
zhengwr 6ace84ffba Campus pipeline hardening: backend parity, wall union, mullion grids, Draco tooling
Sandbox round (Linux):
- detect_sheet_frames.py: multi-frame sheet splitter (column AND row layouts),
  grid-vote per-floor offsets, section-elevation harvesting for storey heights
- dwg_dump_json.mjs + dwgjson_to_dxf.py: WASM libredwg DWG->DXF fallback
  (blocks/INSERT preserved, ATTRIB->TEXT so axis labels survive)
- assemble_campus.py: manifest-driven campus assembly with mandatory
  neighbour-gap gate (overlap = exit 3, 0.1-0.3m flagged as expansion joints)
- site_context_from_dump.py: site-context floors (ground/roads/parking/
  fence/trees/context massings) from site-plan dumps
- write_offline_viewer.py + assets/offline-viewer-libs/: fully-offline
  single-file viewer (vendored three r147 + pako, gzip-embedded GLB)
- audit: clip-scoped coverage figures; report: multi_frame_sheet warning;
  audit gate floors_aligned catches the diagonal-staircase failure mode

Mac round:
- build_blender_showcase.py now honors slab_bounds_fallback and prefers
  footprint polygons for generated roofs (bounds rects made roof plates jut
  past the facade and buried campuses under full-extent slabs); contract now
  matches spec_to_glb.py exactly
- merge_wall_solids (default off) in BOTH backends: shapely union in
  spec_to_glb.py, native delaunay_2d_cdt union in Blender; endpoint-shared
  wall ends pre-extended w/2 so L-corners close seamlessly (flat caps leave
  a notch a union alone cannot fill) while openings stay flat
- glazing_mullions (default off): curtain-wall panel grid (verticals every
  glazing_panel_w + floor-line transoms) as pseudo wall segments in the
  <floor>__walls node; glass pane kept
- build_showcase_variants.py keeps source_file=="site" floors intact in all
  variants (roads/trees live on filtered categories)
- web template: instanced low-poly trees from metadata site_trees,
  grade-level shadow catcher (was at basement depth), data-URI favicon
- tools/compress.mjs deps pinned (package.json); 15MB campus GLB -> 0.57MB
- tests: 24 -> 52 checks (wall union, mullions, byte-identical defaults)

Co-Authored-By: Claude Fable 5 <noreply@anthropic.com>
2026-07-02 17:44:41 +08:00

230 lines
9.8 KiB
Python
Raw Blame History

This file contains ambiguous Unicode characters
This file contains Unicode characters that might be confused with other characters. If you think that this is intentional, you can safely ignore this warning. Use the Escape button to reveal them.
#!/usr/bin/env python3
"""Assemble a campus spec from per-building specs + a site manifest.
Formalizes the spec-level merge proven on the 贝昂 case: every building's
segments/footprints/caps are rotated+translated into campus-local meters,
floor keys get building prefixes, site-context floors (from
site_context_from_dump.py) are appended, and per-building roof_specs are
re-keyed. Placement anchors follow the SKILL rules: WALL corners / coordinate
callouts, never roof envelopes.
Manifest (site_manifest.json) schema used here:
{
"campus_origin_surveying_m": [349505.372, 664163.589],
"rotation_deg": 7.5711, # campus grid rotation (site vs building sheets)
"buildings": {
"1#厂房": {"spec": "work/building_spec.json", "prefix": "",
"model_anchor_m": [7.3, 8.3], # point in the building spec (meters)
"survey_anchor_m": [349582.714, 664188.492]}, # where it lands (surveying meters)
"2#厂房": {"spec": "work/spec_2.json", "prefix": "2", ...}
}
}
Buildings without a "spec" entry are skipped (e.g. "status": "待建模").
Checks performed (loud, not silent): pairwise wall-envelope overlap between
buildings (negative gaps FAIL), and each building inside the site bounds if
--site-bounds is given.
Usage:
python3 assemble_campus.py --manifest work/site_manifest.json \
[--site-floors work/site_floors.json] --out work/campus_spec.json \
[--project-name 厂区] [--roof-specs work/roof_specs.json]
"""
from __future__ import annotations
import argparse
import copy
import json
import math
import sys
from pathlib import Path
def parse_args() -> argparse.Namespace:
p = argparse.ArgumentParser(description=__doc__)
p.add_argument("--manifest", required=True)
p.add_argument("--site-floors", default=None, help="site_context_from_dump.py output to merge")
p.add_argument("--out", required=True)
p.add_argument("--project-name", default=None)
p.add_argument("--description", default=None)
p.add_argument("--gap-warn", type=float, default=0.10,
help="warn when two buildings' wall envelopes are closer than this (m); overlap always fails")
p.add_argument("--allow-overlap", action="store_true", help="downgrade overlap FAIL to warning")
return p.parse_args()
def make_xf(anchor, survey_m, origin_m, cos_t, sin_t):
ax, ay = anchor
tx, ty = survey_m[0] - origin_m[0], survey_m[1] - origin_m[1]
def xf(p):
dx, dy = p[0] - ax, p[1] - ay
return [round(dx * cos_t - dy * sin_t + tx, 6), round(dx * sin_t + dy * cos_t + ty, 6)]
return xf
def transform_floors(spec: dict, xf) -> dict:
out = {}
for fk, fl in spec.get("floors", {}).items():
nf = copy.deepcopy(fl)
xs, ys = [], []
for segs in nf.get("segments", {}).values():
for s in segs:
s["start"] = xf(s["start"])
s["end"] = xf(s["end"])
xs += [s["start"][0], s["end"][0]]
ys += [s["start"][1], s["end"][1]]
if "footprint" in nf:
nf["footprint"]["polygons"] = [[xf(p) for p in poly] for poly in nf["footprint"]["polygons"]]
for cap in nf.get("caps", []):
cap["polygons"] = [[xf(p) for p in poly] for poly in cap["polygons"]]
if xs:
nf["bounds"] = [round(min(xs), 6), round(min(ys), 6), round(max(xs), 6), round(max(ys), 6)]
out[fk] = nf
return out
def wall_envelope_axis(floors: dict, cos_t: float, sin_t: float):
"""Ground-floor wall envelope in the rotated building-axis frame.
Uses the LOWEST floor with real walls: upper floors (roof machine rooms,
parapet-level structures) legitimately overhang by 1-2 m and would turn a
valid 0.19 m expansion joint into a false overlap alarm.
"""
ground = None
for fl in floors.values():
if len(fl.get("segments", {}).get("walls", [])) < 10:
continue
z = float(fl.get("z", 0))
if z < -0.5:
continue # basements are inset; the seam lives at ground level
if ground is None or z < float(ground.get("z", 0)):
ground = fl
if ground is None:
for fl in floors.values():
if len(fl.get("segments", {}).get("walls", [])) >= 10:
if ground is None or float(fl.get("z", 0)) < float(ground.get("z", 0)):
ground = fl
if ground is None:
return None
pts = []
for s in ground["segments"]["walls"]:
for p in (s["start"], s["end"]):
pts.append((p[0] * cos_t + p[1] * sin_t, -p[0] * sin_t + p[1] * cos_t))
xs = [p[0] for p in pts]
ys = [p[1] for p in pts]
return (min(xs), min(ys), max(xs), max(ys))
def envelope_gap(a, b):
"""Positive = separation, negative = overlap (axis-aligned in building frame)."""
dx = max(a[0] - b[2], b[0] - a[2])
dy = max(a[1] - b[3], b[1] - a[3])
if dx < 0 and dy < 0:
return max(dx, dy) # overlapping in both axes -> negative depth
return max(dx, dy)
def main() -> int:
args = parse_args()
manifest = json.loads(Path(args.manifest).read_text(encoding="utf-8"))
origin = manifest.get("campus_origin_surveying_m") or manifest.get("campus_origin_surveying_mm")
if origin is None:
raise SystemExit("manifest needs campus_origin_surveying_m")
if max(abs(origin[0]), abs(origin[1])) > 1e6: # mm legacy
origin = [origin[0] / 1000.0, origin[1] / 1000.0]
theta = math.radians(float(manifest.get("rotation_deg", 0.0)))
cos_t, sin_t = math.cos(theta), math.sin(theta)
base_spec = None
placed: dict[str, dict] = {}
envelopes: dict[str, tuple] = {}
for name, b in manifest.get("buildings", {}).items():
if not isinstance(b, dict) or "spec" not in b:
print(f"skip {name}: no spec (status: {b.get('status', '?') if isinstance(b, dict) else b})", file=sys.stderr)
continue
spec = json.loads(Path(b["spec"]).read_text(encoding="utf-8"))
if base_spec is None:
base_spec = spec
anchor = b.get("model_anchor_m") or b.get("model_anchor_center_m") or b.get("model_anchor_SE_wall_corner_m")
survey = b.get("survey_anchor_m") or b.get("survey_center_m")
if not anchor or not survey:
raise SystemExit(f"{name}: manifest entry needs model_anchor_m + survey_anchor_m")
xf = make_xf(anchor, survey, origin, cos_t, sin_t)
floors = transform_floors(spec, xf)
prefix = str(b.get("prefix", ""))
placed.update({prefix + fk: fl for fk, fl in floors.items()})
env = wall_envelope_axis(floors, cos_t, sin_t)
if env:
envelopes[name] = env
# re-key this building's roof_specs into the campus config later
b["_roof_specs"] = [
{**r, "floor_key": prefix + str(r.get("floor_key")),
"footprint_from": [prefix + str(k) for k in r.get("footprint_from", [r.get("floor_key")])]}
for r in spec.get("source", {}).get("config", {}).get("roof_specs", [])
]
if base_spec is None:
raise SystemExit("no buildings with specs in manifest")
# gap audit
names = list(envelopes)
failures = []
for i in range(len(names)):
for j in range(i + 1, len(names)):
gap = envelope_gap(envelopes[names[i]], envelopes[names[j]])
tag = f"{names[i]} <-> {names[j]}"
if gap < 0:
failures.append(f"OVERLAP {tag}: {gap:.3f} m — placement bug (roof-envelope anchor? flip?)")
elif gap < args.gap_warn:
print(f"NOTE {tag}: gap {gap:.3f} m — 贴建/变形缝? corroborate per SKILL rules", file=sys.stderr)
else:
print(f"gap {tag}: {gap:.2f} m", file=sys.stderr)
if failures and not args.allow_overlap:
for f in failures:
print("FAIL " + f, file=sys.stderr)
return 3
for f in failures:
print("WARN(allowed) " + f, file=sys.stderr)
floors: dict = {}
site_keys: list[str] = []
if args.site_floors:
site = json.loads(Path(args.site_floors).read_text(encoding="utf-8"))
wall_bounds = [fl["bounds"] for fl in placed.values() if len(fl.get("segments", {}).get("walls", [])) >= 10]
for k, v in site.get("floors", {}).items():
if k.startswith("CTX"):
w = v.get("segments", {}).get("walls", [])
if w:
xs = [q for s in w for q in (s["start"][0], s["end"][0])]
ys = [q for s in w for q in (s["start"][1], s["end"][1])]
cx, cy = (min(xs) + max(xs)) / 2, (min(ys) + max(ys)) / 2
if any(b[0] - 1 <= cx <= b[2] + 1 and b[1] - 1 <= cy <= b[3] + 1 for b in wall_bounds):
continue # covered by a real model
floors[k] = v
site_keys.append(k)
base_spec.setdefault("categories", {}).update(site.get("categories", {}))
floors.update(placed)
campus = base_spec
campus["floors"] = floors
campus["project"] = {
"name": args.project_name or manifest.get("project_name", "厂区"),
"description": args.description or manifest.get("description", "多栋建筑 + 场地(assemble_campus.py 合成)"),
}
cfg = campus.setdefault("source", {}).setdefault("config", {})
cfg["roof_specs"] = [r for b in manifest.get("buildings", {}).values()
if isinstance(b, dict) for r in b.get("_roof_specs", [])]
cfg["floor_order"] = site_keys + [k for k in placed]
out = Path(args.out)
out.parent.mkdir(parents=True, exist_ok=True)
out.write_text(json.dumps(campus, ensure_ascii=False, indent=1), encoding="utf-8")
print(json.dumps({"out": str(out), "floors": len(floors), "buildings": len(envelopes),
"site_floors": len(site_keys)}, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())