Kernels:

phanerozoic
/

pathtracer-diff

Kernel card Files Files and versions

xet

Community

phanerozoic commited on Jul 17

Commit

f65a7f1

verified ·

1 Parent(s): aa9c68a

Hero: three acts (appearance, geometry, fog), 384px

Browse files

Files changed (3) hide show

CARD.md +12 -6
README.md +12 -6
media/make_hero.py +241 -76

CARD.md CHANGED Viewed

@@ -22,14 +22,20 @@ and camera silhouettes. Inverse rendering runs as a bare torch loop around
 the kernel, with no rendering framework in the loop: render, compare,
 `backward()`, step.
-![inverse rendering time-lapse: a gray scene converging to a plasma-textured floor with a gold monolith and a glass box](https://huggingface.co/kernels/phanerozoic/pathtracer-diff/resolve/main/media/inverse.gif)
 *An inverse-rendering time-lapse produced entirely by this kernel
-(`media/make_hero.py`): from a gray start, Adam through `render()`
-recovers a 64x64 floor texture (12,288 unknowns), the gold conductor's
-tint, and the environment map against the fixed target on the right,
-with a glass box refracting the lot. Final parameter errors: texture
-0.047 mean, tint 0.007 max, environment 0.081 mean.*
 ## Usage

 the kernel, with no rendering framework in the loop: render, compare,
 `backward()`, step.
+![inverse rendering time-lapse in three acts: a dim gray scene converging to a plasma-textured floor with a gold monolith, red plastic block, glass boxes, and a glowing pi sign; a floating slab sliding home by its shadow; a Cornell box recovering its fog](https://huggingface.co/kernels/phanerozoic/pathtracer-diff/resolve/main/media/inverse.gif)
 *An inverse-rendering time-lapse produced entirely by this kernel
+(`media/make_hero.py`), live optimization frames against the fixed
+target on the right. Act 1: from a dim gray start, Adam through
+`render()` recovers a 128x128 per-texel floor albedo (49,152 unknowns),
+the gold conductor's tint (max err 0.005), a rough-plastic block's
+albedo through its coat (0.002), a 16x32 per-texel emissive pi sign
+(mean err 0.007), and the environment map, with a smooth glass box and
+a frosted rough-dielectric block refracting the scene; image loss falls
+8.3e-1 to 7.8e-6. Act 2: `geometry_grad()` alone slides the floating
+slab home from its shadow and silhouette, offset 2.00 to 0.001 in 130
+steps. Act 3: a Cornell box recovers its participating-medium
+coefficients from a hazy target; extinction max err 0.002.*
 ## Usage

README.md CHANGED Viewed

@@ -22,14 +22,20 @@ and camera silhouettes. Inverse rendering runs as a bare torch loop around
 the kernel, with no rendering framework in the loop: render, compare,
 `backward()`, step.
-![inverse rendering time-lapse: a gray scene converging to a plasma-textured floor with a gold monolith and a glass box](https://huggingface.co/kernels/phanerozoic/pathtracer-diff/resolve/main/media/inverse.gif)
 *An inverse-rendering time-lapse produced entirely by this kernel
-(`media/make_hero.py`): from a gray start, Adam through `render()`
-recovers a 64x64 floor texture (12,288 unknowns), the gold conductor's
-tint, and the environment map against the fixed target on the right,
-with a glass box refracting the lot. Final parameter errors: texture
-0.047 mean, tint 0.007 max, environment 0.081 mean.*
 ## Usage

 the kernel, with no rendering framework in the loop: render, compare,
 `backward()`, step.
+![inverse rendering time-lapse in three acts: a dim gray scene converging to a plasma-textured floor with a gold monolith, red plastic block, glass boxes, and a glowing pi sign; a floating slab sliding home by its shadow; a Cornell box recovering its fog](https://huggingface.co/kernels/phanerozoic/pathtracer-diff/resolve/main/media/inverse.gif)
 *An inverse-rendering time-lapse produced entirely by this kernel
+(`media/make_hero.py`), live optimization frames against the fixed
+target on the right. Act 1: from a dim gray start, Adam through
+`render()` recovers a 128x128 per-texel floor albedo (49,152 unknowns),
+the gold conductor's tint (max err 0.005), a rough-plastic block's
+albedo through its coat (0.002), a 16x32 per-texel emissive pi sign
+(mean err 0.007), and the environment map, with a smooth glass box and
+a frosted rough-dielectric block refracting the scene; image loss falls
+8.3e-1 to 7.8e-6. Act 2: `geometry_grad()` alone slides the floating
+slab home from its shadow and silhouette, offset 2.00 to 0.001 in 130
+steps. Act 3: a Cornell box recovers its participating-medium
+coefficients from a hazy target; extinction max err 0.002.*
 ## Usage

media/make_hero.py CHANGED Viewed

@@ -1,10 +1,20 @@
-"""Hero time-lapse for the card: inverse rendering, live.
-From a gray start, Adam through render() recovers a 64x64 floor texture
-(12,288 unknowns), the gold conductor's tint, and the environment map
-against a fixed target (right panel), with a glass box refracting the lot.
-Rendered and differentiated entirely by the kernel. Output:
-media/inverse.gif (animated, log-spaced snapshots).
 """
 import math
 import os
@@ -21,7 +31,8 @@ import load_local
 ptd = load_local.load()
 DEV = "cuda"
-H = W = 256
 def quad(a, b, c, d):
@@ -46,94 +57,136 @@ def add_box(verts, faces, mat, uv, lo, hi, mid, rot_deg=0.0):
         uv.extend([[(0, 0)] * 3] * 2)
-def build_scene(floor_tex, gold, env):
     verts, faces, mat, uv = [], [], [], []
     b = len(verts)
     verts.extend([(-5, 0, -5), (5, 0, -5), (5, 0, 5), (-5, 0, 5)])
     faces.extend(quad(b, b + 1, b + 2, b + 3))
     mat.extend([0, 0])
     uv.extend([[(0, 0), (1, 0), (1, 1)], [(0, 0), (1, 1), (0, 1)]])
-    add_box(verts, faces, mat, uv, (1.1, 0, -0.6), (2.5, 2.6, 0.8), 1, 25.0)
-    add_box(verts, faces, mat, uv, (-2.5, 0, 0.2), (-0.9, 2.2, 1.8), 2, 12.0)
     b = len(verts)
-    verts.extend([(-1, 6.5, -1), (1, 6.5, -1), (1, 6.5, 1), (-1, 6.5, 1)])
     faces.extend(quad(b, b + 1, b + 2, b + 3))
-    mat.extend([3, 3])
     uv.extend([[(0, 0)] * 3] * 2)
-    return ptd.Scene(verts, faces, mat,
-                     albedo=[floor_tex, gold,
-                             torch.tensor([1.0, 1.0, 1.0], device=DEV),
-                             torch.tensor([0.8, 0.8, 0.8], device=DEV)],
-                     emission=[[0, 0, 0], [0, 0, 0], [0, 0, 0],
-                               [7.0, 6.5, 5.8]],
-                     material_types=[ptd.DIFFUSE, ptd.CONDUCTOR,
-                                     ptd.DIELECTRIC, ptd.DIFFUSE],
-                     roughness=[0.3, 0.10, 0.0, 0.3],
-                     ior=[1.5, 1.5, 1.5, 1.5], uvs=uv, env=env)
-def plasma(n=64):
     y, x = torch.meshgrid(torch.linspace(0, 1, n), torch.linspace(0, 1, n),
                           indexing="ij")
-    r = 0.5 + 0.45 * torch.sin(6.0 * x + 9.0 * y * y + 1.2)
-    g = 0.5 + 0.45 * torch.sin(8.0 * (x - 0.5) ** 2 + 5.5 * y + 3.9)
-    bl = 0.5 + 0.45 * torch.sin(7.0 * torch.sqrt((x - 0.5) ** 2 +
-                                                 (y - 0.5) ** 2) * 4.0 + 0.7)
     t = torch.stack([r, g, bl], dim=-1)
-    return (0.08 + 0.84 * t).to(DEV)
 def sky(eh=16, ew=32):
     v = torch.linspace(0, 1, eh).unsqueeze(1).unsqueeze(2)
-    top = torch.tensor([0.32, 0.52, 1.10]) * 1.25
-    hor = torch.tensor([1.15, 0.72, 0.42])
     e = top * (1 - v) + hor * v
     return e.expand(eh, ew, 3).contiguous().to(DEV)
-cam = ptd.Camera(position=(7.0, 4.2, 9.0), look_at=(0.0, 1.1, 0.4),
-                 vfov_deg=42.0)
-tex_t = plasma()
-gold_t = torch.tensor([1.0, 0.72, 0.30], device=DEV)
-env_t = sky()
-target_scene = build_scene(tex_t, gold_t, env_t)
-target_hi = ptd.render(target_scene, cam, H, W, spp=200, max_bounces=6,
-                       seed=3).detach()
-target_lo = ptd.render(target_scene, cam, H, W, spp=8, max_bounces=6,
-                       seed=3).detach()
-tex = torch.full((64, 64, 3), 0.45, device=DEV, requires_grad=True)
-gold = torch.full((3,), 0.55, device=DEV, requires_grad=True)
-env = torch.full((16, 32, 3), 0.35, device=DEV, requires_grad=True)
-scene = build_scene(tex, gold, env)
-opt = torch.optim.Adam([tex, gold, env], lr=0.06)
-ITERS = 240
-snaps = sorted({0, 1, 2, 3, 4, 5, 7, 9, 12, 15, 19, 24, 30, 38, 48, 60, 75,
-                95, 120, 150, 190, 239})
 def tonemap(img):
-    x = img.clamp(0, 1) ** (1 / 2.2)
     return (x * 255).byte().cpu().numpy()
-def panel(left_img):
-    gap = 12
-    fr = Image.new("RGB", (W * 2 * 2 + gap, H * 2), (16, 16, 16))
-    li = Image.fromarray(tonemap(left_img)).resize((W * 2, H * 2),
-                                                   Image.LANCZOS)
-    ri = Image.fromarray(tonemap(target_hi)).resize((W * 2, H * 2),
-                                                    Image.LANCZOS)
-    fr.paste(li, (0, 0))
-    fr.paste(ri, (W * 2 + gap, 0))
     return fr
-frames = []
 losses = []
 for it in range(ITERS):
     opt.zero_grad()
     img = ptd.render(scene, cam, H, W, spp=8, max_bounces=6, seed=3)
     loss = (img - target_lo).square().mean()
@@ -142,26 +195,138 @@ for it in range(ITERS):
     with torch.no_grad():
         tex.clamp_(0.02, 0.98)
         gold.clamp_(0.02, 1.0)
         env.clamp_(0.0, 3.0)
     losses.append(loss.item())
-    if it in snaps:
-        frames.append(panel(img.detach()))
-final_hi = ptd.render(scene, cam, H, W, spp=200, max_bounces=6,
                       seed=9).detach()
-for _ in range(10):
-    frames.append(panel(final_hi))
-durations = [240] * 6 + [140] * (len(frames) - 16) + [140] * 9 + [2600]
 gif = os.path.join(ROOT, "media", "inverse.gif")
 frames[0].save(gif, save_all=True, append_images=frames[1:],
                duration=durations, loop=0, optimize=True)
 chk = Image.open(gif)
 size = os.path.getsize(gif) / 1e6
-tex_err = (tex.detach() - tex_t).abs().mean().item()
-gold_err = (gold.detach() - gold_t).abs().max().item()
-env_err = (env.detach() - env_t).abs().mean().item()
-print(f"loss {losses[0]:.2e} -> {losses[-1]:.2e} in {ITERS} steps")
-print(f"floor texture mean abs err {tex_err:.3f}; gold tint max err "
-      f"{gold_err:.3f}; env mean abs err {env_err:.3f}")
 print(f"wrote {gif} ({size:.1f} MB, {chk.n_frames} frames)")

+"""Hero time-lapse for the card: inverse rendering, live, every feature.
+Act 1 (appearance): from a dim gray start, Adam through render() recovers
+simultaneously a 128x128 per-texel floor albedo (49,152 unknowns), the
+gold GGX conductor's tint, a rough-plastic block's albedo through its
+specular coat, a 16x32 per-texel emissive sign (a glowing pi glyph), and
+the environment map, with a smooth glass box and a frosted
+rough-dielectric block refracting the scene throughout.
+Act 2 (geometry): with appearance fixed, geometry_grad() alone recovers
+the position of a floating occluder slab from its shadow and its image
+silhouette (dual-number interior + edge-sampled boundary terms).
+Act 3 (fog): a Cornell box recovers its homogeneous medium coefficients
+(sigma_a, sigma_s) from a hazy target under detached distance sampling.
+Output: media/inverse.gif, live panel | target panel, 384x384 native.
 """
 import math
 import os
 ptd = load_local.load()
 DEV = "cuda"
+H = W = 384
+GAP = 12
 def quad(a, b, c, d):
         uv.extend([[(0, 0)] * 3] * 2)
+OCC_CENTER = (0.5, 0.3)  # target x/z offset of the occluder box
+def build_scene(floor_tex, gold, plast, sign_emi, env, occ_t):
     verts, faces, mat, uv = [], [], [], []
     b = len(verts)
     verts.extend([(-5, 0, -5), (5, 0, -5), (5, 0, 5), (-5, 0, 5)])
     faces.extend(quad(b, b + 1, b + 2, b + 3))
     mat.extend([0, 0])
     uv.extend([[(0, 0), (1, 0), (1, 1)], [(0, 0), (1, 1), (0, 1)]])
+    add_box(verts, faces, mat, uv, (1.2, 0, -0.9), (2.4, 3.0, 0.3), 1, 22.0)
+    add_box(verts, faces, mat, uv, (-2.6, 0, 0.6), (-1.0, 2.0, 2.2), 2, 10.0)
+    add_box(verts, faces, mat, uv, (-1.0, 0, -2.8), (0.4, 1.9, -1.5), 3, -15.0)
+    add_box(verts, faces, mat, uv, (2.9, 0, 2.2), (4.2, 1.3, 3.5), 4, 35.0)
     b = len(verts)
+    verts.extend([(-1.5, 6.8, -1.5), (1.5, 6.8, -1.5), (1.5, 6.8, 1.5),
+                  (-1.5, 6.8, 1.5)])
     faces.extend(quad(b, b + 1, b + 2, b + 3))
+    mat.extend([5, 5])
     uv.extend([[(0, 0)] * 3] * 2)
+    b = len(verts)
+    verts.extend([(-4.3, 3.7, -4.8), (-1.1, 3.7, -4.8),
+                  (-1.1, 5.3, -4.8), (-4.3, 5.3, -4.8)])
+    faces.extend(quad(b, b + 1, b + 2, b + 3))
+    mat.extend([6, 6])
+    uv.extend([[(0, 0), (1, 0), (1, 1)], [(0, 0), (1, 1), (0, 1)]])
+    occ0 = len(verts)
+    tx, tz = OCC_CENTER[0] + float(occ_t[0]), OCC_CENTER[1] + float(occ_t[1])
+    add_box(verts, faces, mat, uv, (-1.0 + tx, 3.1, -1.0 + tz),
+            (1.0 + tx, 3.35, 1.0 + tz), 7, 0.0)
+    scene = ptd.Scene(
+        verts, faces, mat,
+        albedo=[floor_tex, gold,
+                torch.tensor([1.0, 1.0, 1.0], device=DEV),
+                plast,
+                torch.tensor([1.0, 1.0, 1.0], device=DEV),
+                torch.tensor([0.8, 0.8, 0.8], device=DEV),
+                torch.tensor([0.06, 0.06, 0.10], device=DEV),
+                torch.tensor([0.16, 0.15, 0.17], device=DEV)],
+        emission=[torch.zeros(3), torch.zeros(3), torch.zeros(3),
+                  torch.zeros(3), torch.zeros(3),
+                  torch.tensor([26.0, 23.0, 19.0]), sign_emi, torch.zeros(3)],
+        material_types=[ptd.DIFFUSE, ptd.CONDUCTOR, ptd.DIELECTRIC,
+                        ptd.PLASTIC, ptd.ROUGH_DIELECTRIC, ptd.DIFFUSE,
+                        ptd.DIFFUSE, ptd.DIFFUSE],
+        roughness=[0.3, 0.10, 0.0, 0.20, 0.12, 0.3, 0.3, 0.3],
+        ior=[1.5] * 8, uvs=uv, env=env)
+    return scene, occ0
+def plasma(n=128):
     y, x = torch.meshgrid(torch.linspace(0, 1, n), torch.linspace(0, 1, n),
                           indexing="ij")
+    r = 0.5 + 0.5 * torch.sin(9.0 * x + 11.0 * y * y + 1.2)
+    g = 0.5 + 0.5 * torch.sin(10.0 * (x - 0.5) ** 2 + 7.5 * y + 3.9)
+    bl = 0.5 + 0.5 * torch.sin(9.0 * torch.sqrt((x - 0.5) ** 2 +
+                                                (y - 0.5) ** 2) * 4.0 + 0.7)
     t = torch.stack([r, g, bl], dim=-1)
+    return (0.04 + 0.92 * t).clamp(0.02, 0.98).to(DEV)
+def pi_sign(h=16, w=32):
+    # texture row 0 sits at the BOTTOM of the sign quad (v runs upward)
+    e = torch.full((h, w, 3), 0.10)
+    e[..., 2] = 0.35  # dim blue field
+    glyph = torch.zeros(h, w, dtype=torch.bool)
+    glyph[11:13, 7:25] = True   # bar (near the top)
+    glyph[3:11, 10:13] = True   # left leg
+    glyph[4:11, 19:22] = True   # right leg
+    glyph[3:5, 19:24] = True    # right foot flick
+    bright = torch.tensor([11.0, 17.0, 18.0])
+    e[glyph] = bright
+    return e.to(DEV)
 def sky(eh=16, ew=32):
     v = torch.linspace(0, 1, eh).unsqueeze(1).unsqueeze(2)
+    top = torch.tensor([0.12, 0.18, 0.42])
+    hor = torch.tensor([0.85, 0.42, 0.22])
     e = top * (1 - v) + hor * v
     return e.expand(eh, ew, 3).contiguous().to(DEV)
+cam = ptd.Camera(position=(7.4, 5.0, 9.4), look_at=(0.0, 1.3, -0.4),
+                 vfov_deg=43.0)
 def tonemap(img):
+    x = (img * 1.25).clamp(0, 1) ** (1 / 2.2)
     return (x * 255).byte().cpu().numpy()
+def panel(left_img, right_np):
+    fr = Image.new("RGB", (W * 2 + GAP, H), (14, 14, 14))
+    fr.paste(Image.fromarray(tonemap(left_img)), (0, 0))
+    fr.paste(Image.fromarray(right_np), (W + GAP, 0))
     return fr
+# ---- act 1: targets
+tex_t = plasma()
+gold_t = torch.tensor([1.0, 0.72, 0.30], device=DEV)
+plast_t = torch.tensor([0.85, 0.12, 0.10], device=DEV)
+sign_t = pi_sign()
+env_t = sky()
+t_target = torch.zeros(2)
+target_scene, _ = build_scene(tex_t, gold_t, plast_t, sign_t, env_t, t_target)
+target_hi = ptd.render(target_scene, cam, H, W, spp=768, max_bounces=6,
+                       seed=9).detach()
+target_lo = ptd.render(target_scene, cam, H, W, spp=8, max_bounces=6,
+                       seed=3).detach()
+target_np = tonemap(target_hi)
+# ---- act 1: appearance parameters (dim gray start; occluder at target)
+tex = torch.full((128, 128, 3), 0.35, device=DEV, requires_grad=True)
+gold = torch.full((3,), 0.40, device=DEV, requires_grad=True)
+plast = torch.full((3,), 0.40, device=DEV, requires_grad=True)
+sign = torch.full((16, 32, 3), 1.5, device=DEV, requires_grad=True)
+env = torch.full((16, 32, 3), 0.12, device=DEV, requires_grad=True)
+opt = torch.optim.Adam([
+    {"params": [tex, gold, plast, env], "lr": 0.06},
+    {"params": [sign], "lr": 0.12},
+])
+ITERS = 480
+STRIDE = 4
+frames, durations = [], []
 losses = []
 for it in range(ITERS):
+    scene, _ = build_scene(tex, gold, plast, sign, env, t_target)
     opt.zero_grad()
     img = ptd.render(scene, cam, H, W, spp=8, max_bounces=6, seed=3)
     loss = (img - target_lo).square().mean()
     with torch.no_grad():
         tex.clamp_(0.02, 0.98)
         gold.clamp_(0.02, 1.0)
+        plast.clamp_(0.02, 0.98)
+        sign.clamp_(0.0, 30.0)
         env.clamp_(0.0, 3.0)
     losses.append(loss.item())
+    if it % STRIDE == 0:
+        frames.append(panel(img.detach(), target_np))
+        durations.append(120 if it < 24 else 55)
+scene, _ = build_scene(tex, gold, plast, sign, env, t_target)
+final_hi = ptd.render(scene, cam, H, W, spp=768, max_bounces=6,
                       seed=9).detach()
+frames.append(panel(final_hi, target_np))
+durations.append(2600)
+# ---- act 2: geometry only, appearance fixed at the recovered values
+occ_t = torch.tensor([-1.6, 1.2], requires_grad=True)  # displaced start
+opt_g = torch.optim.Adam([occ_t], lr=0.04)
+texf = tex.detach()
+goldf = gold.detach()
+plastf = plast.detach()
+signf = sign.detach()
+envf = env.detach()
+GEO_ITERS = 130
+for it in range(GEO_ITERS):
+    scene, occ0 = build_scene(texf, goldf, plastf, signf, envf,
+                              occ_t.detach())
+    img = ptd.render(scene, cam, H, W, spp=8, max_bounces=6,
+                     seed=3).detach()
+    dldi = (2.0 / img.numel()) * (img - target_lo)
+    gv = ptd.geometry_grad(scene, cam, dldi, spp=16, edge_samples=1 << 17,
+                           seed=17 + it)
+    opt_g.zero_grad()
+    g = gv[occ0:occ0 + 8][:, [0, 2]].sum(dim=0).cpu()
+    gn = g.norm()
+    if gn > 0.5:  # near-contact shadow geometry can spike; clip
+        g = g * (0.5 / gn)
+    occ_t.grad = g
+    opt_g.step()
+    if it % 2 == 0:
+        frames.append(panel(img, target_np))
+        durations.append(55)
+scene, _ = build_scene(texf, goldf, plastf, signf, envf, occ_t.detach())
+geo_hi = ptd.render(scene, cam, H, W, spp=768, max_bounces=6,
+                    seed=9).detach()
+frames.append(panel(geo_hi, target_np))
+durations.append(2600)
+# ---- act 3: fog recovery in a Cornell box
+def cornell_scene(sa, ss):
+    verts, faces, mat = [], [], []
+    def wall(a, b, c, d, m):
+        b0 = len(verts)
+        verts.extend([a, b, c, d])
+        faces.extend(quad(b0, b0 + 1, b0 + 2, b0 + 3))
+        mat.extend([m, m])
+    X, Y, Z = 5.56, 5.488, 5.592
+    wall((0, 0, 0), (X, 0, 0), (X, 0, Z), (0, 0, Z), 0)
+    wall((0, Y, 0), (0, Y, Z), (X, Y, Z), (X, Y, 0), 0)
+    wall((0, 0, Z), (X, 0, Z), (X, Y, Z), (0, Y, Z), 0)
+    wall((0, 0, 0), (0, 0, Z), (0, Y, Z), (0, Y, 0), 1)
+    wall((X, 0, 0), (X, Y, 0), (X, Y, Z), (X, 0, Z), 2)
+    wall((2.13, Y - 0.001, 2.27), (3.43, Y - 0.001, 2.27),
+         (3.43, Y - 0.001, 3.32), (2.13, Y - 0.001, 3.32), 3)
+    sc = ptd.Scene(verts, faces, mat,
+                   albedo=[[0.73] * 3, [0.65, 0.05, 0.05],
+                           [0.12, 0.45, 0.15], [0.78] * 3],
+                   emission=[[0, 0, 0], [0, 0, 0], [0, 0, 0],
+                             [18.4, 15.6, 8.0]],
+                   medium=(sa, ss))
+    sc.med_sbar = 0.10  # fixed detached rate across the optimization
+    return sc
+fcam = ptd.Camera(position=(2.78, 2.73, -8.0), look_at=(2.78, 2.73, 2.8),
+                  vfov_deg=39.0)
+sa_t = torch.tensor([0.030, 0.055, 0.085], device=DEV)
+ss_t = torch.tensor([0.110, 0.095, 0.075], device=DEV)
+fog_target_hi = ptd.render(cornell_scene(sa_t, ss_t), fcam, H, W, spp=512,
+                           max_bounces=6, seed=9).detach()
+fog_target_lo = ptd.render(cornell_scene(sa_t, ss_t), fcam, H, W, spp=16,
+                           max_bounces=6, seed=5).detach()
+fog_target_np = tonemap(fog_target_hi)
+sa = torch.full((3,), 0.004, device=DEV, requires_grad=True)
+ss = torch.full((3,), 0.004, device=DEV, requires_grad=True)
+fog_scene = cornell_scene(sa.detach().clone(), ss.detach().clone())
+opt_f = torch.optim.Adam([sa, ss], lr=0.006)
+FOG_ITERS = 240
+fog_loss0 = None
+for it in range(FOG_ITERS):
+    opt_f.zero_grad()
+    fog_scene.med_sa = sa
+    fog_scene.med_ss = ss
+    img = ptd.render(fog_scene, fcam, H, W, spp=16, max_bounces=6, seed=5)
+    loss = (img - fog_target_lo).square().mean()
+    loss.backward()
+    opt_f.step()
+    with torch.no_grad():
+        sa.clamp_(1e-4, 1.0)
+        ss.clamp_(1e-4, 1.0)
+    if fog_loss0 is None:
+        fog_loss0 = loss.item()
+    if it % 6 == 0:
+        frames.append(panel(img.detach(), fog_target_np))
+        durations.append(55)
+fog_scene.med_sa = sa.detach()
+fog_scene.med_ss = ss.detach()
+fog_hi = ptd.render(fog_scene, fcam, H, W, spp=512, max_bounces=6,
+                    seed=9).detach()
+frames.append(panel(fog_hi, fog_target_np))
+durations.append(2600)
 gif = os.path.join(ROOT, "media", "inverse.gif")
 frames[0].save(gif, save_all=True, append_images=frames[1:],
                duration=durations, loop=0, optimize=True)
 chk = Image.open(gif)
 size = os.path.getsize(gif) / 1e6
+print(f"act 1 loss {losses[0]:.2e} -> {losses[-1]:.2e} in {ITERS} steps")
+print(f"floor tex mean err {(tex.detach() - tex_t).abs().mean():.3f}; "
+      f"gold max err {(gold.detach() - gold_t).abs().max():.3f}; "
+      f"plastic max err {(plast.detach() - plast_t).abs().max():.3f}")
+print(f"sign mean err {(sign.detach() - sign_t).abs().mean():.3f}; "
+      f"env mean err {(env.detach() - env_t).abs().mean():.3f}")
+print(f"act 2 occluder offset residual {occ_t.detach().norm():.3f} "
+      f"(start 2.00) in {GEO_ITERS} geometry-only steps")
+st_err = ((sa + ss).detach() - (sa_t + ss_t)).abs().max()
+print(f"fog: loss {fog_loss0:.2e} -> {loss.item():.2e}; "
+      f"sigma_a err {(sa.detach() - sa_t).abs().max():.4f}, "
+      f"sigma_s err {(ss.detach() - ss_t).abs().max():.4f}, "
+      f"sigma_t err {st_err:.4f}")
 print(f"wrote {gif} ({size:.1f} MB, {chk.n_frames} frames)")