| import numpy as np |
| from PIL import Image |
| VIEWS={ |
| 'front':((0,0,1),(0,1,0)),'back':((0,0,-1),(0,1,0)), |
| 'left':((1,0,0),(0,1,0)),'right':((-1,0,0),(0,1,0)), |
| 'top':((0,-1,0),(0,0,-1)),'bottom':((0,1,0),(0,0,1))} |
| def vnormals(V,F): |
| fn=np.cross(V[F[:,1]]-V[F[:,0]],V[F[:,2]]-V[F[:,0]]) |
| N=np.zeros_like(V) |
| for k in range(3): np.add.at(N,F[:,k],fn) |
| n=np.linalg.norm(N,axis=1,keepdims=True); return N/np.maximum(n,1e-12) |
| def camera(view,center,extent,persp=False): |
| if view=='perspective': |
| az,el=np.radians(-35),np.radians(18) |
| d=np.array([np.sin(az)*np.cos(el)*-1,-np.sin(el)*-1*-1,np.cos(az)*np.cos(el)]) |
| f=np.array([np.sin(az)*np.cos(el),-np.sin(el),np.cos(az)*np.cos(el)]) |
| |
| f=np.array([-np.sin(np.radians(35))*np.cos(el),-np.sin(el),np.cos(np.radians(35))*np.cos(el)]) |
| up=np.array([0,1,0.]) |
| else: |
| f=np.array(VIEWS[view][0],float); up=np.array(VIEWS[view][1],float) |
| r=np.cross(f,up); r/=np.linalg.norm(r); u=np.cross(r,f) |
| return f,r,u |
| def render(meshes,view,size=800,extent=None,center=None,bg=(255,255,255),persp=False,mask_only=False): |
| """meshes: list of (V,F,color). returns RGB uint8 image and per-mesh id buffer.""" |
| allV=np.vstack([m[0] for m in meshes]) |
| if center is None: center=(allV.min(0)+allV.max(0))/2 |
| if extent is None: extent=np.linalg.norm(allV.max(0)-allV.min(0))*0.62 |
| f,r,u=camera(view,center,extent) |
| isp=(view=='perspective') |
| img=np.zeros((size,size,3),np.float32); img[:]=bg |
| zb=np.full((size,size),1e9); idb=np.full((size,size),-1,np.int32) |
| L=-f*0.7+u*0.5+r*-0.3; L/=np.linalg.norm(L) |
| for mi,(V,F,col) in enumerate(meshes): |
| N=vnormals(V,F) |
| rel=V-center |
| x=rel@r; y=rel@u; z=rel@f |
| if isp: |
| D=extent*3.2; s=D/(D+z); x=x*s; y=y*s |
| sx=(x/extent*0.5+0.5)*size; sy=(0.5-y/extent*0.5)*size |
| col=np.array(col,float) |
| for tri in F: |
| a,b,c=tri |
| xs=sx[tri]; ys=sy[tri] |
| x0=max(int(np.floor(xs.min())),0); x1=min(int(np.ceil(xs.max())),size-1) |
| y0=max(int(np.floor(ys.min())),0); y1=min(int(np.ceil(ys.max())),size-1) |
| if x1<x0 or y1<y0: continue |
| den=(ys[1]-ys[2])*(xs[0]-xs[2])+(xs[2]-xs[1])*(ys[0]-ys[2]) |
| if abs(den)<1e-9: continue |
| gx,gy=np.meshgrid(np.arange(x0,x1+1)+0.5,np.arange(y0,y1+1)+0.5) |
| w0=((ys[1]-ys[2])*(gx-xs[2])+(xs[2]-xs[1])*(gy-ys[2]))/den |
| w1=((ys[2]-ys[0])*(gx-xs[2])+(xs[0]-xs[2])*(gy-ys[2]))/den |
| w2=1-w0-w1 |
| m=(w0>=-1e-4)&(w1>=-1e-4)&(w2>=-1e-4) |
| if not m.any(): continue |
| zz=w0*z[a]+w1*z[b]+w2*z[c] |
| sub=zb[y0:y1+1,x0:x1+1] |
| mm=m&(zz<sub) |
| if not mm.any(): continue |
| sub[mm]=zz[mm]; idb[y0:y1+1,x0:x1+1][mm]=mi |
| if not mask_only: |
| nn=(w0[mm,None]*N[a]+w1[mm,None]*N[b]+w2[mm,None]*N[c]) |
| nn/=np.maximum(np.linalg.norm(nn,axis=1,keepdims=True),1e-9) |
| lam=np.clip(-(nn@f)*0.0+(nn@L),0,1) |
| head=np.clip(-(nn@f),0,1) |
| sh=0.30+0.45*lam+0.35*head |
| img[y0:y1+1,x0:x1+1][mm]=np.clip(col[None,:]*sh[:,None],0,255) |
| return img.astype(np.uint8),idb,zb |
|
|
