@rig-c/pose 0.6.0 → 0.8.0

package/src/retarget.ts

@@ -41,7 +41,8 @@
  *
  * Then the switches (rig-c/pose#6, `switch.ts`): with every target known —
  * reaches included — each alternate set's distance to the pose is read, and the
- * spans each set shows are chosen. Only then the range clamp: outside the spans
+ * spans each set shows are chosen, each boundary keyed at its window's speed
+ * peak (#31). Only then the range clamp: outside the spans
  * of a set depicting its chain, a bone whose rotate key would leave its
  * `range` is clamped at the limit (its target becomes the clamped world angle),
  * in depth order, so a bone below takes the clamped parent into its own key

package/src/run.ts

@@ -154,7 +154,7 @@ export function runRetarget(a: RetargetArgs, log: (line: string) => void): RunRe
         animation: a.name,
         frames: seq.frames.length,
         duration: r.animation.duration,
-        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, profile: a.profile },
+        options: { minScore: a.minScore, smooth: a.smooth, flip: a.flip, short: a.short, bends: a.bends, bendTolerance: a.bendTolerance, switchTolerance: a.switchTolerance, switchMin: a.switchMin, switchAt: a.switchAt, profile: a.profile },
         scale: r.scale,
         holds: r.holds,
         short: r.short,

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

package/src/switch.ts

@@ -31,6 +31,26 @@
  * time lands below it (rig-c docs/AUTHORING.md §4.5), and the pose's times and
  * a renderer's `i / fps` are two grids that disagree by more than that.
  * Halfway, both see it on frame i.
+ *
+ * Where a switch is keyed (rig-c/pose#31): a boundary — a frame where a set
+ * starts showing, or where the base art or the next set comes back — is moved,
+ * after the selection above, to the fastest frame within ±`switchMin`/2 of it,
+ * so the change of drawing lands in motion, not on an arm slowing into the
+ * pose. The speed on a frame is the largest |angular speed|, degrees per frame
+ * (central difference of the target world angles; one-sided on the first and
+ * last frame), over the segments of the chains the boundary changes, the
+ * leaving set's and the arriving set's; read on the same targets as the
+ * distance, before the range clamp and any set's `turn`, which depend on where
+ * the spans are. The window is clipped so every span keeps `switchMin` (a gap
+ * between two spans of one set too, so the bridging holds), no boundary
+ * reaches its neighbour, and a set with `frames` shows only inside them; and
+ * a frame qualifies only if the set the move newly shows is within twice the
+ * tolerance of its key skeleton on every frame it newly shows it on (speed
+ * alone showed art up to 135° from its pose on the dancer). Ties
+ * go to the frame nearest the original, then the earlier. A boundary between
+ * two sets moves once. `switchAt: 'first'` keeps every boundary where the
+ * selection put it; it is the CLI's default, because on HQ's dancer the bounded
+ * peak still raised the sets' ART-RANGE runs from 24 to 31 (#31, round 2).
  */
 import type { AlternateSet, JointMap, Rest, RigSlots } from './map.ts';
 import { descends } from './map.ts';
@@ -43,6 +63,21 @@ export interface SwitchOptions {
   switchTolerance: number;
   /** Seconds: a run of one set shorter than this is dropped. */
   switchMin: number;
+  /** Where a boundary is keyed: 'first' (the CLI's default) keeps the frame the selection gave it; 'peak' moves it to the fastest qualifying frame of its window (#31). */
+  switchAt: 'peak' | 'first';
+}
+
+/** One boundary of a span: where the selection put it, where it is keyed, and how fast the chains it changes move on each. */
+export interface Move {
+  /** The frame the boundary showed on as selected, then as keyed. */
+  frame: [number, number];
+  /** Signed: frames, and the seconds between the two frames' times. */
+  frames: number;
+  seconds: number;
+  /** The frames it could move to, after clipping: first and last. */
+  window: [number, number];
+  /** Degrees per frame on the old and the new frame: the largest |angular speed| over the segments of the chains it changes. */
+  speed: { old: number; new: number };
 }
 
 export interface Switch {
@@ -63,6 +98,8 @@ export interface Switch {
   distance: { max: number; median: number };
   /** Per bone the set has a `drawn` angle for: |wrap(target − drawn)| over the frames shown, degrees. */
   artTurn: Record<string, { max: number; median: number }>;
+  /** The boundary it starts on (null from the first frame) and the one it ends on (null to the end); a boundary between two sets is in both. */
+  moved: { on: Move | null; off: Move | null };
 }
 
 export interface AttachmentKey {
@@ -169,6 +206,89 @@ function competing(sets: readonly AlternateSet[]): AlternateSet[][] {
   return [...groups.values()];
 }
 
+/**
+ * Per frame, the largest |angular speed| over the given bones' target world
+ * angles, degrees per frame: a central difference, one-sided on the first and
+ * the last frame.
+ */
+export function speeds(bones: readonly string[], targets: ReadonlyMap<string, readonly number[]>, n: number): number[] {
+  const out: number[] = [];
+  for (let k = 0; k < n; k++) {
+    const lo = Math.max(0, k - 1);
+    const hi = Math.min(n - 1, k + 1);
+    let v = 0;
+    if (hi > lo) for (const b of bones) v = Math.max(v, Math.abs(wrap(targets.get(b)![hi]! - targets.get(b)![lo]!)) / (hi - lo));
+    out.push(v);
+  }
+  return out;
+}
+
+/** A moved boundary may newly show a set only on frames within this many times the tolerance of its key skeleton (#31). */
+export const MOVE_BOUND = 2;
+
+/**
+ * Move each boundary of one group's segments to the fastest frame of its
+ * window (`switchAt: 'peak'`), in time order, each clipped against its
+ * neighbours as they stand; `vals[s]` is what segment s shows (null: the base
+ * art) and `pos[m]` the frame boundary m shows on, between segments m and m+1.
+ * A candidate frame qualifies only if every frame the move newly shows a set
+ * on is within `MOVE_BOUND` × the tolerance of it; none qualifying, the
+ * boundary stays. Returns one `Move` per boundary.
+ */
+function moveBoundaries(vals: ReadonlyArray<AlternateSet | null>, pos: readonly number[], map: JointMap, targets: ReadonlyMap<string, readonly number[]>, distances: ReadonlyMap<string, readonly number[]>, times: readonly number[], duration: number, opts: SwitchOptions): Move[] {
+  const n = times.length;
+  const at = [...pos];
+  const end = (b: number) => (b < n ? times[b]! : duration);
+  const len = (a: number, b: number) => end(b) - times[a]!;
+  /** What a segment must keep: the minimum span for a set's, and for a gap between two spans of one set (the bridging); never less than it had. */
+  const need = (s: number, had: number): number => {
+    const v = vals[s];
+    const kept = v !== null || (s > 0 && s + 1 < vals.length && vals[s - 1] !== null && vals[s - 1] === vals[s + 1]);
+    return kept ? Math.min(opts.switchMin, had) : 0;
+  };
+  const allowed = (a: AlternateSet | null, k: number) => a === null || a.frames === null || a.frames.some(([f, l]) => k >= f && k <= l);
+  const bonesOf = (a: AlternateSet | null): string[] => (a === null ? [] : a.chains.flatMap((cn) => map.chains.find((c) => c.name === cn)!.bones));
+  const moves: Move[] = [];
+  for (let m = 0; m < at.length; m++) {
+    const b = at[m]!;
+    const prev = m === 0 ? 0 : at[m - 1]!;
+    const next = m + 1 < at.length ? at[m + 1]! : n;
+    const leaving = vals[m] ?? null;
+    const arriving = vals[m + 1] ?? null;
+    const needPrev = need(m, len(prev, b));
+    const needNext = need(m + 1, len(b, next));
+    // The pose's times are read to the microsecond, so a frame exactly half a minimum span away may read a hair past it.
+    const half = opts.switchMin / 2 + 1e-6;
+    // Earlier: frames b' … b−1 show the arriving segment.
+    let lo = b;
+    while (lo - 1 > prev && times[b]! - times[lo - 1]! <= half && len(prev, lo - 1) >= needPrev - 1e-9 && allowed(arriving, lo - 1)) lo--;
+    // Later: frames b … b'−1 show the leaving one.
+    let hi = b;
+    while (hi + 1 < next && times[hi + 1]! - times[b]! <= half && len(hi + 1, next) >= needNext - 1e-9 && allowed(leaving, hi)) hi++;
+    const sp = speeds([...new Set([...bonesOf(leaving), ...bonesOf(arriving)])], targets, n);
+    // A frame qualifies only if the set it newly shows is within twice the tolerance of its key skeleton on every
+    // frame it newly shows it on (round 1 on the dancer: speed alone showed a set up to 135° from its pose).
+    const near = (a: AlternateSet | null, from: number, to: number): boolean => {
+      if (a === null) return true;
+      const d = distances.get(a.name)!;
+      for (let k = from; k < to; k++) if (d[k]! > MOVE_BOUND * opts.switchTolerance) return false;
+      return true;
+    };
+    const qualifies = (k: number) => (k < b ? near(arriving, k, b) : near(leaving, b, k));
+    let best = b;
+    if (opts.switchAt === 'peak') {
+      for (let k = lo; k <= hi; k++) {
+        if (!qualifies(k)) continue;
+        const d = sp[k]! - sp[best]!;
+        if (d > 1e-9 || (Math.abs(d) <= 1e-9 && (Math.abs(k - b) < Math.abs(best - b) || (Math.abs(k - b) === Math.abs(best - b) && k < best)))) best = k;
+      }
+    }
+    at[m] = best;
+    moves.push({ frame: [b, best], frames: best - b, seconds: r6(times[best]! - times[b]!), window: [lo, hi], speed: { old: r3(sp[b]!), new: r3(sp[best]!) } });
+  }
+  return moves;
+}
+
 /** The key time for a change that shows on frame i: half a frame before it, 0 on the first frame. */
 const changeAt = (times: readonly number[], i: number): number => (i === 0 ? 0 : r6((times[i - 1]! + times[i]!) / 2));
 
@@ -220,20 +340,34 @@ export function selectSwitches(map: JointMap, targets: ReadonlyMap<string, reado
       }
       i = j + 1;
     }
+    // A run shorter than the minimum span shows the base art.
     for (let i = 0; i < n;) {
       const a = pick[i];
       let j = i;
       while (j + 1 < n && pick[j + 1] === a) j++;
-      if (a !== null && a !== undefined) {
-        const from = times[i]!;
-        const to = j + 1 < n ? times[j + 1]! : duration;
-        if (to - from >= opts.switchMin - 1e-9) {
-          const ds = distances.get(a.name)!.slice(i, j + 1);
-          switches.push({ set: a.name, chains: a.chains, slots: a.slots, hides: a.hides, offsets: a.offsets, from, to, frames: [i, j], distance: { max: r3(Math.max(...ds)), median: r3(median(ds)) }, artTurn: {} });
-        }
-      }
+      const to = j + 1 < n ? times[j + 1]! : duration;
+      if (a !== null && a !== undefined && to - times[i]! < opts.switchMin - 1e-9) for (let k = i; k <= j; k++) pick[k] = null;
       i = j + 1;
     }
+    // The segments between boundaries, then each boundary moved (#31).
+    const vals: Array<AlternateSet | null> = [pick[0] ?? null];
+    const pos: number[] = [];
+    for (let i = 1; i < n; i++) {
+      if (pick[i] === pick[i - 1]) continue;
+      pos.push(i);
+      vals.push(pick[i] ?? null);
+    }
+    const moves = moveBoundaries(vals, pos, map, targets, distances, times, duration, opts);
+    for (let s = 0; s < vals.length; s++) {
+      const a = vals[s];
+      if (a === null || a === undefined) continue;
+      const i = s === 0 ? 0 : moves[s - 1]!.frame[1];
+      const j = s < pos.length ? moves[s]!.frame[1] - 1 : n - 1;
+      const from = times[i]!;
+      const to = j + 1 < n ? times[j + 1]! : duration;
+      const ds = distances.get(a.name)!.slice(i, j + 1);
+      switches.push({ set: a.name, chains: a.chains, slots: a.slots, hides: a.hides, offsets: a.offsets, from, to, frames: [i, j], distance: { max: r3(Math.max(...ds)), median: r3(median(ds)) }, artTurn: {}, moved: { on: s === 0 ? null : moves[s - 1]!, off: s < pos.length ? moves[s]! : null } });
+    }
   }
   const order = (name: string) => map.alternates.findIndex((a) => a.name === name);
   switches.sort((x, y) => x.frames[0] - y.frames[0] || order(x.set) - order(y.set));
@@ -433,9 +567,18 @@ export function switchLine(s: Switch, times: readonly number[]): string {
   if (offs.length > 0) parts.push(`offsets ${offs.map(([b, o]) => `"${b}" (${o[0]}, ${o[1]})`).join(', ')}`);
   const art = Object.entries(s.artTurn);
   if (art.length > 0) parts.push(`art turn ${art.map(([b, a]) => `"${b}" max ${deg(a.max)}, median ${deg(a.median)}`).join('; ')}`);
+  const moves = (['on', 'off'] as const).filter((k) => s.moved[k] !== null).map((k) => `${k} ${moveText(s.moved[k]!)}`);
+  if (moves.length > 0) parts.push(`moved ${moves.join(', ')}`);
   return parts.join('; ');
 }
 
+const spd = (v: number) => `${v.toFixed(1)}°/frame`;
+const win = (w: [number, number]) => (w[0] === w[1] ? `window frame ${w[0]}` : `window frames ${w[0]}–${w[1]}`);
+function moveText(m: Move): string {
+  if (m.frames === 0) return `frame ${m.frame[0]} stays (${spd(m.speed.old)}; ${win(m.window)})`;
+  return `frame ${m.frame[0]} → ${m.frame[1]} (${m.frames > 0 ? '+' : '−'}${Math.abs(m.frames)} frame${Math.abs(m.frames) === 1 ? '' : 's'}, ${m.seconds > 0 ? '+' : '−'}${Math.abs(m.seconds).toFixed(3)}s; ${spd(m.speed.old)} → ${spd(m.speed.new)}; ${win(m.window)})`;
+}
+
 export function artRangeLine(e: ArtRange, times: readonly number[]): string {
   return `set "${e.set}" chain "${e.chain}" bone "${e.bone}" turned ${sg(e.turn)} from drawn (range [${e.limits[0]}, ${e.limits[1]}]) ${spanOf(e.frames, times)}: ${e.seconds.toFixed(3)}s, up to ${deg(e.maxOverflow)} past it; ${e.clamped ? 'held at the limit' : 'the bone follows the pose'} — demand for another drawing of the set`;
 }