776 lines
27 KiB
Python
776 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)
|
|
# 1.3 suits colonnade buildings (A208); ordinary facades want ~0.1 or the
|
|
# cap ring reads as a slab overhanging every floor. Config: cap_buffer.
|
|
buf = float(cfg.get("cap_buffer", 1.3))
|
|
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 []
|
|
return _shapely_to_polys(ring, min_area=3.0)
|
|
|
|
|
|
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()
|