rig-c 2.22.0 → 2.23.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "rig-c",
-  "version": "2.22.0",
+  "version": "2.23.0",
   "description": "AI-authored Spine 2D rigging and animation, verified before it is written. rigc compiles a rig spec into Spine 4.3 skeleton data, gates it with named assertions held to a spine-core round trip's verdicts, and emits nothing that fails. Output imports into the Spine editor. Ships as an agent skill.",
   "type": "module",
   "bin": {

package/src/mesh.ts

@@ -1253,8 +1253,9 @@ export function traceAlphaOutline(
  * `background` is how the flood steps: 4 through edges, 8 through corners too.
  * The trace floods 8 — the dual of its 4-connected island, so background that
  * meets the outside at a corner is outside — and says why where it calls this.
- * The authored-mesh measurement floods 4, as it always has; the two agree on
- * every mask the trace accepts.
+ * The authored-mesh measurement floods 4 by default, as it always has, and 8
+ * when its caller asks (issue #1262); the two agree on every mask the trace
+ * accepts.
  */
 export function fillEnclosed(
   inside: Uint8Array,
@@ -1479,16 +1480,57 @@ export interface MeshFitReport {
  * is never refused, so every figure needs a number — hence the exact distance
  * transform below rather than a neighbourhood search that would have to stop
  * somewhere.
+ *
+ * ## Which background is enclosed — `connectivity` (issue #1262)
+ *
+ * The background is flooded 4-connected by default, as it always has been, so
+ * every call that passes four arguments reads exactly what it read before.
+ * `8` floods through corners too — the fill `measureMeshQuality`'s
+ * `MQ_OVERSHOOT` and `MQ_HOLES` rows are taken against (P12), by the same
+ * `fillEnclosed` call — so a background pocket joined to the outside only
+ * diagonally is read as outside, and a caller gating with this figure reads
+ * the number the rows read. The two fills agree on every mask without such a
+ * pocket. Any other value is refused by name: a silent fallback to one of the
+ * two would answer a question the caller did not ask.
  */
 export function measureAuthoredMeshFit(
   mask: AlphaMask,
   threshold: number,
   points: Array<[number, number]>,
   triangles: number[],
+  connectivity: 4 | 8 = 4,
 ): MeshFitReport {
+  return authoredMeshFitOf(mask, threshold, points, triangles, connectivity, null).report;
+}
+
+/**
+ * A fault planted on purpose in `authoredMeshFitOf`, for the mesh-quality
+ * suite's negative control: `'fill-4-under-8'` takes the connectivity it is
+ * passed and floods 4 whatever it was. `measureAuthoredMeshFit` plants none.
+ */
+export type AuthoredFitPlant = 'fill-4-under-8';
+
+/**
+ * `measureAuthoredMeshFit`'s measurement, with the pixel its overshoot is
+ * read at — the first covered pixel outside the filled silhouette at the
+ * largest distance, by the tie rule `MQ_OVERSHOOT` names its pixel with, or
+ * -1 when no covered pixel lies outside — so a control can name where two
+ * readings part.
+ */
+export function authoredMeshFitOf(
+  mask: AlphaMask,
+  threshold: number,
+  points: Array<[number, number]>,
+  triangles: number[],
+  connectivity: 4 | 8,
+  plant: AuthoredFitPlant | null,
+): { report: MeshFitReport; overshootAt: number } {
+  if (connectivity !== 4 && connectivity !== 8) {
+    throw new MeshError(`measureAuthoredMeshFit: connectivity is ${JSON.stringify(connectivity)}; required 4 (the default, the legacy fill) or 8 (the fill MQ_OVERSHOOT reads, P12)`);
+  }
   const { width: w, height: h } = mask;
   const art = artOf(mask, threshold);
-  const { filled } = fillEnclosed(art, w, h, 4);
+  const { filled } = fillEnclosed(art, w, h, plant === 'fill-4-under-8' ? 4 : connectivity);
   const covered = rasteriseTriangles(points, triangles, w, h);
   let artPixels = 0;
   let coveredArt = 0;
@@ -1499,15 +1541,22 @@ export function measureAuthoredMeshFit(
   }
   const squared = squaredDistanceToSet(filled, w, h);
   let worst = 0;
+  let overshootAt = -1;
   for (let i = 0; i < covered.length; i++) {
     if (!covered[i] || filled[i]) continue;
-    if (squared[i] > worst) worst = squared[i];
+    if (overshootAt === -1 || squared[i] > worst) {
+      overshootAt = i;
+      worst = squared[i];
+    }
   }
   return {
-    artPixels,
-    coveredArt,
-    coverage: artPixels === 0 ? 0 : coveredArt / artPixels,
-    overshoot: r6(Math.sqrt(worst)),
+    report: {
+      artPixels,
+      coveredArt,
+      coverage: artPixels === 0 ? 0 : coveredArt / artPixels,
+      overshoot: r6(Math.sqrt(worst)),
+    },
+    overshootAt,
   };
 }
 

package/src/meshquality.ts

@@ -32,7 +32,8 @@
  *   taken at (`MeasureRow.art.threshold`); a measurement claims nothing at any
  *   other.
  * - **Change the legacy fit.** `measureAuthoredMeshFit` (`src/mesh.ts`) keeps
- *   its 4-connected fill for every existing caller. The rows here fill with the
+ *   its 4-connected fill for every existing caller (its `connectivity: 8`,
+ *   issue #1262, is the fill the rows read). The rows here fill with the
  *   tracer's 8-connected background flood over all art (P12), and where the two
  *   fills differ — a diagonal pinch — both labelled results are rows.
  * - **Pose, or link the runtime.** Pure: no clock, no randomness, no network,
@@ -694,8 +695,21 @@ function validateInput(input: MeshMeasureInput): void {
 
 type Pt = readonly [number, number];
 
-/** Is `p` inside or on the closed polygon? On the boundary within `ON_BOUNDARY` counts as inside. */
-function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
+/**
+ * Is `p` inside or on the closed polygon? On the boundary within `ON_BOUNDARY` counts as inside.
+ *
+ * The rule, exactly, because `closedPolygonCentres` reproduces it bit for bit:
+ * `p` is in when its `distanceToSegment` to some side `poly[i]`–`poly[i+1]`
+ * is at most `ON_BOUNDARY` (1e-9 px) — a point on an edge or at a vertex is in,
+ * whatever the ray says; otherwise by **even-odd** parity of a ray towards +x,
+ * where the side from `poly[j]` to `poly[i]` (`j` the one before `i`) crosses
+ * when exactly one of its ends has a y strictly greater than `p`'s — `yi > py`
+ * differs from `yj > py`, so the half-open rule counts a vertex at `p`'s height
+ * once and a horizontal side never — at
+ * `xc = ((xj − xi)·(py − yi)) / (yj − yi) + xi`, and the crossing counts when
+ * `px < xc` strictly.
+ */
+export function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
   const n = poly.length;
   for (let i = 0; i < n; i++) if (distanceToSegment(p, poly[i], poly[(i + 1) % n]) <= ON_BOUNDARY) return true;
   let inside = false;
@@ -707,6 +721,112 @@ function inClosedPolygon(p: Pt, poly: readonly Pt[]): boolean {
   return inside;
 }
 
+/**
+ * A fault planted on purpose in `closedPolygonCentres`, for the mesh-quality
+ * suite's negative control: `'crossing-half-pixel'` moves every ray crossing
+ * half a pixel towards +x. `regionRows` plants none.
+ */
+export type ScanlinePlant = 'crossing-half-pixel';
+
+/**
+ * Which pixel centres of a `w`×`h` grid lie in or on a closed polygon given
+ * in drawing px — `inClosedPolygon` of every centre `((x + 0.5) / scale,
+ * (y + 0.5) / scale)`, 1 where it is true, by scanline (issue #1263).
+ *
+ * The same decision, not a cleaner one: each row's crossings are the sides
+ * `inClosedPolygon` counts for that row's centre height, by its own
+ * half-open test, at the `xc` it computes with the same expression in the same
+ * order, so they are the same doubles; sorted, the number of them a centre
+ * lies strictly left of is the number its ray counts, and its parity is the
+ * answer. The boundary band is then added side by side, each centre near a
+ * side tested with `distanceToSegment` against `ON_BOUNDARY` — the predicate's
+ * own test — so a centre on an edge or at a vertex is in exactly when the
+ * predicate says so. The rows and columns visited around a side are widened by
+ * a pixel past where it can reach, and only the exact tests decide.
+ *
+ * O(rows × sides + pixels) where testing every centre against every side is
+ * O(pixels × sides).
+ */
+export function closedPolygonCentres(poly: readonly Pt[], w: number, h: number, scale: number, plant: ScanlinePlant | null = null): Uint8Array {
+  const marks = new Uint8Array(w * h);
+  const n = poly.length;
+  if (n === 0 || w <= 0 || h <= 0) return marks;
+  const cx = (x: number): number => (x + 0.5) / scale;
+  const cy = (y: number): number => (y + 0.5) / scale;
+  const shift = plant === 'crossing-half-pixel' ? 0.5 / scale : 0;
+  /** The grid row or column of a drawing coordinate, rounded one way and widened by `slack`; NaN visits nothing. */
+  const cellOf = (v: number, round: (u: number) => number, slack: number, size: number): number => {
+    const c = round(v * scale - 0.5) + slack;
+    if (Number.isNaN(c)) return slack < 0 ? size : -1;
+    return c;
+  };
+
+  // Even-odd: per row, the crossings of a ray towards +x from the row's centre height.
+  const crossings: Array<number[] | undefined> = new Array<number[] | undefined>(h);
+  for (let i = 0, j = n - 1; i < n; j = i++) {
+    const [xi, yi] = poly[i];
+    const [xj, yj] = poly[j];
+    const y0 = Math.max(0, cellOf(Math.min(yi, yj), Math.floor, -1, h));
+    const y1 = Math.min(h - 1, cellOf(Math.max(yi, yj), Math.ceil, 1, h));
+    for (let y = y0; y <= y1; y++) {
+      const py = cy(y);
+      if (yi > py !== yj > py) {
+        let row = crossings[y];
+        if (row === undefined) {
+          row = [];
+          crossings[y] = row;
+        }
+        row.push(((xj - xi) * (py - yi)) / (yj - yi) + xi + shift);
+      }
+    }
+  }
+  for (let y = 0; y < h; y++) {
+    const row = crossings[y];
+    if (row === undefined) continue;
+    row.sort((a, b) => a - b);
+    const x0 = Math.max(0, cellOf(row[0], Math.floor, -1, w));
+    const x1 = Math.min(w - 1, cellOf(row[row.length - 1], Math.ceil, 1, w));
+    let left = 0;
+    for (let x = x0; x <= x1; x++) {
+      const px = cx(x);
+      while (left < row.length && !(px < row[left])) left++;
+      if ((row.length - left) & 1) marks[y * w + x] = 1;
+    }
+  }
+
+  // On the boundary: within ON_BOUNDARY of a side. Per side, the rows its ends span and, per row, the columns
+  // the side passes within a pixel of that row's centre height, each widened by a pixel; the exact test decides.
+  const unit = 1 / scale;
+  for (let i = 0; i < n; i++) {
+    const a = poly[i];
+    const b = poly[(i + 1) % n];
+    const y0 = Math.max(0, cellOf(Math.min(a[1], b[1]), Math.floor, -1, h));
+    const y1 = Math.min(h - 1, cellOf(Math.max(a[1], b[1]), Math.ceil, 1, h));
+    const dy = b[1] - a[1];
+    for (let y = y0; y <= y1; y++) {
+      let lo = Math.min(a[0], b[0]);
+      let hi = Math.max(a[0], b[0]);
+      if (dy !== 0) {
+        const py = cy(y);
+        const t0 = Math.max(0, Math.min(1, (py - unit - a[1]) / dy));
+        const t1 = Math.max(0, Math.min(1, (py + unit - a[1]) / dy));
+        const xa = a[0] + (b[0] - a[0]) * t0;
+        const xb = a[0] + (b[0] - a[0]) * t1;
+        lo = Math.min(xa, xb);
+        hi = Math.max(xa, xb);
+      }
+      const x0 = Math.max(0, cellOf(lo, Math.floor, -1, w));
+      const x1 = Math.min(w - 1, cellOf(hi, Math.ceil, 1, w));
+      for (let x = x0; x <= x1; x++) {
+        const k = y * w + x;
+        if (marks[k]) continue;
+        if (distanceToSegment([cx(x), cy(y)], a, b) <= ON_BOUNDARY) marks[k] = 1;
+      }
+    }
+  }
+  return marks;
+}
+
 /** Does the segment `a`–`b` meet the closed polygon — an endpoint inside or on it, or any crossing or touch? */
 function segmentMeetsPolygon(a: Pt, b: Pt, poly: readonly Pt[]): boolean {
   if (inClosedPolygon(a, poly) || inClosedPolygon(b, poly)) return true;
@@ -1673,8 +1793,10 @@ function regionRows(input: MeshMeasureInput, outline: MeshOutline, hullPolygon:
     // would keep, in the same order.
     const centreOf = (i: number): Pt => [((i % mask.width) + 0.5) / scale, (Math.floor(i / mask.width) + 0.5) / scale];
     const inRegion = (): Int32Array => {
+      // `inClosedPolygon` of every art pixel centre, by scanline (`closedPolygonCentres`, issue #1263).
+      const inside = closedPolygonCentres(poly, mask.width, mask.height, scale);
       const kept: number[] = [];
-      for (let i = 0; i < artBits.length; i++) if (artBits[i] && inClosedPolygon(centreOf(i), poly)) kept.push(i);
+      for (let i = 0; i < artBits.length; i++) if (artBits[i] && inside[i]) kept.push(i);
       return Int32Array.from(kept);
     };
     const regionPixels = steps === null ? inRegion() : steps.regionPixels(poly, inRegion);