Initial commit: cad-building-showcase skill
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>
This commit is contained in:
399
scripts/spec_to_glb.py
Normal file
399
scripts/spec_to_glb.py
Normal file
@@ -0,0 +1,399 @@
|
||||
#!/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()
|
||||
Reference in New Issue
Block a user