"""Build fig2_method.svg — DINO → pixel → 1x1 conv → ray logits → unproject. Top row pipeline (left to right): [RGB] → [DINO] → [PCA features 64×64×128] (highlighted pixel) → [1×1 Conv] → [ray-logit strip, blue→red] → "unproject" → [LIBERO frustum + ray viewer (still)] Ray-logit strip uses turbo colormap (blue = low prob, yellow/red = high prob). Uses synthetic volume cache for ray probabilities (delete /tmp/fig2_vol_cache.npz to regenerate). """ import base64 import os import time import numpy as np import matplotlib matplotlib.use("Agg") import matplotlib.pyplot as plt _t = time.time() # ═══════════════════════════════════════════════════════════════════════════ # Ray probabilities (synthetic) # ═══════════════════════════════════════════════════════════════════════════ CACHE = "/tmp/fig2_vol_cache.npz" if os.path.exists(CACHE): d = np.load(CACHE) vol_np = d["vol"] peak_hvu = tuple(int(x) for x in d["peak"]) else: hs, vs, us = np.meshgrid(np.arange(32), np.arange(64), np.arange(64), indexing="ij") d2 = ((hs - 11) / 3.0) ** 2 + ((vs - 32) / 5.0) ** 2 + ((us - 34) / 5.0) ** 2 main = np.exp(-d2) background = 0.02 * np.random.RandomState(0).rand(32, 64, 64) vol_np = (main + background) / (main + background).sum() peak_idx = int(vol_np.argmax()) peak_hvu = (peak_idx // (64*64), (peak_idx // 64) % 64, peak_idx % 64) h_peak, v_peak, u_peak = peak_hvu ray_probs = vol_np[:, v_peak, u_peak] # (32,) ray_probs_norm = ray_probs / ray_probs.max() print(f"peak bin = {int(ray_probs.argmax())} (h={h_peak}, v={v_peak}, u={u_peak})") # ═══════════════════════════════════════════════════════════════════════════ # Ray-logit strip SVG — horizontal, 32 cells, turbo blue→red # Size matches the 1×1 Conv box (~120 wide × 40 tall). # ═══════════════════════════════════════════════════════════════════════════ STRIP_X_LEFT = 500 STRIP_X_RIGHT = 626 STRIP_Y_TOP = 197 STRIP_H = 36 N_BINS = 32 cell_w = (STRIP_X_RIGHT - STRIP_X_LEFT) / N_BINS # 3.75 turbo = plt.cm.turbo strip_cells = [] for i in range(N_BINS): # i=0 → h=0 (ground) at left; i=31 → h=31 (top) at right p = float(ray_probs_norm[i]) x = STRIP_X_LEFT + i * cell_w c = turbo(p) r, g, b = int(c[0]*255), int(c[1]*255), int(c[2]*255) strip_cells.append( f'') strip_svg = '\n '.join(strip_cells) # ═══════════════════════════════════════════════════════════════════════════ # Assemble SVG # ═══════════════════════════════════════════════════════════════════════════ def b64(p): return base64.b64encode(open(p, "rb").read()).decode() ASSETS = "/data/cameron/penpot/figures/extracted" rgb_b64 = b64(f"{ASSETS}/fig1a_rgb_hires.png") pca_b64 = b64(f"{ASSETS}/fig1a_pca_hires.png") frustum_b64 = b64(f"{ASSETS}/fig2v3/frustum_ray.png") volume_b64 = b64(f"{ASSETS}/fig2v3/volume_highlight_crop.png") servo_b64 = b64(f"{ASSETS}/fig2v3/robot_servo_crop.png") # Panel (b): rendered image + metadata (key points' 2D pixel coords) two_frustums_b64 = b64(f"{ASSETS}/fig2v3/two_frustums.png") import json as _json with open(f"{ASSETS}/fig2v3/two_frustums_meta.json") as f: _meta = _json.load(f) # SVG placement for the rendered panel-b image (right 30% of canvas). # Image size chosen so panel (b) total height matches scaled panel (a). PB_IMG_X = 1020 PB_IMG_Y = 50 PB_IMG_W = 310 PB_IMG_H = 310 # square; the underlying render is 896x896 _pb_scale = PB_IMG_W / _meta["image_size"] def _to_svg(pt): return (PB_IMG_X + pt[0] * _pb_scale, PB_IMG_Y + pt[1] * _pb_scale) camA_x, camA_y = _to_svg(_meta["cam_A_2d"]) camB_x, camB_y = _to_svg(_meta["cam_B_2d"]) tgt_x, tgt_y = _to_svg(_meta["target_2d"]) tot_x, tot_y = _to_svg(_meta["target_on_table_2d"]) rayA_mx, rayA_my = _to_svg(_meta["ray_A_mid_2d"]) rayB_mx, rayB_my = _to_svg(_meta["ray_B_mid_2d"]) height_mx, height_my = _to_svg(_meta["height_mid_2d"]) _depth_A_str = f'{_meta["depth_A"]:.2f} m' _depth_B_str = f'{_meta["depth_B"]:.2f} m' _height_str = f'{_meta["height_z"]:.2f} m' GREEN = "#16653a" GRAY = "#6b7280" SLATE = "#334155" LIGHT = "#e5e7eb" DINO_ORANGE = "#d97e1f" HL = "#facc15" # yellow highlight for the selected pixel svg = f''' (a) Pixel-Aligned Heatmap Volume RGB input DINO backbone DINO FEATURES 64 × 64 × 128 1 pixel feature 1×1 Conv 32 RAY LOGITS {{STRIP}} h=0 h=31 unproject ① ONE RAY ray into scene ② FULL VOLUME + ARGMAX peak voxel = 3D target ③ ROBOT MOVES servo to 3D target (b) Height is view-invariant camera A camera B depth = {_depth_A_str} depth = {_depth_B_str} height z* = {_height_str} 3D target {_depth_A_str} vs {_depth_B_str} depth, same height z* PARA predicts height → view-invariant ground / robot base HEIGHT PLANE z = z* z* = 0.15 m 3D target camera A depth = 0.35 m camera B depth = 0.98 m Same 3D target, very different depths — but the height z* above the ground is identical in both views. PARA predicts height directly → view-invariant. ''' svg = svg.replace("{STRIP}", strip_svg) out = "/data/cameron/para/paper/figs/svg/fig2_method.svg" with open(out, "w") as f: f.write(svg) print(f"[{time.time()-_t:.2f}s] wrote {out} ({len(svg)} bytes)")