Files
cad-building-showcase/scripts/write_web_showcase.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

186 lines
7.5 KiB
Python
Executable File

#!/usr/bin/env python3
"""Instantiate the static Three.js web showcase template."""
from __future__ import annotations
import argparse
import json
import shutil
import time
from pathlib import Path
def default_template() -> Path:
return Path(__file__).resolve().parents[1] / "assets" / "web-showcase-template"
def parse_args() -> argparse.Namespace:
parser = argparse.ArgumentParser(description=__doc__)
parser.add_argument("--template", default=str(default_template()), help="Template folder")
parser.add_argument("--glb", help="Source default GLB model")
parser.add_argument("--metadata", help="model_metadata.json from Blender script")
parser.add_argument("--variants-manifest", help="Manifest from build_showcase_variants.py")
parser.add_argument("--out-dir", required=True, help="Web output folder")
parser.add_argument("--title", default="CAD 建筑 Web 展示模型")
return parser.parse_args()
def copy_template(template: Path, out_dir: Path):
if not template.exists():
raise SystemExit(f"Template not found: {template}")
out_dir.mkdir(parents=True, exist_ok=True)
for item in template.iterdir():
dest = out_dir / item.name
if item.is_dir():
shutil.copytree(item, dest, dirs_exist_ok=True)
else:
shutil.copy2(item, dest)
def patch_index(out_dir: Path, title: str, build: str):
"""Fill template placeholders and stamp a cache-busting build token.
Browsers cache ES modules and GLB aggressively; the ?v=<build> query on
app.js / model.glb / model_metadata.json forces a reload after a rebuild.
"""
for name in ("index.html", "app.js"):
path = out_dir / name
if not path.exists():
continue
text = path.read_text(encoding="utf-8")
text = text.replace("{{TITLE}}", title).replace("{{BUILD}}", build)
path.write_text(text, encoding="utf-8")
def resolve_manifest_path(manifest_path: Path, value: str) -> Path:
path = Path(value)
return path if path.is_absolute() else manifest_path.parent / path
def load_variants(manifest_path: Path | None) -> tuple[dict | None, list[dict]]:
if not manifest_path:
return None, []
if not manifest_path.exists():
raise SystemExit(f"Variants manifest not found: {manifest_path}")
manifest = json.loads(manifest_path.read_text(encoding="utf-8"))
variants = list(manifest.get("variants", []))
if not variants:
raise SystemExit(f"Variants manifest has no variants: {manifest_path}")
return manifest, variants
def default_variant(manifest: dict | None, variants: list[dict]) -> dict | None:
if not variants:
return None
default_key = (manifest or {}).get("default_key", "standard")
for variant in variants:
if variant.get("key") == default_key:
return variant
return variants[0]
def copy_variant_assets(manifest_path: Path | None, variants: list[dict], out_dir: Path) -> list[dict]:
web_variants = []
for variant in variants:
source_value = variant.get("source_glb") or variant.get("source") or variant.get("file")
if not source_value:
raise SystemExit(f"Variant is missing source_glb/source/file: {variant}")
source = resolve_manifest_path(manifest_path, source_value) if manifest_path else Path(source_value)
if not source.exists():
raise SystemExit(f"Variant GLB not found: {source}")
dest_name = Path(variant.get("file") or f"{variant.get('key', source.stem)}.glb").name
shutil.copy2(source, out_dir / dest_name)
web_variant = {
"key": variant.get("key", Path(dest_name).stem),
"label": variant.get("label", variant.get("key", dest_name)),
"file": dest_name,
}
if variant.get("description"):
web_variant["description"] = variant["description"]
web_variants.append(web_variant)
return web_variants
def inferred_default_glb(args_glb: str | None, manifest_path: Path | None, manifest: dict | None, variants: list[dict]) -> Path:
if args_glb:
return Path(args_glb)
variant = default_variant(manifest, variants)
if not variant:
raise SystemExit("Either --glb or --variants-manifest is required")
source_value = variant.get("source_glb") or variant.get("source") or variant.get("file")
return resolve_manifest_path(manifest_path, source_value) if manifest_path else Path(source_value)
def inferred_metadata(args_metadata: str | None, manifest_path: Path | None, manifest: dict | None, variants: list[dict]) -> Path:
if args_metadata:
return Path(args_metadata)
variant = default_variant(manifest, variants)
metadata_value = variant.get("metadata") if variant else None
if not metadata_value:
raise SystemExit("Either --metadata or a default variant metadata entry is required")
return resolve_manifest_path(manifest_path, metadata_value) if manifest_path else Path(metadata_value)
def site_trees_from_spec(spec_path: Path | None) -> list[list[float]]:
"""Tree anchor points (plan meters) for the viewer's instanced low-poly trees.
site_context_from_dump.py emits street trees as short posts under the
custom `trees` category; the viewer hides those posts and renders
trunk+crown InstancedMeshes at these midpoints instead.
"""
if not spec_path or not spec_path.exists():
return []
try:
spec = json.loads(spec_path.read_text(encoding="utf-8"))
except (OSError, json.JSONDecodeError):
return []
trees = []
for floor in spec.get("floors", {}).values():
for seg in floor.get("segments", {}).get("trees", []):
trees.append([
round((seg["start"][0] + seg["end"][0]) / 2, 2),
round((seg["start"][1] + seg["end"][1]) / 2, 2),
])
return trees
def write_assets(glb: Path, metadata: Path, out_dir: Path, web_variants: list[dict], site_trees: list[list[float]]):
if not glb.exists():
raise SystemExit(f"GLB not found: {glb}")
if not metadata.exists():
raise SystemExit(f"Metadata not found: {metadata}")
shutil.copy2(glb, out_dir / "model.glb")
meta = json.loads(metadata.read_text(encoding="utf-8"))
meta.setdefault("files", {})["glb"] = "model.glb"
if web_variants:
meta["model_variants"] = web_variants
if site_trees:
meta["site_trees"] = site_trees
(out_dir / "model_metadata.json").write_text(
json.dumps(meta, ensure_ascii=False, indent=2),
encoding="utf-8",
)
def main() -> int:
args = parse_args()
out_dir = Path(args.out_dir)
manifest_path = Path(args.variants_manifest) if args.variants_manifest else None
manifest, variants = load_variants(manifest_path)
copy_template(Path(args.template), out_dir)
build = str(int(time.time()))
patch_index(out_dir, args.title, build)
web_variants = copy_variant_assets(manifest_path, variants, out_dir)
glb = inferred_default_glb(args.glb, manifest_path, manifest, variants)
metadata = inferred_metadata(args.metadata, manifest_path, manifest, variants)
variant = default_variant(manifest, variants)
spec_value = variant.get("spec") if variant else None
spec_path = resolve_manifest_path(manifest_path, spec_value) if (manifest_path and spec_value) else None
write_assets(glb, metadata, out_dir, web_variants, site_trees_from_spec(spec_path))
print(json.dumps({"web_dir": str(out_dir), "entry": str(out_dir / "index.html")}, ensure_ascii=False))
return 0
if __name__ == "__main__":
raise SystemExit(main())