diff options
| author | Gabriel Schneider <[email protected]> | 2026-11-10 14:48:26 -0300 |
|---|---|---|
| committer | Gabriel Schneider <[email protected]> | 2026-11-10 15:14:31 -0300 |
| commit | 7e9bf9e6e85c6c6e7a400d4fa0b43b77133ed3cb (patch) | |
| tree | a6add92cd4dcbbf4c31cd1ce989d99b190258353 /anim/tools/motion.py | |
| parent | ed46c51fe127377eb1fde8dee83da984e0f61860 (diff) | |
| download | computeranim-7e9bf9e6e85c6c6e7a400d4fa0b43b77133ed3cb.tar.gz computeranim-7e9bf9e6e85c6c6e7a400d4fa0b43b77133ed3cb.zip | |
canim: animations of recordings, as a debugger's whole context with a lens beside it
A package of its own (anim/), on sketchbook's anim module and pardes's
syntax. A scene opens a recording, takes a cursor into it, and declares
blocks that read the moment the cursor is at: the state column (registers
each followed as a pointer and inked by where it points, the stack
telescope, the backtrace), the program column (the whole source, the
disassembly in address order, and the scene's lens: a node-link list over
a hexdump of its heap, array cells, a call tree, a syscall crossing), and
ties between them. Motion is a step told as a sentence (the line fires,
its effects cascade a level at a time, the mark moves on last), timed by
what the step contains; walk, hurry and sprint pace a loop. Five scenes
from real recordings of fib, a linked list, a sort and syscalls.
First drafts, by the agent's own handover: the frame of the design's
second revision, the hexdump lens and the ties; no disassembly
annotations, no gallery, scenes not yet reviewed against the mocks.
Diffstat (limited to 'anim/tools/motion.py')
| -rw-r--r-- | anim/tools/motion.py | 210 |
1 files changed, 210 insertions, 0 deletions
diff --git a/anim/tools/motion.py b/anim/tools/motion.py new file mode 100644 index 0000000..9bf0a39 --- /dev/null +++ b/anim/tools/motion.py @@ -0,0 +1,210 @@ +#!/usr/bin/env python3 +"""Motion, made visible: a scene judged by how it moves, not by its stills. + + motion.py SCENE_EXE OUT_DIR [--size 960x540] [--fps 60] + +Exports the scene twice (it is deterministic) and writes into OUT_DIR: + + change.png how much of the picture changes from each frame to the + next: the whole frame on top (log scale), then a lane for + each panel, the head and the caption. Holds are gaps, + a metronome is evenly spaced spikes, overlapping action + is lanes that light one after another. + change-NN.png the same, ten seconds a picture, a frame about two pixels. + sheet-NN.png contact sheets: a row for each transition (a run of + frames in which something changes), six frames of it + side by side, cropped to where the change is, with its + length and the hold after it. + transitions.txt every transition: when, how long, how much, which panels + in what order, and the hold that follows. + +and prints the summary: how many transitions, how long the holds are, how +regular the beat is. +""" +import os, subprocess, sys +import numpy as np +from PIL import Image, ImageDraw +import matplotlib +matplotlib.use("Agg") +import matplotlib.pyplot as plt + +args = [a for a in sys.argv[1:] if not a.startswith("--")] +opts = dict(zip(sys.argv[1:], sys.argv[2:])) +exe, out = args[0], args[1] +W, H = (int(v) for v in opts.get("--size", "960x540").split("x")) +FPS = int(opts.get("--fps", "60")) +os.makedirs(out, exist_ok=True) +for old in os.listdir(out): + if old.startswith(("sheet-", "change")) or old == "transitions.txt": + os.remove(os.path.join(out, old)) + +# A pixel has changed when any channel moved by more than this: above what +# antialiasing does to a still edge, below the faintest ember. +THRESHOLD = 10 +# A frame is moving when this share of it changed; transitions closer than +# GAP frames are one (a strike, then its cooling). +ACTIVE = 0.0002 +GAP = 4 + + +def frames(want=None): + """The scene's frames in order, as H x W x 3 arrays; with `want` (a set of indices), those alone.""" + env = dict(os.environ, CANIM_PANELS="1") + # The scene says where its panels are, a line a panel a frame: kept aside, read once. + log = open(os.path.join(out, "panels.log"), "w+") + p = subprocess.Popen([exe, "--state", os.path.join(out, "motion.state"), "--export", "-", "--size", f"{W}x{H}", "--fps", str(FPS)], + stdout=subprocess.PIPE, stderr=log, env=env) + size, i = W * H * 4, 0 + while True: + raw = p.stdout.read(size) + if len(raw) < size: + break + if want is None or i in want: + yield i, np.frombuffer(raw, np.uint8).reshape(H, W, 4)[:, :, :3] + i += 1 + p.wait() + log.seek(0) + frames.stderr = log.read() + log.close() + os.remove(os.path.join(out, "panels.log")) + + +# Pass one: what changes, frame by frame, in the whole picture and in each region. +regions = {"head": (0, 0, W, int(H * 112 / 1080)), "caption": (0, int(H * 896 / 1080), W, H)} +# The scene says where its panels are on frame 45, so each frame's change +# is kept small (a 96 x 54 map of where) and cut into lanes afterwards. +whole, maps, boxes, prev, n = [], [], [], None, 0 +for i, frame in frames(): + n = i + 1 + # Every second pixel each way is enough to see what moves, four times sooner. + now = frame[::2, ::2].copy() + changed = np.zeros(now.shape[:2], bool) if prev is None else ((np.maximum(now, prev) - np.minimum(now, prev)).max(axis=2) > THRESHOLD) + prev = now + whole.append(float(changed.mean())) + maps.append(changed.reshape(54, changed.shape[0] // 54, 96, changed.shape[1] // 96).mean(axis=(1, 3)).astype(np.float32)) + ys, xs = np.nonzero(changed) + boxes.append((2 * xs.min(), 2 * ys.min(), 2 * xs.max() + 2, 2 * ys.max() + 2) if len(xs) else None) +whole = np.array(whole) + +# Where each panel is when it first shows (before any camera move). +for line in frames.stderr.splitlines(): + if line.startswith("canim-panel "): + x0, y0, x1, y1, name = line.split(" ", 5)[1:] + if name not in regions: + regions[name] = (max(0, int(float(x0) * W)), max(0, int(float(y0) * H)), min(W, int(float(x1) * W)), min(H, int(float(y1) * H))) +lanes = {} +for name, (x0, y0, x1, y1) in regions.items(): + cx0, cy0, cx1, cy1 = x0 * 96 // W, y0 * 54 // H, max(x1 * 96 // W, x0 * 96 // W + 1), max(y1 * 54 // H, y0 * 54 // H + 1) + lanes[name] = np.array([m[cy0:cy1, cx0:cx1].mean() for m in maps]) + +# Transitions: runs of moving frames, bridged over short gaps. +moving = whole > ACTIVE +runs, i = [], 0 +while i < n: + if not moving[i]: + i += 1 + continue + j = i + while j + 1 < n and (moving[j + 1] or moving[j + 1:j + 1 + GAP].any()): + j += 1 + runs.append((i, j)) + i = j + 1 + +def order(a, b): + """The panels that move in frames a..b, each with the frame it starts at after a.""" + firsts = [] + for name, lane in lanes.items(): + hit = np.nonzero(lane[a:b + 1] > ACTIVE * 4)[0] + if len(hit): + firsts.append((int(hit[0]), name)) + return sorted(firsts) + +with open(os.path.join(out, "transitions.txt"), "w") as f: + f.write(f"{exe}: {n} frames, {n / FPS:.2f} s at {FPS} fps; {len(runs)} transitions\n") + f.write(" # start frames length peak hold after panels, in the order they start (frames after the first)\n") + for k, (a, b) in enumerate(runs): + hold = (runs[k + 1][0] if k + 1 < len(runs) else n) - b - 1 + who = " ".join(f"{name}+{d}" for d, name in order(a, b)) + f.write(f"{k:3d} {a / FPS:7.2f}s {a:5d}-{b:<5d} {(b - a + 1) / FPS:6.2f}s {whole[a:b + 1].max() * 100:5.1f}% {hold / FPS:6.2f}s {who}\n") + +# The plot: the whole frame, then a lane each. +names = list(regions) +def plot(path, a, b): + t = np.arange(a, b) / FPS + fig, axes = plt.subplots(2, 1, figsize=(min(20, max(8, (b - a) / FPS * 1.8)), 2.4 + 0.32 * len(names)), sharex=True, + gridspec_kw={"height_ratios": [2.2, 0.32 * len(names) + 0.4]}) + ax = axes[0] + ax.fill_between(t, np.maximum(whole[a:b] * 100, 0.005), 0.005, color="#ff6a4a", step="mid", linewidth=0) + ax.set_yscale("log"); ax.set_ylim(0.005, 100); ax.set_ylabel("% of frame changed") + for (s, e) in runs: + if e >= a and s < b: + ax.axvspan(s / FPS, (e + 1) / FPS, color="#e8c46a", alpha=0.18, linewidth=0) + ax.grid(True, which="major", axis="both", alpha=0.25) + grid = np.array([lanes[name][a:b] for name in names]) + axes[1].imshow(np.sqrt(grid), aspect="auto", cmap="magma", vmin=0, vmax=0.5, extent=(a / FPS, b / FPS, len(names), 0), interpolation="nearest") + axes[1].set_yticks(np.arange(len(names)) + 0.5); axes[1].set_yticklabels(names) + axes[1].set_xlabel("seconds") + fig.tight_layout(); fig.savefig(path, dpi=110); plt.close(fig) + +plot(os.path.join(out, "change.png"), 0, n) +for k, a in enumerate(range(0, n, 10 * FPS)): + plot(os.path.join(out, f"change-{k:02d}.png"), a, min(n, a + 10 * FPS)) + +# Contact sheets: six frames of each transition, cropped to where it happens. +TILE, COLS, ROWS = (320, 180), 6, 5 +picks = {} +for k, (a, b) in enumerate(runs): + # From two frames before to where it has settled, evenly. + span = np.linspace(max(a - 2, 0), min(b + 3, n - 1), COLS).round().astype(int) + picks[k] = list(span) +want = {int(i) for span in picks.values() for i in span} +kept = {i: frame.copy() for i, frame in frames(want)} + +def crop(a, b): + """The box the change of frames a..b happens in, grown to the tile's shape, at least a quarter of the frame.""" + found = [bx for bx in boxes[a:b + 1] if bx is not None] + if not found: + return (0, 0, W, H) + x0, y0 = min(bx[0] for bx in found), min(bx[1] for bx in found) + x1, y1 = max(bx[2] for bx in found), max(bx[3] for bx in found) + w = max(x1 - x0 + 40, W // 4, int((y1 - y0 + 40) * 16 / 9)) + w = min(W, w); h = min(H, int(w * 9 / 16)) + cx, cy = (x0 + x1) // 2, (y0 + y1) // 2 + left = min(max(cx - w // 2, 0), W - w); top = min(max(cy - h // 2, 0), H - h) + return (left, top, left + w, top + h) + +for s in range(0, len(runs), ROWS): + sheet = Image.new("RGB", (COLS * TILE[0], min(ROWS, len(runs) - s) * (TILE[1] + 22)), "#000000") + draw = ImageDraw.Draw(sheet) + for r, k in enumerate(range(s, min(s + ROWS, len(runs)))): + a, b = runs[k] + box = crop(a, b) + hold = (runs[k + 1][0] if k + 1 < len(runs) else n) - b - 1 + y = r * (TILE[1] + 22) + draw.text((6, y + 4), f"#{k} {a / FPS:.2f}s frames {a}-{b} {(b - a + 1) / FPS:.2f}s long, then still {hold / FPS:.2f}s " + " ".join(f"{name}+{d}" for d, name in order(a, b)), fill="#eee6d2") + for c, i in enumerate(picks[k]): + tile = Image.fromarray(kept[int(i)]).crop(box).resize(TILE, Image.LANCZOS) + sheet.paste(tile, (c * TILE[0], y + 22)) + draw.text((c * TILE[0] + 6, y + 26), f"{int(i)}", fill="#e8c46a") + sheet.save(os.path.join(out, f"sheet-{s // ROWS:02d}.png")) + +# The summary: the beat, and whether it is a metronome. +starts = np.array([a for a, _ in runs]) / FPS +lengths = np.array([b - a + 1 for a, b in runs]) / FPS +holds = np.array([(runs[k + 1][0] if k + 1 < len(runs) else n) - runs[k][1] - 1 for k in range(len(runs))]) / FPS +gaps = np.diff(starts) +print(f"{os.path.basename(exe)}: {n / FPS:.1f} s, {len(runs)} transitions; moving {moving.mean() * 100:.0f}% of the time") +if len(runs) > 2: + print(f" transitions last {np.median(lengths):.2f} s (median), {lengths.min():.2f} to {lengths.max():.2f}") + print(f" holds: median {np.median(holds):.2f} s, shortest {holds.min():.2f} s; {int((holds < 0.25).sum())} under 0.25 s") + same = np.abs(gaps[1:] - gaps[:-1]) < 0.02 + longest, cur = 0, 0 + for v in same: + cur = cur + 1 if v else 0 + longest = max(longest, cur) + print(f" beat: {len(set(np.round(gaps, 2)))} different intervals between starts; longest run of equal ones: {longest + 1}") +print(f" sheets and plots in {out}") +try: + os.remove(os.path.join(out, "motion.state")) +except OSError: + pass |
