Files
cad-building-showcase/scripts/spec_to_glb.py

778 lines
27 KiB
Python

#!/usr/bin/env python3
"""Blender-free building_spec.json -> GLB exporter.
Replicates the geometry rules of the skill's build_blender_showcase.py
(segment prisms, z-windows, footprint slabs, generated roofs, floor__category
naming) using trimesh, so the lightweight Web showcase can be produced without
a Blender install. The Web viewer recolours meshes by category from
model_metadata.json, so only correct node names + geometry are required.
"""
from __future__ import annotations
import argparse
import json
import math
import sys
from pathlib import Path
import numpy as np
import trimesh
from shapely.geometry import Polygon
import showcase_schema
CATEGORY_DRAW_ORDER = (
"grid",
"floor_lines",
"detail_lines",
"doors",
"railings",
"roof",
"glazing",
"walls",
"columns",
"beams",
)
def is_roof_floor(floor_key, floor):
t = f"{floor_key} {floor.get('name', '')}".upper()
return any(k in t for k in ("RF", "ROOF", "屋顶", "屋面"))
def z_window(category, z, height, floor_key, floor):
if category in {"walls", "columns", "glazing"}:
if category == "columns" and is_roof_floor(floor_key, floor):
return z, z + min(height, 1.15)
return z, z + height
if category == "beams":
return z + max(height - 0.55, 0.1), z + height
if category == "roof":
return z - 0.35, z + 0.08
if category == "railings":
return z + 0.05, z + min(1.20, height)
if category == "doors":
return z + 0.02, z + min(2.30, height)
if category in {"floor_lines", "detail_lines"}:
return z + 0.03, z + 0.09
if category == "grid":
return z + 0.01, z + 0.04
return z + 0.03, z + min(0.12, height)
# 12-triangle box from 8 corner verts
_BOX_TRIS = np.array(
[
[0, 1, 2],
[0, 2, 3], # bottom
[4, 6, 5],
[4, 7, 6], # top
[0, 4, 5],
[0, 5, 1],
[1, 5, 6],
[1, 6, 2],
[2, 6, 7],
[2, 7, 3],
[3, 7, 4],
[3, 4, 0],
],
dtype=np.int64,
)
def segment_box_verts(seg, z0, z1):
x1, y1 = seg["start"]
x2, y2 = seg["end"]
dx, dy = x2 - x1, y2 - y1
L = math.hypot(dx, dy)
if L <= 1e-7:
return None
hw = max(float(seg.get("width", 0.1)), 0.005) / 2.0
nx, ny = -dy / L * hw, dx / L * hw
z0 = float(seg.get("_z0", z0))
z1 = float(seg.get("_z1", z1))
return np.array(
[
(x1 + nx, y1 + ny, z0),
(x2 + nx, y2 + ny, z0),
(x2 - nx, y2 - ny, z0),
(x1 - nx, y1 - ny, z0),
(x1 + nx, y1 + ny, z1),
(x2 + nx, y2 + ny, z1),
(x2 - nx, y2 - ny, z1),
(x1 - nx, y1 - ny, z1),
],
dtype=np.float64,
)
def mesh_from_segments(segments, z0, z1):
V = []
F = []
base = 0
for seg in segments:
v = segment_box_verts(seg, z0, z1)
if v is None:
continue
V.append(v)
F.append(_BOX_TRIS + base)
base += 8
if not V:
return None
return trimesh.Trimesh(vertices=np.vstack(V), faces=np.vstack(F), process=False)
_POLY_FAILS = {"n": 0}
def mesh_from_polygons(polygons, z0, z1):
parts = []
for coords in polygons:
pts = [(float(x), float(y)) for x, y in coords]
if len(pts) >= 2 and pts[0] == pts[-1]:
pts = pts[:-1]
if len(pts) < 3:
continue
try:
poly = Polygon(pts)
if not poly.is_valid:
poly = poly.buffer(0)
if poly.is_empty or poly.area <= 0:
continue
m = trimesh.creation.extrude_polygon(poly, height=max(z1 - z0, 1e-4))
m.apply_translation((0, 0, z0))
parts.append(m)
except Exception as exc:
# Silent drops here erase slabs/caps/roofs wholesale (e.g. trimesh
# cannot triangulate without mapbox_earcut/manifold3d installed).
_POLY_FAILS["n"] += 1
if _POLY_FAILS["n"] <= 3:
print(
f"WARNING mesh_from_polygons failed ({exc}); slabs/caps/roofs may be "
"missing - pip install mapbox_earcut",
file=sys.stderr,
)
continue
if not parts:
return None
return trimesh.util.concatenate(parts) if len(parts) > 1 else parts[0]
def hex_rgba(hex_color, alpha):
h = hex_color.lstrip("#")
return [int(h[0:2], 16) / 255, int(h[2:4], 16) / 255, int(h[4:6], 16) / 255, alpha]
ALPHA = {
"slab": 0.72,
"roof": 0.95,
"glazing": 0.38,
"floor_lines": 0.95,
"grid": 0.95,
"detail_lines": 0.82,
"doors": 0.90,
}
def merge_collinear(segs, angle_tol_deg=6.0, offset_tol=0.30, gap_tol=3.6):
"""Merge collinear, near-touching segments into continuous spans (for glazing bands)."""
groups = {}
keep = []
for s in segs:
a = s["start"]
b = s["end"]
dx = b[0] - a[0]
dy = b[1] - a[1]
L = math.hypot(dx, dy)
if L < 1e-6:
keep.append(s)
continue
ang = math.atan2(dy, dx) % math.pi
akey = round(ang / math.radians(angle_tol_deg))
nx, ny = -dy / L, dx / L
off = a[0] * nx + a[1] * ny
okey = round(off / offset_tol)
groups.setdefault((akey, okey), []).append(
(a, b, nx, ny, float(s.get("width", 0.06)), s.get("layer", ""), math.radians(angle_tol_deg) * akey)
)
out = list(keep)
for (akey, okey), items in groups.items():
a0, b0, nx, ny, w, layer, _ = items[0]
dirx, diry = -ny, nx
offv = a0[0] * nx + a0[1] * ny
intervals = []
for a, b, *_r in items:
t0 = a[0] * dirx + a[1] * diry
t1 = b[0] * dirx + b[1] * diry
intervals.append([min(t0, t1), max(t0, t1)])
intervals.sort()
merged = [intervals[0][:]]
for lo, hi in intervals[1:]:
if lo <= merged[-1][1] + gap_tol:
merged[-1][1] = max(merged[-1][1], hi)
else:
merged.append([lo, hi])
for lo, hi in merged:
p0 = (offv * nx + lo * dirx, offv * ny + lo * diry)
p1 = (offv * nx + hi * dirx, offv * ny + hi * diry)
out.append(
{"start": [p0[0], p0[1]], "end": [p1[0], p1[1]], "width": w, "layer": layer, "source_type": "merged"}
)
return out
def extend_shared_wall_ends(segments, tol=1e-3):
"""Extend wall ends that meet another wall's endpoint by half their own width.
Flat-capped rectangles stop exactly at the endpoint, so an L-corner leaves
a w/2 x w/2 notch that even a union keeps open. Extending only SHARED ends
makes the corner rectangles overlap (union -> clean square corner) while
free ends (door/window openings) stay flat. T-joints need nothing: the
ending wall already reaches the crossing wall's centerline.
"""
from collections import Counter
pts = []
for s in segments:
pts.append((float(s["start"][0]), float(s["start"][1])))
pts.append((float(s["end"][0]), float(s["end"][1])))
scale = 1.0 / max(tol, 1e-9)
buckets = Counter((round(x * scale), round(y * scale)) for x, y in pts)
def shared(p):
cx, cy = round(p[0] * scale), round(p[1] * scale)
return sum(buckets.get((gx, gy), 0) for gx in (cx - 1, cx, cx + 1) for gy in (cy - 1, cy, cy + 1)) >= 2
out = []
for s in segments:
a = [float(s["start"][0]), float(s["start"][1])]
b = [float(s["end"][0]), float(s["end"][1])]
dx, dy = b[0] - a[0], b[1] - a[1]
L = math.hypot(dx, dy)
if L < 1e-7:
out.append(s)
continue
ux, uy = dx / L, dy / L
half = max(float(s.get("width", 0.1)), 0.005) / 2.0
item = dict(s)
if shared((a[0], a[1])):
a = [a[0] - ux * half, a[1] - uy * half]
if shared((b[0], b[1])):
b = [b[0] + ux * half, b[1] + uy * half]
item["start"] = a
item["end"] = b
out.append(item)
return out
def merged_wall_polygons(segments):
"""Union per-segment wall rectangles into continuous solids (shapely).
Shared endpoints are pre-extended (see extend_shared_wall_ends), then each
segment becomes a flat-capped rectangle (LineString.buffer, cap_style=2,
half its own width) and unary_union removes corner seams and z-fighting at
junctions. Returns shapely Polygons (holes preserved for courtyard walls).
Enabled via config {"merge_wall_solids": true}.
"""
from shapely.geometry import LineString
from shapely.ops import unary_union
rects = []
for s in extend_shared_wall_ends(segments):
a = s["start"]
b = s["end"]
if math.hypot(b[0] - a[0], b[1] - a[1]) < 1e-7:
continue
w = max(float(s.get("width", 0.1)), 0.005)
rects.append(LineString([tuple(a), tuple(b)]).buffer(w / 2.0, cap_style=2))
if not rects:
return []
union = unary_union(rects)
geoms = [union] if union.geom_type == "Polygon" else list(getattr(union, "geoms", []))
# simplify(0) drops the collinear vertices GEOS noding leaves on straight edges
return [g.simplify(0) for g in geoms if g.geom_type == "Polygon" and g.area > 1e-6]
def mesh_from_shapely(polys, z0, z1):
"""Extrude shapely Polygons directly (keeps interior holes, unlike mesh_from_polygons)."""
parts = []
for poly in polys:
try:
m = trimesh.creation.extrude_polygon(poly, height=max(z1 - z0, 1e-4))
m.apply_translation((0, 0, z0))
parts.append(m)
except Exception as exc:
_POLY_FAILS["n"] += 1
if _POLY_FAILS["n"] <= 3:
print(
f"WARNING mesh_from_polygons failed ({exc}); merged walls may be "
"missing - pip install mapbox_earcut",
file=sys.stderr,
)
continue
if not parts:
return None
return trimesh.util.concatenate(parts) if len(parts) > 1 else parts[0]
def glazing_mullion_segments(bands, z0, z1, panel_w=1.5, profile=0.06, depth=0.10):
"""Curtain-wall panel grid over merged glazing bands.
Emits pseudo wall segments (thin box profiles, walls material via the
<floor>__walls node): vertical mullions evenly spaced ~panel_w along each
band (posts at both ends included) plus a horizontal transom at the band's
bottom and top floor lines (carrying _z0/_z1). The glass pane itself stays.
Config {"glazing_mullions": true}, pitch {"glazing_panel_w": 1.5}.
"""
out = []
for s in bands:
a = s["start"]
b = s["end"]
dx, dy = b[0] - a[0], b[1] - a[1]
L = math.hypot(dx, dy)
if L < max(profile * 2, 0.3):
continue
ux, uy = dx / L, dy / L
n = max(1, round(L / max(panel_w, 0.2)))
step = L / n
for i in range(n + 1):
t = i * step
cx, cy = a[0] + ux * t, a[1] + uy * t
out.append(
{
"start": [cx - ux * profile / 2.0, cy - uy * profile / 2.0],
"end": [cx + ux * profile / 2.0, cy + uy * profile / 2.0],
"width": depth,
"layer": s.get("layer", ""),
"source_type": "mullion",
}
)
th = 0.08
for tz0, tz1 in ((z0, z0 + th), (z1 - th, z1)):
out.append(
{
"start": [float(a[0]), float(a[1])],
"end": [float(b[0]), float(b[1])],
"width": depth,
"layer": s.get("layer", ""),
"source_type": "transom",
"_z0": tz0,
"_z1": tz1,
}
)
return out
def _shapely_union(polys):
from shapely.geometry import Polygon
from shapely.ops import unary_union
gs = []
for p in polys:
try:
g = Polygon(p)
if not g.is_valid:
g = g.buffer(0)
if not g.is_empty and g.area > 0:
gs.append(g)
except Exception:
pass
return unary_union(gs) if gs else None
def _shapely_to_polys(geom, min_area=2.0):
res = []
if geom is None or geom.is_empty:
return res
geoms = [geom] if geom.geom_type == "Polygon" else list(getattr(geom, "geoms", []))
for g in geoms:
if g.geom_type != "Polygon" or g.area < min_area:
continue
res.append([[float(x), float(y)] for x, y in g.exterior.coords])
return res
def setback_cap_polys(spec, fk, fl, own_polys):
"""Cap ring = own footprint minus the footprint of the floor directly above (same group)."""
z = float(fl["z"])
h = float(fl.get("height", 4.2))
ftop = z + h
cfg = spec.get("source", {}).get("config", {})
grp = floor_group(fk, cfg)
upper = []
for ok, ot in spec["floors"].items():
if ok == fk or floor_group(ok, cfg) != grp:
continue
if abs(float(ot.get("z", 0.0)) - ftop) > 0.8:
continue
upper.extend(ot.get("footprint", {}).get("polygons", []))
own_u = _shapely_union(own_polys)
# Ordinary facades default to a small tolerance. Colonnade buildings such
# as A208 must explicitly set cap_buffer around 1.3 m.
buf = float(cfg.get("cap_buffer", 0.1))
if not upper:
# top of a basement stack -> cap the WHOLE footprint (ground / podium deck over parking)
if grp == "BASE" and own_u is not None:
return _shapely_to_polys(own_u.buffer(0.5), min_area=3.0)
return [] # above-ground top handled by generated roof caps
up_u = _shapely_union(upper)
if own_u is None or up_u is None:
return []
try:
ring = own_u.buffer(buf).difference(up_u.buffer(0.05))
except Exception:
return []
# Keep thin 0.1 m default cap rings on small buildings; this geometry is
# already constrained by validated floor footprints, not raw CAD noise.
return _shapely_to_polys(ring, min_area=0.25)
def floor_group(fk, cfg=None):
return showcase_schema.floor_group(str(fk), cfg)
def _pt_seg_dist(p, a, b):
px, py = p
ax, ay = a
bx, by = b
dx, dy = bx - ax, by - ay
L = dx * dx + dy * dy
if L <= 1e-12:
return math.hypot(px - ax, py - ay)
t = max(0.0, min(1.0, ((px - ax) * dx + (py - ay) * dy) / L))
return math.hypot(px - (ax + t * dx), py - (ay + t * dy))
def _pt_in_poly(p, poly):
x, y = p
inside = False
n = len(poly)
if n < 3:
return False
j = n - 1
for i in range(n):
xi, yi = float(poly[i][0]), float(poly[i][1])
xj, yj = float(poly[j][0]), float(poly[j][1])
if (yi > y) != (yj > y):
xat = (xj - xi) * (y - yi) / ((yj - yi) or 1e-12) + xi
if x < xat:
inside = not inside
j = i
return inside
def _near_polys(p, polys, margin):
for poly in polys:
if _pt_in_poly(p, poly):
return True
pts = [(float(x), float(y)) for x, y in poly]
for i in range(len(pts)):
if _pt_seg_dist(p, pts[i], pts[(i + 1) % len(pts)]) <= margin:
return True
return False
def column_supported(pt, fk, fl, spec, cfg, roofs):
ftop = float(fl["z"]) + float(fl.get("height", 4.2))
sd = float(cfg.get("column_support_distance", 1.1))
ztol = float(cfg.get("column_support_z_tolerance", 0.65))
scats = set(cfg.get("column_support_categories", ["walls", "glazing", "columns", "beams"]))
req_plate = bool(cfg.get("column_support_requires_upper_plate", True))
plate_only = bool(cfg.get("column_support_allow_plate_only", False))
grp = floor_group(fk, cfg)
for ok, ot in spec["floors"].items():
if floor_group(ok, cfg) != grp:
continue
oz = float(ot.get("z", 0.0))
if not (ftop - 0.05 <= oz <= ftop + ztol):
continue
ups = ot.get("footprint", {}).get("polygons", [])
if ups:
has = _near_polys(pt, ups, sd)
if has and plate_only:
return True
if req_plate and not has:
continue
for c in scats:
for s in ot.get("segments", {}).get(c, []):
if _pt_seg_dist(pt, tuple(s["start"]), tuple(s["end"])) <= sd:
return True
rtol = float(cfg.get("column_roof_support_z_tolerance", 0.65))
for r in roofs:
if floor_group(str(r["floor_key"]), cfg) != grp:
continue
if abs(float(r["z"]) - ftop) > rtol:
continue
if r["polygons"] and _near_polys(pt, r["polygons"], sd):
return True
return False
def adjust_columns(segs, fk, fl, spec, cfg, roofs):
if not cfg.get("shorten_unsupported_columns", False):
return segs
flt = {str(k) for k in cfg.get("shorten_unsupported_columns_floor_keys", [])}
if flt and fk not in flt:
return segs
z = float(fl["z"])
h = float(fl.get("height", 4.2))
sh = min(float(cfg.get("unsupported_column_height", 1.2)), h)
out = []
for s in segs:
a = s["start"]
b = s["end"]
mid = ((a[0] + b[0]) / 2.0, (a[1] + b[1]) / 2.0)
it = dict(s)
if not column_supported(mid, fk, fl, spec, cfg, roofs):
it["_z0"] = z
it["_z1"] = z + sh
out.append(it)
return out
def roof_specs(spec):
cfg = spec.get("source", {}).get("config", {})
floors = spec.get("floors", {})
out = []
for r in cfg.get("roof_specs", []):
fk = str(r.get("floor_key"))
fl = floors.get(fk)
if not fl:
continue
ffrom = list(r.get("footprint_from", [fk]))
polys = []
for k in ffrom:
polys.extend(floors.get(k, {}).get("footprint", {}).get("polygons", []))
out.append(
{
"floor_key": fk,
"z": float(r.get("z", fl.get("z", 0.0))),
"thickness": float(r.get("thickness", 0.35)),
"polygons": polys,
"bounds": r.get("bounds") or fl.get("bounds"),
}
)
return out
def build_scene(spec, categories):
cfg = spec.get("source", {}).get("config", {})
use_fp_slab = cfg.get("use_footprint_slabs", False)
slab_th = float(cfg.get("slab_thickness", 0.25))
cat_defs = spec.get("categories", {})
scene = trimesh.Scene()
mats = {}
def material(cat):
if cat in mats:
return mats[cat]
color = cat_defs.get(cat, {}).get("color", "#cccccc")
m = trimesh.visual.material.PBRMaterial(
name=cat,
baseColorFactor=hex_rgba(color, ALPHA.get(cat, 1.0)),
metallicFactor=0.02,
roughnessFactor=0.75,
alphaMode=("BLEND" if ALPHA.get(cat, 1.0) < 1 else "OPAQUE"),
)
mats[cat] = m
return m
def add(name, mesh, cat):
if mesh is None or mesh.faces.shape[0] == 0:
return
# bake flat normals: unweld so each face has unique verts -> exported NORMAL is per-face
tris = mesh.vertices[mesh.faces]
v = tris.reshape(-1, 3)
f = np.arange(len(v)).reshape(-1, 3)
mesh = trimesh.Trimesh(vertices=v, faces=f, process=False)
# drop degenerate (near-zero-area) faces so normals never become NaN
tri = mesh.vertices[mesh.faces]
area = np.linalg.norm(np.cross(tri[:, 1] - tri[:, 0], tri[:, 2] - tri[:, 0]), axis=1) * 0.5
good = np.isfinite(area) & (area > 1e-9)
if not good.all():
mesh.update_faces(good)
mesh.remove_unreferenced_vertices()
if mesh.faces.shape[0] == 0:
return
# convert Z-up -> glTF-standard Y-up: (x,y,z) -> (x, z, -y)
mesh.apply_transform(np.array([[1, 0, 0, 0], [0, 0, 1, 0], [0, -1, 0, 0], [0, 0, 0, 1.0]]))
if not np.isfinite(mesh.vertices).all():
return
vn = np.array(mesh.vertex_normals, dtype=np.float64) # force + sanitize
badrows = ~np.isfinite(vn).all(axis=1)
if badrows.any():
vn[badrows] = [0.0, 1.0, 0.0]
mesh.vertex_normals = vn
try:
mesh.visual = trimesh.visual.TextureVisuals(material=material(cat))
except Exception:
pass
scene.add_geometry(mesh, geom_name=name, node_name=name)
want = None if categories in (None, "all") else set(categories)
roofs = roof_specs(spec)
for fk, fl in spec["floors"].items():
z = float(fl["z"])
h = float(fl.get("height", 4.2))
# slab (bottom plate + setback cap ring at this floor's top to cap columns)
if want is None or "slab" in want:
polys = fl.get("footprint", {}).get("polygons", []) if use_fp_slab else []
parts = []
if polys:
parts.append(mesh_from_polygons(polys, z - slab_th, z))
caps = fl.get("caps", [])
if caps:
for cap in caps:
cap_z = float(cap.get("z", z + h))
cap_polys = cap.get("polygons", [])
if cap_polys:
parts.append(mesh_from_polygons(cap_polys, cap_z - slab_th, cap_z))
elif cfg.get("slab_bounds_fallback", True):
# Rectangular fallback can fake a full-cover plate on floors
# like parapet-only roof plans; disable via config
# {"slab_bounds_fallback": false} when footprints are trusted.
b = fl["bounds"]
mg = 1.2
parts.append(
mesh_from_polygons(
[
[
[b[0] - mg, b[1] - mg],
[b[2] + mg, b[1] - mg],
[b[2] + mg, b[3] + mg],
[b[0] - mg, b[3] + mg],
]
],
z - slab_th,
z,
)
)
parts = [p for p in parts if p is not None]
if parts:
add(f"{fk}__slab", parts[0] if len(parts) == 1 else trimesh.util.concatenate(parts), "slab")
segs = fl.get("segments", {})
mullion_mesh = None
if cfg.get("glazing_mullions", False) and segs.get("glazing") and (want is None or "walls" in want):
gz0, gz1 = z_window("glazing", z, h, fk, fl)
mullion_mesh = mesh_from_segments(
glazing_mullion_segments(
merge_collinear(segs["glazing"]), gz0, gz1, panel_w=float(cfg.get("glazing_panel_w", 1.5))
),
gz0,
gz1,
)
present = [c for c in CATEGORY_DRAW_ORDER if segs.get(c)]
extra = sorted(c for c in segs if c not in CATEGORY_DRAW_ORDER and segs.get(c))
for cat in present + extra:
if want is not None and cat not in want:
continue
z0, z1 = z_window(cat, z, h, fk, fl)
seglist = segs[cat]
if cat == "columns":
seglist = adjust_columns(seglist, fk, fl, spec, cfg, roofs)
if cat == "glazing":
seglist = merge_collinear(seglist)
if cat == "walls":
wall_mesh = None
if cfg.get("merge_wall_solids", False):
wall_mesh = mesh_from_shapely(merged_wall_polygons(seglist), z0, z1)
if wall_mesh is None:
wall_mesh = mesh_from_segments(seglist, z0, z1)
if mullion_mesh is not None:
parts = [p for p in (wall_mesh, mullion_mesh) if p is not None]
wall_mesh = trimesh.util.concatenate(parts) if len(parts) > 1 else (parts[0] if parts else None)
mullion_mesh = None
add(f"{fk}__walls", wall_mesh, "walls")
continue
add(f"{fk}__{cat}", mesh_from_segments(seglist, z0, z1), cat)
if mullion_mesh is not None:
# glazing-only floor: the panel grid still needs a walls node
add(f"{fk}__walls", mullion_mesh, "walls")
# generated roofs
if want is None or "roof" in want:
for r in roof_specs(spec):
z = r["z"]
th = r["thickness"]
if r["polygons"]:
add(f"{r['floor_key']}__roof", mesh_from_polygons(r["polygons"], z - th, z + 0.08), "roof")
elif r["bounds"]:
b = r["bounds"]
add(
f"{r['floor_key']}__roof",
mesh_from_polygons([[[b[0], b[1]], [b[2], b[1]], [b[2], b[3]], [b[0], b[3]]]], z - th, z + 0.08),
"roof",
)
return scene
def scene_bounds(spec):
bx = [math.inf, math.inf, -math.inf, -math.inf]
maxz = 0.0
for fl in spec["floors"].values():
b = fl["bounds"]
bx[0] = min(bx[0], b[0])
bx[1] = min(bx[1], b[1])
bx[2] = max(bx[2], b[2])
bx[3] = max(bx[3], b[3])
maxz = max(maxz, float(fl["z"]) + float(fl.get("height", 4.2)))
return bx, maxz
def write_metadata(spec, name, out):
cfg = spec.get("source", {}).get("config", {})
bx, maxz = scene_bounds(spec)
meta = {
"metadata_version": 1,
"schema_version": spec.get("schema_version"),
"project": spec.get("project", {"name": name}),
"floors": [
{"key": k, "name": f.get("name", k), "z": f.get("z", 0), "height": f.get("height", 4.2)}
for k, f in spec["floors"].items()
],
"categories": spec.get("categories", {}),
"viewer_defaults": {"disabled_categories": list(cfg.get("default_disabled_categories", []))},
"bounds": {"xy": bx, "max_z": maxz},
"files": {"glb": f"{name}.glb"},
}
Path(out).write_text(json.dumps(meta, ensure_ascii=False, indent=2), encoding="utf-8")
def main():
ap = argparse.ArgumentParser()
ap.add_argument("--spec", required=True)
ap.add_argument("--out", required=True)
ap.add_argument("--metadata-out")
ap.add_argument("--name", default="model")
ap.add_argument("--categories", default="all", help="'all' or comma list incl. slab")
a = ap.parse_args()
raw_spec = json.loads(Path(a.spec).read_text(encoding="utf-8"))
spec = showcase_schema.normalize_spec(raw_spec)
try:
showcase_schema.validate_spec(spec)
except showcase_schema.ValidationFailure as exc:
print(str(exc), file=sys.stderr)
raise SystemExit(3)
cats = None if a.categories == "all" else [c.strip() for c in a.categories.split(",") if c.strip()]
scene = build_scene(spec, cats)
Path(a.out).parent.mkdir(parents=True, exist_ok=True)
scene.export(a.out)
tris = sum(int(g.faces.shape[0]) for g in scene.geometry.values())
verts = sum(int(g.vertices.shape[0]) for g in scene.geometry.values())
if a.metadata_out:
write_metadata(spec, a.name, a.metadata_out)
print(
json.dumps(
{
"out": a.out,
"nodes": len(scene.geometry),
"triangles": tris,
"vertices": verts,
"bytes": Path(a.out).stat().st_size,
},
ensure_ascii=False,
)
)
if __name__ == "__main__":
main()