"""Rebuild Crown Landmark SHELL C02 from MODEL_SPEC.json.

C02 is a new candidate beside the preserved C01 baseline. Changes from C01: smooth upper-tower taper,
flared rib blades, curved podium cantilever fascia, explicit podium enclosure walls with front bays,
and a 0.6 m slab over enclosed floors. Original R06 artwork and INT R02 layouts are untouched.

Python 3 + NumPy. Pillow is needed only for the neutral reference renders.
Source coordinates are metres, Z up, front -Y. GLB converts to Y up/front +Z.
This is an isolated concept review model, not an accepted construction asset.
"""
from pathlib import Path
import argparse, hashlib, json, math, struct
import numpy as np

HERE=Path(__file__).resolve().parent
PREFIX='PI-BLD-0001-V01_CrownLandmark_SHELL_C02'
LABEL='C02'
MESHES=[]

def unit(v):
    v=np.asarray(v,dtype=float);n=np.linalg.norm(v)
    return v/n if n>1e-12 else np.array([0.,0.,1.])

class Mesh:
    def __init__(self,name,material,group):
        self.name=name;self.material=material;self.group=group;self.v=[];self.f=[]
        MESHES.append(self)
    def vertex(self,p):self.v.append(list(map(float,p)));return len(self.v)-1
    def face(self,*ids):
        for i in range(1,len(ids)-1):
            a,b,c=ids[0],ids[i],ids[i+1]
            if np.linalg.norm(np.cross(np.subtract(self.v[b],self.v[a]),np.subtract(self.v[c],self.v[a])))>1e-9:self.f.append([a,b,c])
    def finish(self):
        if not self.f:return
        v=np.array(self.v,dtype=np.float32);f=np.array(self.f,dtype=np.uint32)
        used,inv=np.unique(f,return_inverse=True);self.v=v[used];self.f=inv.reshape(-1,3).astype(np.uint32)
        n=np.zeros_like(self.v)
        fn=np.cross(self.v[self.f[:,1]]-self.v[self.f[:,0]],self.v[self.f[:,2]]-self.v[self.f[:,0]])
        for i in range(3):np.add.at(n,self.f[:,i],fn)
        length=np.linalg.norm(n,axis=1);n[length>0]/=length[length>0,None];self.n=n

def rounded_rect(w,d,r,arc=6,straight=12,recess=0):
    """CCW plan, with sampled straight edges so the front recess is real geometry."""
    corners=[(w/2-r,d/2-r,0),(-w/2+r,d/2-r,90),(-w/2+r,-d/2+r,180),(w/2-r,-d/2+r,270)]
    pts=[]
    for k,(cx,cy,start) in enumerate(corners):
        angles=np.linspace(start,start+90,arc+1)
        points=[(cx+r*math.cos(math.radians(a)),cy+r*math.sin(math.radians(a))) for a in angles]
        if pts:
            p0=np.array(pts[-1]);p1=np.array(points[0])
            pts.extend([tuple(p0+(p1-p0)*t) for t in np.linspace(0,1,straight+2)[1:-1]])
        pts.extend(points)
    p0=np.array(pts[-1]);p1=np.array(pts[0]);pts.extend([tuple(p0+(p1-p0)*t) for t in np.linspace(0,1,straight+2)[1:-1]])
    out=np.array(pts)
    if recess:
        for p in out:
            if abs(p[1]+d/2)<1e-6 and abs(p[0])<12:
                p[1]+=recess*(1 if abs(p[0])<=8 else (12-abs(p[0]))/4)
    return out

def loft(name,material,group,rings,caps=True):
    m=Mesh(name,material,group);rows=[]
    for z,outline in rings:rows.append([m.vertex([p[0],p[1],z]) for p in outline])
    n=len(rows[0])
    for j in range(len(rows)-1):
        for i in range(n):m.face(rows[j][i],rows[j][(i+1)%n],rows[j+1][(i+1)%n],rows[j+1][i])
    if caps:
        for row,rev in [(rows[0],True),(rows[-1],False)]:
            c=m.vertex(np.mean([m.v[i] for i in row],axis=0))
            for i in range(n):m.face(c,row[(i+1)%n],row[i]) if rev else m.face(c,row[i],row[(i+1)%n])
    return m

def box(name,material,group,x0,x1,y0,y1,z0,z1):
    return loft(name,material,group,[(z,np.array([[x1,y1],[x0,y1],[x0,y0],[x1,y0]])) for z in [z0,z1]])

def tube(name,material,group,path,radius,sides=6):
    m=Mesh(name,material,group);rows=[];path=np.array(path,float)
    for i,p in enumerate(path):
        tangent=unit(path[min(i+1,len(path)-1)]-path[max(i-1,0)])
        helper=np.array([0,0,1]) if abs(tangent[2])<.95 else np.array([0,1,0])
        u=unit(np.cross(tangent,helper));v=unit(np.cross(tangent,u))
        rows.append([m.vertex(p+radius*(u*math.cos(a)+v*math.sin(a))) for a in np.linspace(0,2*math.pi,sides,endpoint=False)])
    for j in range(len(rows)-1):
        for i in range(sides):m.face(rows[j][i],rows[j][(i+1)%sides],rows[j+1][(i+1)%sides],rows[j+1][i])
    for row,rev in [(rows[0],True),(rows[-1],False)]:
        c=m.vertex(np.mean([m.v[i] for i in row],axis=0))
        for i in range(sides):m.face(c,row[(i+1)%sides],row[i]) if rev else m.face(c,row[i],row[(i+1)%sides])
    return m

def hermite(anchors,z):
    a=np.array(anchors,float);xs=a[:,0];values=a[:,1:];i=max(0,min(len(a)-2,int(np.searchsorted(xs,z)-1)));t=(z-xs[i])/(xs[i+1]-xs[i]);h=xs[i+1]-xs[i]
    slopes=np.gradient(values,xs,axis=0);t=max(0,min(1,t))
    return (2*t**3-3*t**2+1)*values[i]+(t**3-2*t**2+t)*h*slopes[i]+(-2*t**3+3*t**2)*values[i+1]+(t**3-t**2)*h*slopes[i+1]

def pchip(xs,ys,x):
    """Monotone piecewise cubic Hermite (Fritsch-Carlson); no overshoot between proposed profile rows."""
    xs=np.asarray(xs,float);ys=np.asarray(ys,float);h=np.diff(xs);delta=np.diff(ys)/h;m=np.zeros_like(ys)
    for i in range(1,len(xs)-1):
        if delta[i-1]*delta[i]>0:
            w1=2*h[i]+h[i-1];w2=h[i]+2*h[i-1];m[i]=(w1+w2)/(w1/delta[i-1]+w2/delta[i])
    m[0]=delta[0];m[-1]=delta[-1]
    i=int(max(0,min(len(xs)-2,np.searchsorted(xs,x)-1)));t=max(0,min(1,(x-xs[i])/h[i]))
    return float((2*t**3-3*t**2+1)*ys[i]+(t**3-2*t**2+t)*h[i]*m[i]+(-2*t**3+3*t**2)*ys[i+1]+(t**3-t**2)*h[i]*m[i+1])

def profile(spec,z):
    rows=np.array(spec['proposed']['tower_profile'],float)
    return [pchip(rows[:,0],rows[:,i],z) for i in [1,2,3]]

def tower_outline(spec,z):
    w,d,r=profile(spec,z);return rounded_rect(w,d,r,recess=spec['proposed']['front_recess_m'])

def rib(spec,target):
    anchors=spec['proposed']['rib_paths'][target['id']];tip=np.array([*target['crown_tip_xy_m'],target['crown_tip_z_m']],float)
    # The requested endpoint is represented by a single exact tip vertex.
    m=Mesh('Rib_'+target['id'],'ivory','Ribs and crown');rows=[];centres=[]
    for z in np.linspace(0,tip[2],83)[:-1]:
        xy=hermite(anchors,z);p=np.array([*xy,z]);centres.append(p)
        near=min(tip[2]-.001,z+.05);far=max(0,z-.05);tangent=unit(np.array([*(hermite(anchors,near)-hermite(anchors,far)),near-far]))
        radial=unit([*xy,0]);u=unit([-radial[1],radial[0],0]);v=unit(np.cross(tangent,u))
        bw=spec['proposed']['rib_blade_widths'];width=float(np.interp(z,bw['z_m']+[tip[2]],bw['tangential_width_m']+[0]))
        depth=float(np.interp(z,bw['z_m']+[tip[2]],bw['radial_depth_m']+[0]))
        cross=[(-.42,-.5),(.42,-.5),(.5,-.38),(.5,.38),(.42,.5),(-.42,.5),(-.5,.38),(-.5,-.38)]
        rows.append([m.vertex(p+u*width*x+v*depth*y) for x,y in cross])
    for j in range(len(rows)-1):
        for i in range(8):m.face(rows[j][i],rows[j][(i+1)%8],rows[j+1][(i+1)%8],rows[j+1][i])
    end=m.vertex(tip)
    for i in range(8):m.face(rows[-1][i],rows[-1][(i+1)%8],end)
    c=m.vertex([*target['foot_xy_m'],0])
    for i in range(8):m.face(c,rows[0][(i+1)%8],rows[0][i])
    # Gold inner spine follows the same continuous curve, rather than an unrelated crown prop.
    line=[]
    for z in np.linspace(2,tip[2]-1,80):
        xy=hermite(anchors,z);radial=unit([*xy,0]);line.append(np.array([*xy,z])-radial*1.3)
    tube('Gold_inner_'+target['id'],'gold','Ribs and crown',line,.24,5)
    # A small blue sail continues the glazing into the principal crown blade.
    xy=hermite(anchors,210);radial=unit([*xy,0]);u=unit([-radial[1],radial[0],0]);p=np.array([*xy,210])-radial*1.5
    sail=Mesh('Crown_glass_'+target['id'],'blue','Ribs and crown')
    a=sail.vertex(p-u*3.8);b=sail.vertex(p+u*3.8);c=sail.vertex(tip-radial*.6-np.array([0,0,.6]));sail.face(a,b,c)

def arch(name,origin,direction,width,height,spring,thickness,depth,material='ivory'):
    origin=np.array(origin,float);u=unit(direction);v=unit(np.cross(u,[0,0,1]));m=Mesh(name,material,'Podium arcades')
    pts=[(-width/2,0),(-width/2,spring)]
    for a in np.linspace(math.pi,0,19)[1:]:pts.append((width/2*math.cos(a),spring+(height-spring)*math.sin(a)))
    pts.append((width/2,0));rows=[]
    for x,z in pts:
        if z<=spring:out=np.array([x+math.copysign(thickness,x),z])
        else:
            a=math.atan2((z-spring)/(height-spring),x/(width/2));out=np.array([(width/2+thickness)*math.cos(a),spring+(height-spring+thickness)*math.sin(a)])
        rows.append([m.vertex(origin+u*xx+np.array([0,0,zz])+v*dd) for xx,zz,dd in [(x,z,-depth/2),(out[0],out[1],-depth/2),(out[0],out[1],depth/2),(x,z,depth/2)]])
    for j in range(len(rows)-1):
        for i in range(4):m.face(rows[j][i],rows[j][(i+1)%4],rows[j+1][(i+1)%4],rows[j+1][i])
    m.face(*reversed(rows[0]));m.face(*rows[-1]);return m

def construct(spec):
    target=spec['targets'];prop=spec['proposed']
    foundation=rounded_rect(160,120,14)
    loft('Foundation_160x120','stone','Foundation',[(prop['foundation_soffit_m'],foundation),(0,foundation)])
    base=0;cant=prop['podium_cantilever'];bays=prop['front_bays']
    def wall_polygon(i):
        deck=target['podium_decks'][i-1];hx=deck['width_m']/2-18;hy=deck['depth_m']/2-18;bay=bays.get(f'tier_{i}')
        pts=[(hx,-hy),(hx,hy),(-hx,hy),(-hx,-hy)]
        if bay:pts+=[(bay['x_m'][0],-hy),(bay['x_m'][0],bay['wall_front_y_m']),(bay['x_m'][1],bay['wall_front_y_m']),(bay['x_m'][1],-hy)]
        return np.array(pts,float),bay
    def in_bay(i,x,y):
        bay=bays.get(f'tier_{i}');deck=target['podium_decks'][i-1]
        return bool(bay) and bay['x_m'][0]-3<=x<=bay['x_m'][1]+3 and y<-(deck['depth_m']/2-18)+1
    for i,deck in enumerate(target['podium_decks'],1):
        z=deck['z_m'];w=deck['width_m'];d=deck['depth_m'];r=[14,12,10][i-1];t0=cant['slab_thickness_over_enclosed_floor_m']
        outline=rounded_rect(w,d,r)
        loft(f'Deck_{i}_top_{z}m','ivory','Podium terraces',[(z-t0,outline),(z,outline)])
        wall,bay=wall_polygon(i)
        loft(f'Podium_wall_{i}','podium_glass','Podium glazing',[(base+.2,wall),(z-t0-.05,wall)],False)
        # Curved cantilever fascia: thick at the lip, sweeping back into the slab soffit. Omitted over front bays.
        K=10;rows=[(0,t0)]+[(cant['fascia_reach_m']*k/K,t0+cant['fascia_drop_at_lip_m']*(1-k/K)**cant['fascia_curve_exponent']) for k in range(K+1)]
        ringsets=[]
        for s_in,drop in rows:
            ring=rounded_rect(w-2*s_in,d-2*s_in,max(r-s_in,1.5));ringsets.append((z-drop,ring))
        fas=Mesh(f'Cantilever_fascia_{i}','ivory','Podium terraces');ids=[[fas.vertex([p[0],p[1],zz]) for p in ring] for zz,ring in ringsets];n=len(ids[0])
        for j in range(len(ids)-1):
            for q in range(n):
                cx=np.mean([ringsets[j][1][q][0],ringsets[j][1][(q+1)%n][0]]);cy=np.mean([ringsets[j][1][q][1],ringsets[j][1][(q+1)%n][1]])
                if in_bay(i,cx,cy):continue
                fas.face(ids[j][q],ids[j][(q+1)%n],ids[j+1][(q+1)%n],ids[j+1][q])
        for side in ['front','rear','left','right']:
            span=(w-2*r-12) if side in ['front','rear'] else (d-2*r-12)
            count=max(3,int(span/17));bay_w=span/count
            for k in range(count):
                c=-span/2+(k+.5)*bay_w
                if side=='front' and i==1 and abs(c)<12:continue
                if side in ['front','rear']:origin=[c,(-1 if side=='front' else 1)*(d/2-16),base];direction=[1,0,0]
                else:origin=[(-1 if side=='left' else 1)*(w/2-16),c,base];direction=[0,1,0]
                if side=='front' and in_bay(i,origin[0],origin[1]):continue
                arch(f'T{i}_{side}_arch_{k+1}',origin,direction,bay_w*.71,13.2,6.2,1.3,2.2)
        parapet=rounded_rect(w-1.4,d-1.4,r-.7)
        loft(f'Terrace_{i}_blue_parapet','parapet','Podium terraces',[(z+.15,parapet),(z+1.35,parapet)],False)
        tube(f'Terrace_{i}_coping','gold','Podium terraces',[[*p,z+1.4] for p in [*parapet,parapet[0]]],.14,4)
        base=z
    zs=sorted(set([54,126,130.5,135,180,216]+[float(x) for x in np.arange(54,216.1,3)]))
    skin=loft('Tower_curtainwall_skin','blue','Tower glazing',[(z,tower_outline(spec,z)) for z in zs],False)
    # The crown is a continuation of the curtainwall. A scalloped top contour
    # rises above the occupied +216m roof; it is not a flat box with loose fins.
    for v in skin.v:
        if abs(v[2]-216)>1e-6:continue
        angle=math.atan2(v[1],v[0]);best=None
        for r in target['principal_ribs']:
            theta=math.atan2(r['crown_tip_xy_m'][1],r['crown_tip_xy_m'][0]);delta=abs((angle-theta+math.pi)%(2*math.pi)-math.pi);weight=math.exp(-(delta/.21)**2)
            if best is None or weight>best[0]:best=(weight,r)
        weight,r=best
        for axis in [0,1]:v[axis]=(1-weight**2)*v[axis]+weight**2*r['crown_tip_xy_m'][axis]
        v[2]=216+weight*(r['crown_tip_z_m']-218.5)
    roof=rounded_rect(36,26,4)
    loft('Occupied_roof_top_216m','ivory','Tower glazing',[(215.6,roof),(216,roof)])
    # Every storey band uses the same section function as the shell.
    for n,z in enumerate(target['tower_floor_slab_z_m']):
        outline=tower_outline(spec,z)*1.006
        loft(f'Storey_band_{n+1:02d}','gold','Facade grid',[(z-.12,outline),(z+.12,outline)],False)
    for i in range(0,len(tower_outline(spec,54)),3):
        line=[[*tower_outline(spec,z)[i]*1.008,z] for z in np.linspace(54,216,55)]
        tube(f'Mullion_{i:02d}','gold','Facade grid',line,.115,4)
    for r in target['principal_ribs']:rib(spec,r)
    # Amber review glazing marks the central front atrium, with the ground portal open.
    atrium=Mesh('Front_amber_atrium_skin','amber','Front atrium');rows=[]
    def amber_y(z):
        if z>=54:return -profile(spec,z)[1]/2+prop['front_recess_m']-.15
        return float(np.interp(z,[4.5,17.4,18.6,35.4,36.6,53.4],[-52.6,-52.6,-27.2,-27.2,-20.2,-20.2]))
    for z in [4.5,17.4,18.6,35.4,36.6,53.4]+[v for v in zs if v>=54 and v<209]+[209]:
        half=6 if z>=54 else 8;y=amber_y(z)
        rows.append([atrium.vertex([-half,y,z]),atrium.vertex([half,y,z])])
    for j in range(len(rows)-1):atrium.face(rows[j][0],rows[j][1],rows[j+1][1],rows[j+1][0])
    # The front slot and rear crossed gold are deliberately different treatments.
    for sign in [-1,1]:
        line=[]
        for z in np.linspace(54,211,91):
            w,d,r=profile(spec,z);x=sign*float(np.interp(z,[54,78,126,177,211],[-10,0,12,8,0]));line.append([x,d/2+.6,z])
        tube('Rear_crossed_gold_'+str(sign),'gold','Rear authority motif',line,.65,6)
        front=[]
        for z in np.linspace(18.6,207,100):
            x=sign*(3.5*math.sin((z-18)/189*math.pi*3));front.append([x,amber_y(z)-.25,z])
        tube('Front_atrium_gold_'+str(sign),'warm_gold','Front atrium',front,.38,5)
    arch('Main_entry_clear_18x14',[0,-55,0],[1,0,0],18,14,4.5,1.5,2.2)
    # Glass canopy: half-elliptical cross-section swept over the portal depth.
    canopy=Mesh('Entry_glass_canopy','parapet','Entrance and basins');rows=[]
    for y in [-58,-57,-56,-55,-54,-53,-52]:
        rows.append([canopy.vertex([5*math.cos(a),y,5+2.3*math.sin(a)]) for a in np.linspace(0,math.pi,17)])
    for j in range(len(rows)-1):
        for i in range(16):canopy.face(rows[j][i],rows[j][i+1],rows[j+1][i+1],rows[j+1][i])
    for y in [-58,-52]:tube('Canopy_gold_edge_'+str(abs(y)),'gold','Entrance and basins',[[5*math.cos(a),y,5+2.3*math.sin(a)] for a in np.linspace(0,math.pi,33)],.17,5)
    for r in target['principal_ribs']:
        cx,cy=r['foot_xy_m'];theta=math.atan2(cy,cx);outline=[]
        for a in np.linspace(0,2*math.pi,48,endpoint=False):
            x=7.2*math.cos(a);y=4.8*math.sin(a);outline.append([cx+x*math.cos(theta)-y*math.sin(theta),cy+x*math.sin(theta)+y*math.cos(theta)])
        outline=np.array(outline);loft('Basin_rim_'+r['id'],'ivory','Entrance and basins',[(.05,outline),(.55,outline)])
        inner=(outline-[cx,cy])*.86+[cx,cy];loft('Basin_water_'+r['id'],'water','Entrance and basins',[(.57,inner),(.59,inner)])
    cap=[]
    for z,scale in [(216,1),(220,.94),(225,.65),(229,.22),(230,.01)]:cap.append((z,np.array([[8*scale*math.cos(a),12*scale*math.sin(a)] for a in np.linspace(0,2*math.pi,48,endpoint=False)])))
    loft('Central_glazed_cap_16x24','blue','Ribs and crown',cap)
    for m in MESHES:m.finish()

def export(spec,out):
    mats=list(spec['materials']);material_index={k:i for i,k in enumerate(mats)};buf=bytearray();views=[];access=[];meshes=[];nodes=[]
    def add(a,component,kind,target,mins=False):
        while len(buf)%4:buf.append(0)
        start=len(buf);data=a.tobytes();buf.extend(data);view=len(views);views.append({'buffer':0,'byteOffset':start,'byteLength':len(data),'target':target})
        ac={'bufferView':view,'componentType':component,'count':len(a),'type':kind}
        if mins:ac.update(min=a.min(axis=0).tolist(),max=a.max(axis=0).tolist())
        access.append(ac);return len(access)-1
    for m in MESHES:
        p=m.v[:,[0,2,1]].copy();p[:,2]*=-1;n=m.n[:,[0,2,1]].copy();n[:,2]*=-1
        # This axis conversion is a proper rotation and preserves winding.
        pi=add(p.astype('<f4'),5126,'VEC3',34962,True);ni=add(n.astype('<f4'),5126,'VEC3',34962);ii=add(m.f.reshape(-1).astype('<u4'),5125,'SCALAR',34963)
        meshes.append({'name':m.name,'primitives':[{'attributes':{'POSITION':pi,'NORMAL':ni},'indices':ii,'material':material_index[m.material]}],'extras':{'group':m.group,'review_status':'CONCEPT'}})
        nodes.append({'name':m.name,'mesh':len(meshes)-1,'extras':{'group':m.group}})
    gltf={'asset':{'version':'2.0','generator':'Lost Souls Crown Landmark parametric builder C02','copyright':'Lost Souls project; source references retained'},'scene':0,'scenes':[{'name':'CrownLandmark SHELL '+LABEL+' CONCEPT','nodes':list(range(len(nodes)))}],'nodes':nodes,'meshes':meshes,'materials':[],'buffers':[{'byteLength':len(buf)}],'bufferViews':views,'accessors':access,'extras':{'asset_id':spec['asset_id'],'revision':'SHELL '+LABEL,'status':'CONCEPT; shell and engine acceptance pending','source_units':'metres Z up front -Y','glTF_units':'metres Y up front +Z','source_to_gltf':'(x,y,z) -> (x,z,-y)','map_transform':None}}
    for k in mats:
        v=spec['materials'][k];gltf['materials'].append({'name':k,'doubleSided':True,'pbrMetallicRoughness':{'baseColorFactor':v['color']+[1],'metallicFactor':v.get('metallic',0),'roughnessFactor':v.get('roughness',.45)}})
    gltf['extras']['saved_cameras_source_m']=spec['cameras']
    raw=json.dumps(gltf,separators=(',',':')).encode();raw+=b' '*((-len(raw))%4);buf+=b'\0'*((-len(buf))%4)
    blob=struct.pack('<III',0x46546c67,2,12+8+len(raw)+8+len(buf))+struct.pack('<II',len(raw),0x4e4f534a)+raw+struct.pack('<II',len(buf),0x004e4942)+buf
    (out/(PREFIX+'.glb')).write_bytes(blob)
    with (out/(PREFIX+'.obj')).open('w') as f:
        f.write('# Crown Landmark SHELL '+LABEL+' CONCEPT; metres, Z up, front -Y\nmtllib '+PREFIX+'.mtl\n');offset=1
        for m in MESHES:
            f.write('o '+m.name+'\ng '+m.group.replace(' ','_')+'\nusemtl '+m.material+'\n')
            for v in m.v:f.write('v '+' '.join(f'{x:.6f}' for x in v)+'\n')
            for n in m.n:f.write('vn '+' '.join(f'{x:.6f}' for x in n)+'\n')
            for face in m.f:f.write('f '+' '.join(f'{int(i)+offset}//{int(i)+offset}' for i in face)+'\n')
            offset+=len(m.v)
    with (out/(PREFIX+'.mtl')).open('w') as f:
        for k,v in spec['materials'].items():f.write('newmtl '+k+'\nKd '+' '.join(map(str,v['color']))+'\nKs 0.25 0.25 0.25\nNs 48\nd 1\n\n')
    vertices=np.concatenate([m.v for m in MESHES]);minimum=vertices.min(axis=0);maximum=vertices.max(axis=0)
    measurements={'asset_id':spec['asset_id'],'revision':'SHELL '+LABEL,'state':'CONCEPT','units':'metres','coordinate_frame':spec['coordinate_frame'],'bounding_box_m':{'min':minimum.tolist(),'max':maximum.tolist(),'span':(maximum-minimum).tolist()},'height_above_finished_ground_m':float(maximum[2]),'mesh_objects':len(MESHES),'vertices':sum(len(m.v) for m in MESHES),'triangles':sum(len(m.f) for m in MESHES),'source_render_method':'Direct CPU rasterization of these exact triangle meshes; no image generation or photo geometry reconstruction','objects':[]}
    for m in MESHES:measurements['objects'].append({'name':m.name,'group':m.group,'material':m.material,'vertices':len(m.v),'triangles':len(m.f),'bbox_min':m.v.min(axis=0).tolist(),'bbox_max':m.v.max(axis=0).tolist()})
    (out/'MODEL_MEASUREMENTS.json').write_text(json.dumps(measurements,indent=2)+'\n')
    return measurements

def render(spec,out,view):
    from PIL import Image,ImageDraw,ImageFont
    w,h=1100,1400;image=np.ones((h,w,3),dtype=np.uint8)*242;depth=np.full((h,w),-np.inf,dtype=np.float32)
    camera=spec['cameras'][view];eye=np.array(camera['eye_source_m'],float);target=np.array(camera['target_source_m'],float);back=unit(eye-target);right=unit(np.cross([0,0,1],back)) if abs(back[2])<.99 else np.array([1.,0.,0.]);up=unit(np.cross(back,right));scale=(h-205)/camera['orthographic_vertical_span_m'];centre=np.array([w/2,(100+h-105)/2]);light=unit([-1,-1.4,2])
    for m in MESHES:
        v=m.v-target;xy=np.column_stack((v@right,-v@up))*scale+centre;z=v@back;color=np.array(spec['materials'][m.material]['color'])*255
        for face in m.f:
            pts=xy[face];zs=z[face];x0=max(0,int(np.floor(pts[:,0].min())));x1=min(w-1,int(np.ceil(pts[:,0].max())));y0=max(100,int(np.floor(pts[:,1].min())));y1=min(h-105,int(np.ceil(pts[:,1].max())))
            if x1<x0 or y1<y0:continue
            a,b,c=pts;den=(b[1]-c[1])*(a[0]-c[0])+(c[0]-b[0])*(a[1]-c[1])
            if abs(den)<1e-8:continue
            xx,yy=np.meshgrid(np.arange(x0,x1+1)+.5,np.arange(y0,y1+1)+.5)
            aa=((b[1]-c[1])*(xx-c[0])+(c[0]-b[0])*(yy-c[1]))/den;bb=((c[1]-a[1])*(xx-c[0])+(a[0]-c[0])*(yy-c[1]))/den;cc=1-aa-bb
            zz=aa*zs[0]+bb*zs[1]+cc*zs[2];sub=depth[y0:y1+1,x0:x1+1];mask=(aa>=-1e-6)&(bb>=-1e-6)&(cc>=-1e-6)&(zz>sub)
            if not np.any(mask):continue
            normal=unit(np.cross(m.v[face[1]]-m.v[face[0]],m.v[face[2]]-m.v[face[0]]));normal=normal if normal@back>=0 else -normal
            shade=.46+.54*max(0,float(normal@light));rgb=np.clip(color*shade,0,255).astype(np.uint8);image[y0:y1+1,x0:x1+1][mask]=rgb;sub[mask]=zz[mask]
    im=Image.fromarray(image);draw=ImageDraw.Draw(im)
    font='/usr/share/fonts/truetype/dejavu/DejaVuSans.ttf';bold='/usr/share/fonts/truetype/dejavu/DejaVuSans-Bold.ttf'
    try:f=ImageFont.truetype(font,20);title=ImageFont.truetype(bold,29);small=ImageFont.truetype(font,16)
    except OSError:f=title=small=ImageFont.load_default()
    draw.rectangle((0,0,w,95),fill='#17111e');draw.text((35,24),'CROWN LANDMARK / SHELL '+LABEL,font=title,fill='#f4e7d2');draw.text((35,63),view.replace('_',' ').upper()+' · SAME MODEL · ORTHOGRAPHIC',font=small,fill='#e8b7d3')
    draw.rectangle((0,h-100,w,h),fill='#17111e');draw.text((35,h-85),('TAPER STUDY · breaks L25/L26 fit · not a candidate' if LABEL.endswith('T') else 'CONCEPT CANDIDATE · 240 m target · shell / engine acceptance pending'),font=f,fill='#f4e7d2');draw.text((35,h-48),'Metres · Z up · front -Y · curves and upper taper are recorded proposals',font=small,fill='#bcaeac')
    im.save(out/'VIEWS'/(LABEL+'_'+view+'.png'),optimize=True)

def main():
    global PREFIX,LABEL
    parser=argparse.ArgumentParser();parser.add_argument('--no-renders',action='store_true');parser.add_argument('--dir',help='folder holding MODEL_SPEC.json; default is this folder');args=parser.parse_args()
    base=Path(args.dir).resolve() if args.dir else HERE;spec=json.loads((base/'MODEL_SPEC.json').read_text())
    LABEL=spec['revision'].split()[-1];PREFIX='PI-BLD-0001-V01_CrownLandmark_SHELL_'+LABEL
    out=base/'MODEL';out.mkdir(exist_ok=True);(out/'VIEWS').mkdir(exist_ok=True)
    construct(spec);measurements=export(spec,out)
    if not args.no_renders:
        for view in spec['cameras']:render(spec,out,view);print('Rendered',view,flush=True)
    manifest=[]
    for p in sorted(out.rglob('*')):
        if p.is_file() and p.name!='MODEL_MANIFEST.json' and not p.name.startswith('FIT_REVIEW'):
            b=p.read_bytes();manifest.append({'path':p.relative_to(base).as_posix(),'bytes':len(b),'sha256':hashlib.sha256(b).hexdigest()})
    (out/'MODEL_MANIFEST.json').write_text(json.dumps({'asset_id':spec['asset_id'],'revision':spec['revision'],'files':manifest},indent=2)+'\n')
    print(json.dumps({k:v for k,v in measurements.items() if k!='objects'},indent=2))

if __name__=='__main__':main()
