File size: 13,760 Bytes
012414f | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 | #!/usr/bin/env python3
import argparse
import json
import shutil
import subprocess
import time
from pathlib import Path
import cv2
import numpy as np
import torch
import triton as tr
import triton.language as tl
import triton.language.extra.cuda.libdevice as lib
from scipy.spatial.transform import Rotation, Slerp
@tr.jit
def field(x, y, z, ball, rod):
# Nodes at integer grid coordinates; no finite array or moving window.
qx = x - tl.floor(x + 0.5)
qy = y - tl.floor(y + 0.5)
qz = z - tl.floor(z + 0.5)
sx, sy, sz = qx*qx, qy*qy, qz*qz
ds = tl.sqrt(sx + sy + sz) - ball
dxy = tl.sqrt(sx + sy) - rod
dxz = tl.sqrt(sx + sz) - rod
dyz = tl.sqrt(sy + sz) - rod
return tl.minimum(ds, tl.minimum(dxy, tl.minimum(dxz, dyz)))
@tr.jit
def render_kernel(CAM, OUT, DEPTH, W: tl.constexpr, H: tl.constexpr,
BALL: tl.constexpr, ROD: tl.constexpr, FAR: tl.constexpr,
STEPS: tl.constexpr, BLOCK: tl.constexpr,
DIRECTION_RGB: tl.constexpr, BACKGROUND_ONLY: tl.constexpr):
i = tl.program_id(0)*BLOCK + tl.arange(0, BLOCK)
valid = i < W*H
px = (i % W - tl.load(CAM+2)) / tl.load(CAM)
py = (i // W - tl.load(CAM+3)) / tl.load(CAM+1)
inv = tl.rsqrt(px*px + py*py + 1.)
px, py, pz = px*inv, py*inv, inv
dx = tl.load(CAM+4)*px + tl.load(CAM+5)*py + tl.load(CAM+6)*pz
dy = tl.load(CAM+7)*px + tl.load(CAM+8)*py + tl.load(CAM+9)*pz
dz = tl.load(CAM+10)*px + tl.load(CAM+11)*py + tl.load(CAM+12)*pz
ox, oy, oz = tl.load(CAM+13), tl.load(CAM+14), tl.load(CAM+15)
t = tl.full((BLOCK,), .002, tl.float32)
hit = tl.full((BLOCK,), False, tl.int1)
active = valid & (not BACKGROUND_ONLY)
step = 0
while (tl.sum(active.to(tl.int32), 0) > 0) & (step < STEPS):
dist = field(ox+t*dx, oy+t*dy, oz+t*dz, BALL, ROD)
# abs also handles an origin inside a scaffold solid: find the exit.
new_hit = active & (tl.abs(dist) < .00015)
hit = hit | new_hit
active = active & ~new_hit
t = tl.where(active, t + tl.maximum(tl.abs(dist)*.95, .000075), t)
active = active & (t < FAR)
step += 1
x, y, z = ox+t*dx, oy+t*dy, oz+t*dz
e = .0003
nx = field(x+e,y,z,BALL,ROD)-field(x-e,y,z,BALL,ROD)
ny = field(x,y+e,z,BALL,ROD)-field(x,y-e,z,BALL,ROD)
nz = field(x,y,z+e,BALL,ROD)-field(x,y,z-e,BALL,ROD)
nn = tl.rsqrt(nx*nx+ny*ny+nz*nz+1.e-12)
diffuse = .55 + .45*tl.maximum(0., (nx*.36-ny*.80-nz*.48)*nn)
qx, qy, qz = x-tl.floor(x+.5), y-tl.floor(y+.5), z-tl.floor(z+.5)
sphere = tl.sqrt(qx*qx+qy*qy+qz*qz)-BALL < .0005
# Directional hue map: independent of translation and scaffold spacing.
lon = lib.atan2(dx, dz)
lat = lib.asin(tl.minimum(1., tl.maximum(-1., -dy)))
hue = lon/6.283185307179586+.5
rr = tl.minimum(1., tl.maximum(0., tl.abs(hue*6.-3.)-1.))
gg = tl.minimum(1., tl.maximum(0., 2.-tl.abs(hue*6.-2.)))
bb = tl.minimum(1., tl.maximum(0., 2.-tl.abs(hue*6.-4.)))
sat = .68 * (1.-.35*tl.abs(lat)/1.5707963267948966)
val = .86 + .10*tl.cos(lat*2.)
er, eg, eb = val*(1.-sat+sat*rr), val*(1.-sat+sat*gg), val*(1.-sat+sat*bb)
if DIRECTION_RGB:
# Continuous world-direction map, including at the poles. The base
# RGB map distinguishes signed latitude; graticule is decorative.
er, eg, eb = (dx+1.)*.5, (dy+1.)*.5, (dz+1.)*.5
# Fine white angular grid matches the visual motif of Wonder Fig. 4.
angle = 0.2617993877991494
glon = tl.abs(lon/angle-tl.floor(lon/angle+.5))*angle*tl.cos(lat)
glat = tl.abs(lat/angle-tl.floor(lat/angle+.5))*angle
aa = .75/tl.load(CAM)
grid = 1.-tl.minimum(1., tl.maximum(0., (tl.minimum(glon,glat)-aa)/(aa+1.e-7)))
if DIRECTION_RGB:
# Longitude is undefined at the poles: fade the angular overlay there.
grid *= tl.minimum(1., tl.sqrt(dx*dx+dz*dz)/.1)
er, eg, eb = er+(1.-er)*grid*.55, eg+(1.-eg)*grid*.55, eb+(1.-eb)*grid*.55
cr = tl.where(sphere, .92, .26)*diffuse
cg = tl.where(sphere, .28, .29)*diffuse
cb = tl.where(sphere, .16, .31)*diffuse
# Far attenuation reduces subpixel aliasing; world geometry remains fixed.
alpha = tl.where(hit, tl.exp(-tl.maximum(t-2.,0.)/8.), 0.)
cr, cg, cb = er*(1.-alpha)+cr*alpha, eg*(1.-alpha)+cg*alpha, eb*(1.-alpha)+cb*alpha
tl.store(OUT+3*i, (255.*cr).to(tl.uint8), valid)
tl.store(OUT+3*i+1, (255.*cg).to(tl.uint8), valid)
tl.store(OUT+3*i+2, (255.*cb).to(tl.uint8), valid)
tl.store(DEPTH+i, tl.where(hit,t,tl.where(active,-2.,-1.)),valid)
class Renderer:
def __init__(self, width=832, height=480, aa=2, far=64., steps=4096, environment='direction_rgb'):
self.width,self.height,self.aa,self.far,self.steps=width,height,aa,far,steps
self.environment=environment
self.rgb=torch.empty((height*aa,width*aa,3),device='cuda',dtype=torch.uint8)
self.depth=torch.empty((height*aa,width*aa),device='cuda')
def frame(self, c2w, K, spacing, radius=.05, rod=.008, background_only=False):
# The initial camera lies at a cell center, for every spacing variant.
# This phase is fixed for the whole trajectory, never recentered.
# Reduce only the evaluation coordinate of the periodic renderer.
# This is algebraically identical to the fixed infinite lattice, and
# avoids losing precision in X-round(X). Keep actual memory addresses
# unwrapped; this modulo is not a camera-following grid translation.
center=np.remainder(c2w[:3,3].astype(np.float64)/spacing + .5, 1.)
k=K.copy();k[:2,:]*=self.aa
k[0,2]+=(self.aa-1)*.5;k[1,2]+=(self.aa-1)*.5
packed=np.r_[k[0,0],k[1,1],k[0,2],k[1,2],c2w[:3,:3].ravel(),center].astype('float32')
cam=torch.tensor(packed,device='cuda')
w,h=self.width*self.aa,self.height*self.aa
render_kernel[(tr.cdiv(w*h,128),)](cam,self.rgb,self.depth,w,h,radius,rod,self.far,self.steps,128,
self.environment=='direction_rgb',background_only)
rgb=self.rgb.cpu().numpy()
if self.aa>1: rgb=cv2.resize(rgb,(self.width,self.height),interpolation=cv2.INTER_AREA)
dep=self.depth[::self.aa,::self.aa].cpu().numpy()
return rgb,dep
def make_trajectories(root, out, items=(4,10,15)):
out.mkdir(parents=True,exist_ok=True)
rows=[json.loads(x) for x in (root/'test/000000/index.jsonl').read_text().splitlines()]
paths=[]
for item in items:
row=next(x for x in rows if x['source_item_index']==item)
d=np.load(root/row['cameras']); t=d['timestamps_us'].astype(float)/1e6;t-=t[0]
assert t[-1]>=5., (item,t[-1])
target=np.arange(81)/16.;poses=d['c2w'].astype(float)
result=np.repeat(np.eye(4)[None],81,axis=0)
result[:,:3,:3]=Slerp(t,Rotation.from_matrix(poses[:,:3,:3]))(target).as_matrix()
for j in range(3):result[:,j,3]=np.interp(target,t,poses[:,j,3])
# One rigid gauge transform only; preserve metric scale.
result=np.linalg.inv(result[0])[None]@result
K=np.stack([np.interp(target,t,d['intrinsics'][:,i,j]) for i in range(3) for j in range(3)],axis=-1).reshape(81,3,3)
h,w=d['image_size_hw'];scale=max(832/w,480/h)
cropx=(w*scale-832)/2; cropy=(h*scale-480)/2
K[:,:2,:]*=scale
K[:,0,2]+=(scale-1)*.5-cropx;K[:,1,2]+=(scale-1)*.5-cropy
name=f're10k_{item:02d}_{row["source_key"]}'
path=out/(name+'.npz')
np.savez(path,c2w=result.astype('float32'),K=K.astype('float32'),times_s=target)
meta={'source_camera_file':str(root/row['cameras']),'source_metadata':str(root/row['metadata']),
'source_image_hw':d['image_size_hw'].tolist(),'resize_scale':scale,'crop_xy':[cropx,cropy],
'units':'official ViPE metric estimate, no translation scale fitting','sampling':'first 5 seconds, rotation Slerp, translation/K linear interpolation at 16fps',
'translation_path_m':float(np.linalg.norm(np.diff(result[:,:3,3],axis=0),axis=1).sum())}
path.with_suffix('.json').write_text(json.dumps(meta,indent=2));paths.append(path)
K=np.repeat(np.array([[600,0,415.5],[0,600,239.5],[0,0,1]],dtype='float32')[None],81,axis=0)
u=np.linspace(0,1,81)
for name in ('translate_1m','rotate_60deg','closed_loop'):
C=np.repeat(np.eye(4)[None],81,axis=0)
if name=='translate_1m':C[:,0,3]=u
elif name=='rotate_60deg':C[:,:3,:3]=Rotation.from_euler('y',60*u,degrees=True).as_matrix()
else:
C[:,0,3]=.4*np.sin(2*np.pi*u);C[:,2,3]=.3*(1-np.cos(2*np.pi*u))
C[:,:3,:3]=Rotation.from_euler('y',20*np.sin(2*np.pi*u),degrees=True).as_matrix()
path=out/(name+'.npz');np.savez(path,c2w=C.astype('float32'),K=K,times_s=u*5);paths.append(path)
return paths
def writer(path,w=832,h=480):
ffmpeg=shutil.which('ffmpeg') or '/opt/tiger/ss_bin/ffmpeg'
return subprocess.Popen([ffmpeg,'-v','error','-y','-f','rawvideo','-pix_fmt','rgb24','-s',f'{w}x{h}',
'-r','16','-i','-','-an','-c:v','libx264','-crf','17','-preset','fast',
'-threads','4','-pix_fmt','yuv420p','-movflags','+faststart',str(path)],stdin=subprocess.PIPE)
def run(args):
out=Path(args.output);out.mkdir(parents=True,exist_ok=True)
paths=make_trajectories(Path(args.annotations),out/'trajectories',args.scene_items)
renderer=Renderer(aa=args.aa,far=args.far,steps=args.steps,environment=args.environment)
tasks=[]
if args.mode=='preview':
for spacing in (.25,.5,1.,2.):
rgb,dep=renderer.frame(np.eye(4),np.array([[600,0,415.5],[0,600,239.5],[0,0,1.]]),spacing,args.radius)
cv2.imwrite(str(out/f'preview_{spacing}.png'),cv2.cvtColor(rgb,cv2.COLOR_RGB2BGR))
print(spacing,{'hit':float((dep>0).mean()),'unresolved':float((dep==-2).mean())},flush=True)
return
for path in paths[:len(args.scene_items)]:
for spacing in (.25,.5,1.,2.):tasks.append((path,spacing,args.radius))
for radius in args.radius_extras:tasks.append((paths[0],.5,radius))
if not args.no_synthetic_videos:
for path in paths[len(args.scene_items):]:tasks.append((path,.5,args.radius))
(out/'videos').mkdir(exist_ok=True);(out/'stills').mkdir(exist_ok=True)
summaries=[]
for path,spacing,radius in tasks:
name=f'{path.stem}_d{spacing:g}_r{radius:g}';video=out/'videos'/(name+'.mp4')
d=np.load(path);stats=[];start=time.perf_counter();proc=writer(video)
try:
for t in range(81):
rgb,dep=renderer.frame(d['c2w'][t],d['K'][t],spacing,radius)
proc.stdin.write(rgb.tobytes())
if t in (0,20,40,60,80):cv2.imwrite(str(out/'stills'/f'{name}_{t:03d}.png'),cv2.cvtColor(rgb,cv2.COLOR_RGB2BGR))
stats.append({'hit':float((dep>0).mean()),'unresolved':float((dep==-2).mean()),
'beyond_4_cells':float((dep>4).mean()),'beyond_8_cells':float((dep>8).mean()),
'near_half_cell':float(((dep>0)&(dep<.5)).mean())})
finally:proc.stdin.close()
if proc.wait()!=0:raise RuntimeError('ffmpeg failed')
summary={'name':name,'video':str(video),'trajectory':str(path),'spacing_m':spacing,'sphere_radius_over_spacing':radius,
'rod_radius_over_spacing':.008,'seconds':time.perf_counter()-start,
'mean_hit':float(np.mean([s['hit'] for s in stats])),
'max_unresolved':max(s['unresolved'] for s in stats),
'max_near_half_cell':max(s['near_half_cell'] for s in stats),
'mean_beyond_4_cells':float(np.mean([s['beyond_4_cells'] for s in stats])),
'mean_beyond_8_cells':float(np.mean([s['beyond_8_cells'] for s in stats]))}
summaries.append(summary)
(out/'metrics.json').write_text(json.dumps(summaries,indent=2))
print(json.dumps(summary),flush=True)
manifest={'worker':'1094200','shape':[81,480,832],'fps':16,'aa':args.aa,'far_cells':args.far,'max_steps':args.steps,
'geometry':'infinite periodic sphere/cylinder union, finite ray distance','origin':'(-Delta/2,-Delta/2,-Delta/2), fixed per trajectory',
'renderer':'custom CUDA Triton sphere tracing; not official Wonder OpenGL code','device':torch.cuda.get_device_name(),
'environment_mode':args.environment,'base_radius_ratio':args.radius,
'environment':('E(d)=(d+1)/2; 15 degree white graticule with polar fade' if args.environment=='direction_rgb'
else 'world longitude hue + latitude modulation + 15 degree white graticule'),
'distance_fog':'exp(-max(ray_distance_cells-2,0)/8), blends into directional environment','variants':summaries}
(out/'manifest.json').write_text(json.dumps(manifest,indent=2))
if __name__=='__main__':
p=argparse.ArgumentParser(description=__doc__)
p.add_argument('--output',required=True)
p.add_argument('--annotations',default='/mnt/hdfs/data_ssd/tianqi/re10k_annotations/vipe_dav3_v1')
p.add_argument('--scene-items',type=int,nargs='+',default=[4,10,15])
p.add_argument('--radius',type=float,default=.05)
p.add_argument('--radius-extras',type=float,nargs='*',default=[])
p.add_argument('--environment',choices=['direction_rgb','legacy_hsv'],default='direction_rgb')
p.add_argument('--no-synthetic-videos',action='store_true')
p.add_argument('--aa',type=int,default=2);p.add_argument('--far',type=float,default=64.)
p.add_argument('--steps',type=int,default=4096);p.add_argument('--mode',choices=['preview','sweep'],default='sweep')
run(p.parse_args())
|