@rig-c/pose 0.7.0 → 0.8.1

package/src/pose.ts

@@ -50,6 +50,16 @@ export interface PoseSequence {
 
 const TOP_KEYS = ['spec', 'space', 'width', 'height', 'source', 'frames'];
 
+/**
+ * The older name the same file went by: `rig-c-pose-frames/0`, written by the
+ * extraction jobs this package's own demos were made from. It is this format
+ * under another spec string, with `space.units` "painting-px" and an `fps` key
+ * (the time is in each frame's `t`, which wins). It is read as it is; nothing
+ * else about it differs.
+ */
+export const POSE_SPEC_FRAMES0 = 'rig-c-pose-frames/0';
+const FRAMES0_SPACE = { units: 'painting-px', origin: 'top-left', y: 'down' } as const;
+
 /** Read and check a pose sequence; every problem is collected and thrown once. */
 export function readPoseSequence(text: string, where: string): PoseSequence {
   const doc = parseJson(text, where, 'POSE_JSON');
@@ -59,12 +69,15 @@ export function readPoseSequence(text: string, where: string): PoseSequence {
     p.throwIfAny();
     throw new Error('unreachable');
   }
-  refuseUnknownKeys(p, 'POSE_KEYS', where, doc, TOP_KEYS);
+  const frames0 = doc.spec === POSE_SPEC_FRAMES0;
+  refuseUnknownKeys(p, 'POSE_KEYS', where, doc, frames0 ? [...TOP_KEYS, 'fps'] : TOP_KEYS);
   for (const k of TOP_KEYS) if (!(k in doc)) p.add('POSE_KEYS', `${where} has no "${k}"; a ${POSE_SPEC} document carries ${TOP_KEYS.join(', ')}`);
-  if ('spec' in doc && doc.spec !== POSE_SPEC) p.add('POSE_SPEC', `${where} "spec" is ${typeName(doc.spec)}; this reader reads "${POSE_SPEC}"`);
-  if ('space' in doc && JSON.stringify(doc.space) !== JSON.stringify(POSE_SPACE)) {
-    p.add('POSE_SPACE', `${where} "space" is ${JSON.stringify(doc.space)}; it must be exactly ${JSON.stringify(POSE_SPACE)}`);
+  if ('spec' in doc && doc.spec !== POSE_SPEC && !frames0) p.add('POSE_SPEC', `${where} "spec" is ${typeName(doc.spec)}; this reader reads "${POSE_SPEC}" (and the older name "${POSE_SPEC_FRAMES0}")`);
+  const space = frames0 ? FRAMES0_SPACE : POSE_SPACE;
+  if ('space' in doc && JSON.stringify(doc.space) !== JSON.stringify(space)) {
+    p.add('POSE_SPACE', `${where} "space" is ${JSON.stringify(doc.space)}; for "${frames0 ? POSE_SPEC_FRAMES0 : POSE_SPEC}" it must be exactly ${JSON.stringify(space)}`);
   }
+  if (frames0 && 'fps' in doc && !(typeof doc.fps === 'number' && Number.isFinite(doc.fps) && doc.fps > 0)) p.add('POSE_FPS', `${where} "fps" is ${typeName(doc.fps)}; it must be a positive number (each frame's "t" is the time read)`);
   for (const k of ['width', 'height'] as const) {
     if (k in doc && !(Number.isInteger(doc[k]) && (doc[k] as number) > 0)) p.add('POSE_SIZE', `${where} "${k}" is ${typeName(doc[k])}; it must be a positive integer (picture pixels)`);
   }

package/src/rigc.ts

@@ -96,11 +96,11 @@ export interface Gate {
 }
 
 /** Build `rig` with `motion` under rigc's gate into `dir/build`; nothing is read from a red build. */
-export function gate(rig: string, motion: Record<string, unknown>, dir: string, profile: string): Gate {
+export function gate(rig: string, motion: Record<string, unknown>, dir: string, profile: string, images?: string): Gate {
   mkdirSync(dir, { recursive: true });
   const motionPath = join(dir, 'motion.json');
   writeFileSync(motionPath, `${JSON.stringify(motion, null, 2)}\n`);
-  return buildInto(rig, motionPath, join(dir, 'build'), profile, join(dir, 'build-report.json'));
+  return buildInto(rig, motionPath, join(dir, 'build'), profile, join(dir, 'build-report.json'), images);
 }
 
 /**
@@ -112,8 +112,8 @@ export function gate(rig: string, motion: Record<string, unknown>, dir: string,
  * never copied out, which would carry a path climbing from the scratch
  * directory to the filesystem root. --copy-images puts the pages beside it.
  */
-export function buildInto(rig: string, motionPath: string, out: string, profile: string, report?: string): Gate {
-  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', out, '--profile', profile, '--copy-images', ...(report === undefined ? [] : ['--report', report])]);
+export function buildInto(rig: string, motionPath: string, out: string, profile: string, report?: string, images?: string): Gate {
+  const run = runRigc(['build', '--rig', rig, '--motion', motionPath, '--out', out, '--profile', profile, '--copy-images', ...(images === undefined ? [] : ['--images', images]), ...(report === undefined ? [] : ['--report', report])]);
   const lines = run.out.split('\n');
   return {
     run,
@@ -196,3 +196,12 @@ export function folds(build: string, animation: string, dir: string, fps: number
     frames: setDir,
   };
 }
+
+/** rig-c's version and the entry its launcher picked (`rigc --version`), so a run names the compiler that gated it. */
+export function rigcVersion(): { version: string; entry: string } {
+  const r = runRigc(['--version']);
+  const lines = r.out.split('\n').map((l) => l.trim()).filter((l) => l !== '');
+  const version = lines.find((l) => /^\d+\.\d+\.\d+/.test(l)) ?? lines[0] ?? 'unknown';
+  const entry = lines.find((l) => l.startsWith('entry:'))?.slice('entry:'.length).trim() ?? 'not stated';
+  return { version, entry };
+}

package/src/run.ts

@@ -7,11 +7,11 @@
 import { cpSync, existsSync, mkdtempSync, readFileSync, rmSync, statSync, writeFileSync } from 'node:fs';
 import { tmpdir } from 'node:os';
 import { dirname, join, resolve } from 'node:path';
-import { readMap, resolveMap } from './map.ts';
+import { readMap, resolveMap, type JointMap } from './map.ts';
 import { convertCoco17, personTrack, readPoseSequence } from './pose.ts';
 import { lineOf, Problems, Refusal, type Problem } from './problems.ts';
 import { bendLine, endOnLine, flipLine, holdLine, rangeLine, retarget, shortLine, turnLine, type RetargetOptions } from './retarget.ts';
-import { attachmentBones, baseMotionOf, buildInto, folds, gate, readBuild, resolveRig, restOf, slotsOf } from './rigc.ts';
+import { attachmentBones, baseMotionOf, buildInto, rigcVersion, folds, gate, readBuild, resolveRig, restOf, slotsOf } from './rigc.ts';
 import { artRangeLine, chainsMoving, switchLine, uncoveredFolds } from './switch.ts';
 import { landed, measureLanding, measurePosture, poseFrames, postureLines, ANGLE_TOLERANCE, ORIGIN_TOLERANCE } from './verify.ts';
 
@@ -24,6 +24,8 @@ export interface RetargetArgs extends RetargetOptions {
   coco: boolean;
   person?: string;
   baseMotion?: string;
+  /** Passed to rigc build as --images: the directory the rig spec's images resolve in, when rig.json's own `images` does not point there (a copied rig). */
+  images?: string;
   profile: 'spine' | 'spine-html';
   /** Keep the gated build here. */
   build?: string;
@@ -72,17 +74,19 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
   const scratch = mkdtempSync(join(tmpdir(), 'rig-pose-'));
   try {
     // The rig as it stands, through the gate, so the rest pose is rig-c's reading of a green build.
-    const g0 = gate(input.rig, base, join(scratch, 'base'), a.profile);
+    const g0 = gate(input.rig, base, join(scratch, 'base'), a.profile, a.images);
     if (!g0.green) {
       refuse([{ code: 'RIG_GATE_BASE', text: `${input.rig} with ${input.motion ?? 'no motion spec'} is red under rigc build --profile ${a.profile} before any animation is added (exit ${g0.run.status})` }, ...g0.fails.map((f) => ({ code: 'RIGC', text: f }))]);
     }
     const doc0 = readBuild(g0.build);
+    const rigc = rigcVersion();
     const rest = restOf(doc0);
     const slots = slotsOf(doc0);
     resolveMap(map, rest, a.map, slots);
 
     const r = retarget(rest, map, frames, times, a, slots);
     say(`rig-pose retarget: ${seq.frames.length} frame(s), ${r.animation.duration.toFixed(3)}s, onto "${input.name}" as "${a.name}" — ${r.animation.tracks.length} track(s); min-score ${a.minScore}, smooth ${a.smooth}, flip ${a.flip === 'off' ? 'off' : `${a.flip}°`}, short ${a.short}, bends ${a.bends} (tolerance ${a.bendTolerance}°)`);
+    say(`  RIGC   rig-c ${rigc.version} (${rigc.entry}) gates and poses this run`);
     if (r.scale !== null) say(`  SCALE  ${r.scale.factor.toFixed(5)} rig units per picture px (rig ${r.scale.rig.toFixed(2)} / pose median ${r.scale.pose.toFixed(2)})`);
     for (const h of r.holds) say(`  HOLD   ${holdLine(h, r.times)}`);
     if (a.short !== 'off') {
@@ -96,12 +100,13 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (map.alternates.length > 0) {
       if (r.switches.length === 0) say(`  SWITCH none — no set within ${a.switchTolerance}° of the pose for ${a.switchMin}s`);
       for (const s of r.switches) say(`  SWITCH ${switchLine(s, r.times)}`);
+      for (const l of windowLines(map, r.switches, r.distances, r.times, a.switchTolerance)) say(`  FRAMES ${l}`);
     }
     for (const e of r.range) say(`  RANGE  ${rangeLine(e, r.times)}`);
     for (const e of r.artRange) say(`  ART-RANGE ${artRangeLine(e, r.times)}`);
 
     const motion = { ...base, animations: { ...animations, [a.name]: r.animation } };
-    const g1 = gate(input.rig, motion, join(scratch, 'with'), a.profile);
+    const g1 = gate(input.rig, motion, join(scratch, 'with'), a.profile, a.images);
     if (!g1.green) {
       refuse([{ code: 'RIG_GATE', text: `rigc build --profile ${a.profile} is red with "${a.name}" in (exit ${g1.run.status}); nothing written` }, ...g1.fails.map((f) => ({ code: 'RIGC', text: f }))]);
     }
@@ -139,7 +144,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (a.build !== undefined) {
       // Built again where it will live, not copied: rigc's page paths are relative to the build (#18).
       rmSync(a.build, { recursive: true, force: true });
-      const kept = buildInto(input.rig, join(scratch, 'with', 'motion.json'), resolve(a.build), a.profile);
+      const kept = buildInto(input.rig, join(scratch, 'with', 'motion.json'), resolve(a.build), a.profile, undefined, a.images);
       if (!kept.green) refuse([{ code: 'RIG_GATE', text: `rigc build into --build ${a.build} is red where the same build was green in scratch (exit ${kept.run.status}); nothing written` }, ...kept.fails.map((x) => ({ code: 'RIGC', text: x }))]);
     }
     writeFileSync(a.out, `${JSON.stringify(motion, null, 2)}\n`);
@@ -150,6 +155,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
     if (a.report !== undefined) {
       writeFileSync(a.report, `${JSON.stringify({
         spec: 'rig-pose-report/1',
+        rigc,
         rig: input.name,
         animation: a.name,
         frames: seq.frames.length,
@@ -195,3 +201,37 @@ function spans(ts: number[], step: number): string {
 }
 
 export { lineOf };
+
+/**
+ * For each set with `frames` windows: every stretch of a window the set did not
+ * show on, and why — the pose there was past the tolerance (with the largest
+ * distance), or within it but the run was dropped (shorter than --switch-min, or
+ * taken by another set's span). A window never forces a set; this says so.
+ */
+function windowLines(map: JointMap, switches: ReadonlyArray<{ set: string; frames: [number, number] }>, distances: ReadonlyMap<string, readonly number[]>, times: readonly number[], tolerance: number): string[] {
+  const out: string[] = [];
+  for (const set of map.alternates) {
+    if (set.frames === null) continue;
+    const shown = new Set<number>();
+    for (const sw of switches) if (sw.set === set.name) for (let i = sw.frames[0]; i <= sw.frames[1]; i++) shown.add(i);
+    const d = distances.get(set.name)!;
+    for (const [first, last] of set.frames) {
+      const lastIn = Math.min(last, times.length - 1);
+      const parts: string[] = [];
+      for (let i = first; i <= lastIn;) {
+        if (shown.has(i)) { i++; continue; }
+        let j = i;
+        while (j + 1 <= lastIn && !shown.has(j + 1)) j++;
+        const ds = d.slice(i, j + 1);
+        const worst = Math.max(...ds);
+        const over = ds.filter((x) => x > tolerance).length;
+        const span = i === j ? `frame ${i}` : `frames ${i}–${j}`;
+        parts.push(over === ds.length ? `${span} outside the tolerance (up to ${worst.toFixed(1)}° > ${tolerance}°)` : over === 0 ? `${span} within the tolerance but not shown (a run shorter than --switch-min, or another set's span)` : `${span} partly outside the tolerance (up to ${worst.toFixed(1)}°)`);
+        i = j + 1;
+      }
+      const head = `set "${set.name}" window ${first}–${last}`;
+      out.push(parts.length === 0 ? `${head}: shown on every frame` : `${head}: ${parts.join('; ')} — a window restricts a set, it never forces one`);
+    }
+  }
+  return out;
+}

package/src/runcompare.ts

@@ -0,0 +1,119 @@
+/**
+ * `rig-pose compare`, end to end: read the two sequences, the map and the
+ * optional inputs, compare (`compare.ts`), print a summary line per unit and a
+ * line per finding, and write the report and the sheet when asked. A finding is
+ * not a failure: the run exits 0 whenever it compared.
+ */
+import { existsSync, readFileSync, statSync, writeFileSync } from 'node:fs';
+import { dirname } from 'node:path';
+import { compare, findingLine, readCloth, readHands, readSpans, summaryLine, writeComparison, type ClothWindow, type CompareInput, type Comparison } from './compare.ts';
+import { readMap } from './map.ts';
+import { personTrack, readPoseSequence, type PoseSequence } from './pose.ts';
+import { Problems, Refusal } from './problems.ts';
+import { drawable, drawSheet } from './sheet.ts';
+
+export interface CompareArgs {
+  reference: string;
+  render: string;
+  map: string;
+  retargetReport?: string;
+  referenceHands?: string;
+  renderHands?: string;
+  clothReference?: string;
+  clothRender?: string;
+  clothWindows?: ClothWindow[];
+  report?: string;
+  sheet?: string;
+}
+
+export function runCompare(a: CompareArgs, log: (line: string) => void): Comparison {
+  const p = new Problems();
+  const inputs: Array<[string, string | undefined]> = [
+    ['--reference', a.reference], ['--render', a.render], ['--map', a.map], ['--retarget-report', a.retargetReport],
+    ['--reference-hands', a.referenceHands], ['--render-hands', a.renderHands], ['--cloth-reference', a.clothReference], ['--cloth-render', a.clothRender],
+  ];
+  for (const [flag, path] of inputs) {
+    if (path === undefined) continue;
+    if (!existsSync(path)) p.add('ARG_PATH', `${flag} ${path} does not exist`);
+    else if (!statSync(path).isFile()) p.add('ARG_PATH', `${flag} ${path} is not a file`);
+  }
+  for (const [flag, path] of [['--report', a.report], ['--sheet', a.sheet]] as const) {
+    if (path === undefined) continue;
+    const dir = dirname(path);
+    if (!existsSync(dir)) p.add('ARG_PATH', `${flag} ${path} — directory ${dir} does not exist`);
+    else if (!statSync(dir).isDirectory()) p.add('ARG_PATH', `${flag} ${path} — ${dir} is not a directory`);
+  }
+  p.throwIfAny();
+
+  // Every reader runs, and every refusal is reported together.
+  const all: Refusal[] = [];
+  const read = <T>(f: () => T): T | null => {
+    try {
+      return f();
+    } catch (e) {
+      if (e instanceof Refusal) {
+        all.push(e);
+        return null;
+      }
+      throw e;
+    }
+  };
+  const seqOf = (path: string) => read(() => {
+    const seq = readPoseSequence(readFileSync(path, 'utf8'), path);
+    return { seq, frames: personTrack(seq, undefined, path) };
+  });
+  const ref = seqOf(a.reference);
+  const ren = seqOf(a.render);
+  const map = read(() => readMap(readFileSync(a.map, 'utf8'), a.map));
+  const report = a.retargetReport === undefined ? null : read(() => readSpans(readFileSync(a.retargetReport!, 'utf8'), a.retargetReport!));
+  const handsA = a.referenceHands === undefined ? null : read(() => readHands(readFileSync(a.referenceHands!, 'utf8'), a.referenceHands!));
+  const handsB = a.renderHands === undefined ? null : read(() => readHands(readFileSync(a.renderHands!, 'utf8'), a.renderHands!));
+  const clothA = a.clothReference === undefined ? null : read(() => readCloth(readFileSync(a.clothReference!, 'utf8'), a.clothReference!));
+  const clothB = a.clothRender === undefined ? null : read(() => readCloth(readFileSync(a.clothRender!, 'utf8'), a.clothRender!));
+  if (all.length > 0) throw new Refusal(all.flatMap((e) => e.problems));
+  if (report !== null && report.frames !== ref!.seq.frames.length) {
+    throw new Refusal([{ code: 'COMPARE_REPORT', text: `${a.retargetReport} is a retarget over ${report.frames} frame(s); the reference ${a.reference} has ${ref!.seq.frames.length} — it is the report of another run` }]);
+  }
+
+  const side = (path: string, s: { seq: PoseSequence; frames: CompareInput['reference']['frames'] }) => ({ where: path, times: s.seq.frames.map((f) => f.t), frames: s.frames });
+  const input: CompareInput = {
+    reference: side(a.reference, ref!),
+    render: side(a.render, ren!),
+    map: map!,
+    spans: report === null ? null : report.spans,
+    retargetScale: report === null ? null : report.scale,
+    hands: handsA !== null && handsB !== null ? { reference: handsA, render: handsB } : null,
+    cloth: clothA !== null && clothB !== null ? { reference: clothA, render: clothB, windows: a.clothWindows ?? [] } : null,
+  };
+  const c = compare(input);
+
+  log(`rig-pose compare: ${c.frames} frame(s), ${c.duration.toFixed(3)}s — reference ${a.reference}, render ${a.render}; median hip width ${px(c.hipWidth.reference)} and ${px(c.hipWidth.render)}${a.retargetReport === undefined ? '' : `; spans from ${a.retargetReport}`}`);
+  for (const u of c.units) log(`  ${u.unit.toUpperCase().padEnd(6)} ${summaryLine(u, c.times)}`);
+  for (const f of c.findings) log(`  FIND   ${findingLine(f, c.times)}`);
+  if (c.cloth !== null) {
+    for (const w of c.cloth.windows) {
+      const fig = (x: { lag: number; swingRatio: number | null; overshoot: number | null; strokes: number }) => `lag ${x.lag.toFixed(3)}, swing ${x.swingRatio === null ? '—' : x.swingRatio.toFixed(3)}, overshoot ${x.overshoot === null ? '—' : x.overshoot.toFixed(3)} (${x.strokes} strokes)`;
+      log(`  CLOTH  window ${w.name} ${w.t[0]}–${w.t[1]}s (frames ${w.frames[0]}–${w.frames[1]}): reference ${fig(w.reference)}; render ${fig(w.render)}; strokes from ${c.cloth.stroke.reference} and ${c.cloth.stroke.render.toFixed(4)} hip widths (reference, render)`);
+    }
+    if (c.cloth.windows.length > 0) log(`  CLOTH  the render's stroke threshold ${c.cloth.stroke.render.toFixed(4)} of its hip widths = ${c.cloth.stroke.carried}`);
+  }
+  if (a.report !== undefined) {
+    writeFileSync(a.report, writeComparison(c, {
+      reference: a.reference, render: a.render, map: a.map, retargetReport: a.retargetReport ?? null,
+      referenceHands: a.referenceHands ?? null, renderHands: a.renderHands ?? null, clothReference: a.clothReference ?? null, clothRender: a.clothRender ?? null,
+    }));
+    log(`  wrote ${a.report}`);
+  }
+  if (a.sheet !== undefined) {
+    const plate = drawSheet({ frames: ref!.frames, width: ref!.seq.width, height: ref!.seq.height }, { frames: ren!.frames, width: ren!.seq.width, height: ren!.seq.height }, c.findings);
+    if (plate === null) log(`  SHEET  no finding has a frame to draw (${c.findings.length} finding(s), none outside cloth); ${a.sheet} not written`);
+    else {
+      plate.writePng(a.sheet);
+      log(`  SHEET  ${drawable(c.findings).length} finding(s), reference | render at each worst frame: wrote ${a.sheet}`);
+    }
+  }
+  log(`  ${c.findings.length} finding(s)`);
+  return c;
+}
+
+const px = (v: number | null) => (v === null ? 'none' : `${v.toFixed(1)}px`);

package/src/sheet.ts

@@ -0,0 +1,106 @@
+/**
+ * The comparison's sheet (rig-c/pose#38): for each finding, the reference
+ * skeleton beside the render skeleton at its worst frame, one row per finding,
+ * worst first within each unit. Skeletons only — no video frame is ever drawn.
+ * The finding's own points are drawn over the limbs in yellow.
+ *
+ * A cloth finding is a figure over a window with no single frame, so it has no
+ * row. Pure: it returns the plate; the caller writes it.
+ */
+import { textWidth } from 'rig-c/font5x7';
+import { Plate, type RGBA } from 'rig-c/plate';
+import type { Body18 } from './joints.ts';
+import { positionOf, type Finding, type Frames } from './compare.ts';
+
+const RIGHT: RGBA = [214, 69, 65, 255];
+const LEFT: RGBA = [52, 120, 214, 255];
+const MID: RGBA = [120, 120, 120, 255];
+const MARK: RGBA = [236, 180, 20, 255];
+const PANE: RGBA = [232, 232, 232, 255];
+const PAPER: RGBA = [255, 255, 255, 255];
+const INK: RGBA = [30, 30, 30, 255];
+
+const LIMBS: Array<[Body18, Body18, RGBA]> = [
+  ['r_shoulder', 'r_elbow', RIGHT], ['r_elbow', 'r_wrist', RIGHT],
+  ['r_hip', 'r_knee', RIGHT], ['r_knee', 'r_ankle', RIGHT],
+  ['l_shoulder', 'l_elbow', LEFT], ['l_elbow', 'l_wrist', LEFT],
+  ['l_hip', 'l_knee', LEFT], ['l_knee', 'l_ankle', LEFT],
+  ['r_shoulder', 'l_shoulder', MID], ['r_hip', 'l_hip', MID],
+  ['r_shoulder', 'r_hip', RIGHT], ['l_shoulder', 'l_hip', LEFT],
+  ['neck', 'nose', MID], ['nose', 'r_eye', RIGHT], ['nose', 'l_eye', LEFT],
+  ['r_eye', 'r_ear', RIGHT], ['l_eye', 'l_ear', LEFT],
+];
+
+export interface SheetSide {
+  frames: Frames;
+  width: number;
+  height: number;
+}
+
+/** The pane height in px; each pane keeps its picture's aspect. */
+export const SHEET_PANE = 320;
+const LABEL = 28;
+const GAP = 8;
+
+/** The findings a sheet draws: every one with a frame (not cloth). */
+export function drawable(findings: readonly Finding[]): Finding[] {
+  return findings.filter((f) => f.unit !== 'cloth');
+}
+
+/** The sheet as a plate, or null when no finding has a frame to draw. */
+export function drawSheet(reference: SheetSide, render: SheetSide, findings: readonly Finding[]): Plate | null {
+  const rows = drawable(findings);
+  if (rows.length === 0) return null;
+  const wa = Math.round((reference.width * SHEET_PANE) / reference.height);
+  const wb = Math.round((render.width * SHEET_PANE) / render.height);
+  const width = Math.max(wa + GAP + wb, 480) + 2 * GAP;
+  const rowH = LABEL + SHEET_PANE + GAP;
+  const plate = new Plate(width, GAP + rows.length * rowH);
+  plate.rect(0, 0, plate.width, plate.height, PAPER);
+  rows.forEach((f, k) => {
+    const y = GAP + k * rowH;
+    const title = label(`${k + 1} ${f.unit} ${f.measure} ${f.subject} frame ${f.worst.frame} t=${f.worst.t.toFixed(3)}`);
+    plate.text(title, GAP, y, textWidth(title, 2) <= width - 2 * GAP ? 2 : 1, INK);
+    plate.text('reference', GAP, y + 16, 1, INK);
+    plate.text('render', GAP + wa + GAP, y + 16, 1, INK);
+    pane(plate, reference, f, GAP, y + LABEL, wa);
+    pane(plate, render, f, GAP + wa + GAP, y + LABEL, wb);
+  });
+  return plate;
+}
+
+function pane(plate: Plate, side: SheetSide, f: Finding, x0: number, y0: number, w: number): void {
+  plate.rect(x0, y0, w, SHEET_PANE, PANE);
+  const k = SHEET_PANE / side.height;
+  const joints = side.frames[f.worst.frame] ?? {};
+  const at = (n: string): [number, number] | null => {
+    const p = positionOf(joints, n);
+    if (p === null) return null;
+    const x = x0 + p[0] * k;
+    const y = y0 + p[1] * k;
+    // A point outside the picture is not drawn outside its pane.
+    return x < x0 || x >= x0 + w || y < y0 || y >= y0 + SHEET_PANE ? null : [x, y];
+  };
+  const t = 3;
+  for (const [a, b, colour] of LIMBS) {
+    const pa = at(a);
+    const pb = at(b);
+    if (pa !== null && pb !== null) plate.line(pa[0], pa[1], pb[0], pb[1], t, colour);
+  }
+  // A hand's points are not body-18: its wrist is marked.
+  const marks = f.measure === 'visibility' ? [f.subject === 'hand_r' ? 'r_wrist' : 'l_wrist'] : f.points;
+  for (let i = 0; i + 1 < marks.length; i++) {
+    const pa = at(marks[i]!);
+    const pb = at(marks[i + 1]!);
+    if (pa !== null && pb !== null) plate.line(pa[0], pa[1], pb[0], pb[1], t + 2, MARK);
+  }
+  for (const q of marks) {
+    const pq = at(q);
+    if (pq !== null) plate.disc(pq[0], pq[1], t * 2, MARK);
+  }
+}
+
+/** The 5×7 font has capitals, digits and a little punctuation; anything else becomes a space. */
+function label(s: string): string {
+  return s.toUpperCase().replace(/[^A-Z0-9 _\-.,:/()!+=<>]/g, ' ');
+}