Kernels:

phanerozoic
/

pathtracer-diff

Kernel card Files Files and versions

xet

Community

phanerozoic commited on Jul 16

Commit

2468c9d

verified ·

1 Parent(s): 269ccd5

Add hero

Browse files

Files changed (3) hide show

CARD.md +9 -0
README.md +10 -1
media/make_hero.py +167 -0

CARD.md CHANGED Viewed

@@ -18,6 +18,15 @@ albedo texels, the per-material emission, and the environment texels.
 Inverse rendering runs as a bare torch loop around the kernel, with no
 rendering framework in the loop: render, compare, `backward()`, step.
 ## Usage
 ```python

 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
 ```python

README.md CHANGED Viewed

@@ -18,6 +18,15 @@ albedo texels, the per-material emission, and the environment texels.
 Inverse rendering runs as a bare torch loop around the kernel, with no
 rendering framework in the loop: render, compare, `backward()`, step.
 ## Usage
 ```python
@@ -172,4 +181,4 @@ Duff et al., "Building an Orthonormal Basis, Revisited" (JCGT 2017); Wald,
 ## License
-Apache-2.0.

 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
 ```python
 ## License
+Apache-2.0.

media/make_hero.py ADDED Viewed

	@@ -0,0 +1,167 @@

+"""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
+import sys
+ROOT = os.path.dirname(os.path.dirname(os.path.abspath(__file__)))
+sys.path.insert(0, ROOT)
+import torch
+from PIL import Image
+import load_local
+ptd = load_local.load()
+DEV = "cuda"
+H = W = 256
+def quad(a, b, c, d):
+    return [[a, b, c], [a, c, d]]
+def add_box(verts, faces, mat, uv, lo, hi, mid, rot_deg=0.0):
+    x0, y0, z0 = lo
+    x1, y1, z1 = hi
+    cx, cz = (x0 + x1) / 2, (z0 + z1) / 2
+    ca, sa = math.cos(math.radians(rot_deg)), math.sin(math.radians(rot_deg))
+    b = len(verts)
+    for (x, y, z) in [(x0, y0, z0), (x1, y0, z0), (x1, y0, z1), (x0, y0, z1),
+                      (x0, y1, z0), (x1, y1, z0), (x1, y1, z1), (x0, y1, z1)]:
+        dx, dz = x - cx, z - cz
+        verts.append((cx + ca * dx - sa * dz, y, cz + sa * dx + ca * dz))
+    for q in [quad(b, b + 1, b + 2, b + 3), quad(b + 4, b + 7, b + 6, b + 5),
+              quad(b, b + 4, b + 5, b + 1), quad(b + 3, b + 2, b + 6, b + 7),
+              quad(b, b + 3, b + 7, b + 4), quad(b + 1, b + 5, b + 6, b + 2)]:
+        faces.extend(q)
+        mat.extend([mid, mid])
+        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()
+    loss.backward()
+    opt.step()
+    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)")