@rig-c/pose 0.7.0 → 0.8.0

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, ' ');
+}