Agent-led CAD-drawing → 3D web showcase pipeline. Inspects CAD reports, maps layers/floors, extracts a normalized building spec (with block-probed glazing and audit gates), builds Blender/trimesh GLB variants, and assembles a Three.js web viewer. Includes XREF-shell detection and a regression test. Large inputs/outputs (work/, outputs/, source_cad/, renders) are gitignored. Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
400 lines
16 KiB
Python
400 lines
16 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, json, math
|
|
from pathlib import Path
|
|
import numpy as np
|
|
import trimesh
|
|
from shapely.geometry import Polygon
|
|
|
|
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)
|
|
|
|
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:
|
|
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 _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
|
|
grp=floor_group(fk)
|
|
upper=[]
|
|
for ok,ot in spec["floors"].items():
|
|
if ok==fk or floor_group(ok)!=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)
|
|
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:
|
|
# buffer own footprint outward so the cap also covers perimeter colonnade columns
|
|
ring=own_u.buffer(1.3).difference(up_u.buffer(0.05))
|
|
except Exception:
|
|
return []
|
|
return _shapely_to_polys(ring, min_area=3.0)
|
|
|
|
def floor_group(fk):
|
|
if fk.startswith("AUX_"): return "AUX"
|
|
if fk in {"B1","B1M"}: return "BASE"
|
|
return "MAIN"
|
|
|
|
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)
|
|
for ok,ot in spec["floors"].items():
|
|
if floor_group(ok)!=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"]))!=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))
|
|
cap_polys=setback_cap_polys(spec, fk, fl, polys)
|
|
if cap_polys:
|
|
parts.append(mesh_from_polygons(cap_polys, z+h-slab_th, z+h))
|
|
else:
|
|
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",{})
|
|
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)
|
|
add(f"{fk}__{cat}", mesh_from_segments(seglist, z0, z1), cat)
|
|
# 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={
|
|
"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()
|
|
spec=json.loads(Path(a.spec).read_text(encoding="utf-8"))
|
|
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()
|