rig-c 0.0.0-stage → 2.20.4

package/tools/font5x7.ts

@@ -0,0 +1,101 @@
+/**
+ * A 5x7 bitmap font, uppercase + digits + a little punctuation.
+ *
+ * It exists so a generated plate can burn its own name into its own pixels with
+ * no font file, no canvas and no dependency. That matters more than it sounds:
+ * the whole point of a synthetic stand-in plate is that nobody can mistake it
+ * for real art, and the strongest form of that is the word PLACEHOLDER sitting
+ * in the image itself.
+ *
+ * Each glyph is 7 rows of 5 bits, MSB = leftmost column.
+ */
+const GLYPHS: Record<string, number[]> = {
+  A: [0x0e, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
+  B: [0x1e, 0x11, 0x11, 0x1e, 0x11, 0x11, 0x1e],
+  C: [0x0e, 0x11, 0x10, 0x10, 0x10, 0x11, 0x0e],
+  D: [0x1e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x1e],
+  E: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x1f],
+  F: [0x1f, 0x10, 0x10, 0x1e, 0x10, 0x10, 0x10],
+  G: [0x0e, 0x11, 0x10, 0x17, 0x11, 0x11, 0x0e],
+  H: [0x11, 0x11, 0x11, 0x1f, 0x11, 0x11, 0x11],
+  I: [0x0e, 0x04, 0x04, 0x04, 0x04, 0x04, 0x0e],
+  J: [0x07, 0x02, 0x02, 0x02, 0x02, 0x12, 0x0c],
+  K: [0x11, 0x12, 0x14, 0x18, 0x14, 0x12, 0x11],
+  L: [0x10, 0x10, 0x10, 0x10, 0x10, 0x10, 0x1f],
+  M: [0x11, 0x1b, 0x15, 0x15, 0x11, 0x11, 0x11],
+  N: [0x11, 0x19, 0x19, 0x15, 0x13, 0x13, 0x11],
+  O: [0x0e, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
+  P: [0x1e, 0x11, 0x11, 0x1e, 0x10, 0x10, 0x10],
+  Q: [0x0e, 0x11, 0x11, 0x11, 0x15, 0x13, 0x0d],
+  R: [0x1e, 0x11, 0x11, 0x1e, 0x14, 0x12, 0x11],
+  S: [0x0f, 0x10, 0x10, 0x0e, 0x01, 0x01, 0x1e],
+  T: [0x1f, 0x04, 0x04, 0x04, 0x04, 0x04, 0x04],
+  U: [0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x0e],
+  V: [0x11, 0x11, 0x11, 0x11, 0x11, 0x0a, 0x04],
+  W: [0x11, 0x11, 0x11, 0x15, 0x15, 0x1b, 0x11],
+  X: [0x11, 0x11, 0x0a, 0x04, 0x0a, 0x11, 0x11],
+  Y: [0x11, 0x11, 0x0a, 0x04, 0x04, 0x04, 0x04],
+  Z: [0x1f, 0x01, 0x02, 0x04, 0x08, 0x10, 0x1f],
+  '0': [0x0e, 0x11, 0x13, 0x15, 0x19, 0x11, 0x0e],
+  '1': [0x04, 0x0c, 0x04, 0x04, 0x04, 0x04, 0x0e],
+  '2': [0x0e, 0x11, 0x01, 0x02, 0x04, 0x08, 0x1f],
+  '3': [0x1f, 0x02, 0x04, 0x06, 0x01, 0x11, 0x0e],
+  '4': [0x02, 0x06, 0x0a, 0x12, 0x1f, 0x02, 0x02],
+  '5': [0x1f, 0x10, 0x1e, 0x01, 0x01, 0x11, 0x0e],
+  '6': [0x06, 0x08, 0x10, 0x1e, 0x11, 0x11, 0x0e],
+  '7': [0x1f, 0x01, 0x02, 0x04, 0x08, 0x08, 0x08],
+  '8': [0x0e, 0x11, 0x11, 0x0e, 0x11, 0x11, 0x0e],
+  '9': [0x0e, 0x11, 0x11, 0x0f, 0x01, 0x02, 0x0c],
+  ' ': [0, 0, 0, 0, 0, 0, 0],
+  _: [0, 0, 0, 0, 0, 0, 0x1f],
+  '-': [0, 0, 0, 0x1f, 0, 0, 0],
+  '.': [0, 0, 0, 0, 0, 0x0c, 0x0c],
+  ',': [0, 0, 0, 0, 0x0c, 0x0c, 0x04],
+  ':': [0, 0x0c, 0x0c, 0, 0x0c, 0x0c, 0],
+  '/': [0x01, 0x02, 0x02, 0x04, 0x08, 0x08, 0x10],
+  '(': [0x02, 0x04, 0x08, 0x08, 0x08, 0x04, 0x02],
+  ')': [0x08, 0x04, 0x02, 0x02, 0x02, 0x04, 0x08],
+  '!': [0x04, 0x04, 0x04, 0x04, 0x04, 0, 0x04],
+  '+': [0, 0x04, 0x04, 0x1f, 0x04, 0x04, 0],
+  '=': [0, 0, 0x1f, 0, 0x1f, 0, 0],
+  '<': [0x02, 0x04, 0x08, 0x10, 0x08, 0x04, 0x02],
+  '>': [0x08, 0x04, 0x02, 0x01, 0x02, 0x04, 0x08],
+};
+
+export const GLYPH_W = 5;
+export const GLYPH_H = 7;
+
+/** Width in pixels of `text` drawn at `scale` with a one-column gap. */
+export function textWidth(text: string, scale: number): number {
+  if (!text.length) return 0;
+  return (text.length * (GLYPH_W + 1) - 1) * scale;
+}
+
+/**
+ * Rasterise `text` by calling `plot(x, y)` for every lit pixel, with the top
+ * left of the first glyph at (x0, y0). Unknown characters draw as a full block
+ * so a typo is loud rather than invisible.
+ */
+export function drawText(
+  text: string,
+  x0: number,
+  y0: number,
+  scale: number,
+  plot: (x: number, y: number) => void,
+): void {
+  let cursor = x0;
+  for (const ch of text.toUpperCase()) {
+    const glyph = GLYPHS[ch] ?? [0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f, 0x1f];
+    for (let row = 0; row < GLYPH_H; row++) {
+      for (let col = 0; col < GLYPH_W; col++) {
+        if (!(glyph[row] & (1 << (GLYPH_W - 1 - col)))) continue;
+        for (let sy = 0; sy < scale; sy++) {
+          for (let sx = 0; sx < scale; sx++) {
+            plot(cursor + col * scale + sx, y0 + row * scale + sy);
+          }
+        }
+      }
+    }
+    cursor += (GLYPH_W + 1) * scale;
+  }
+}

package/tools/measure_contact_depth.ts

@@ -0,0 +1,105 @@
+#!/usr/bin/env bun
+/**
+ * Measure a cut's contact depth from its plates.
+ *
+ *   bun tools/measure_contact_depth.ts <manifest.json> <massSlot> <againstSlot>
+ *
+ * The rule it makes mechanical: inward travel goes at most until the moving mass
+ * touches the part that occludes it. That turns the deepest inward amplitude
+ * from a number somebody picks into a measured fact.
+ *
+ * ⚠️ The two slot names are REQUIRED and the tool has no defaults for them. Which
+ * plate is the mass and which is the occluder is a fact about one cut's anatomy,
+ * and a default here would quietly measure the wrong pair on the next cut and
+ * still print a plausible number.
+ *
+ * The result goes into the manifest as `stroke.contact_depth`. It is not computed
+ * at build time on purpose — the compiler never re-measures art, the same
+ * division that keeps `mesh.center` a measured manifest number.
+ *
+ * Output includes the two-sided proof the depth has to satisfy: ZERO overlapping
+ * body pixels at the depth, and MORE THAN ZERO one pixel past it. A depth with no
+ * overlap one pixel past is not "touching", it is just short.
+ */
+import { readFileSync } from 'node:fs';
+import { dirname, resolve } from 'node:path';
+import { readPlate } from './plate.ts';
+import { BODY_ALPHA, measureContactDepth } from './contact.ts';
+
+interface Part {
+  slot: string;
+  image?: string;
+  offset: [number, number];
+  size?: [number, number];
+}
+interface Manifest {
+  crop: { w: number; h: number };
+  insertion?: [number, number];
+  axis?: { deg: number };
+  stroke?: { contact_depth?: number };
+  parts: Part[];
+}
+
+const [manifestArg, massSlot, againstSlot] = process.argv.slice(2);
+if (!manifestArg || !massSlot || !againstSlot) {
+  console.error('usage: bun tools/measure_contact_depth.ts <manifest.json> <massSlot> <againstSlot>');
+  console.error('  massSlot    the part that advances');
+  console.error('  againstSlot the part it must not pass through');
+  process.exit(2);
+}
+const manifestPath = resolve(manifestArg);
+const manifest = JSON.parse(readFileSync(manifestPath, 'utf8')) as Manifest;
+const dir = dirname(manifestPath);
+
+if (!manifest.axis) {
+  console.error('manifest has no `axis`; the contact depth is a distance ALONG the axis and cannot be measured without it');
+  process.exit(1);
+}
+const partOf = (slot: string): Part => {
+  const part = manifest.parts.find((p) => p.slot === slot);
+  if (!part?.image) throw new Error(`manifest has no part with an image for slot "${slot}"`);
+  return part;
+};
+const load = (slot: string) => {
+  const part = partOf(slot);
+  return { part, plate: readPlate(resolve(dir, part.image!)) };
+};
+
+const mass = load(massSlot);
+const against = load(againstSlot);
+const rad = (manifest.axis.deg * Math.PI) / 180;
+const inward: [number, number] = [Math.cos(rad), Math.sin(rad)];
+
+const result = measureContactDepth(
+  { plate: mass.plate, offset: mass.part.offset },
+  { plate: against.plate, offset: against.part.offset },
+  inward,
+);
+
+console.log(`contact depth for ${manifestPath}`);
+console.log(`  axis            ${manifest.axis.deg} deg (screen, y down) -> inward unit [${inward.map((v) => v.toFixed(4)).join(', ')}]`);
+console.log(`  mass            ${massSlot.padEnd(12)} ${mass.plate.width}x${mass.plate.height} at ${JSON.stringify(mass.part.offset)}  ${result.massPixels} body px`);
+console.log(`  against         ${againstSlot.padEnd(12)} ${against.plate.width}x${against.plate.height} at ${JSON.stringify(against.part.offset)}  ${result.againstPixels} body px`);
+console.log(`  alpha threshold ${result.alphaThreshold} of 255`);
+const expected = result.touches ? result.depth : null;
+if (!result.touches) {
+  console.log(`  DEPTH           none — scanned to ${result.depth}px without the footprints ever meeting`);
+  console.log('                  along this axis the masses never touch, so the rule imposes no ceiling');
+} else {
+  console.log(`  DEPTH           ${result.depth} px inward`);
+  console.log(`  overlap at depth      ${result.overlapAtDepth}  (must be 0)`);
+  console.log(`  overlap one px past   ${result.overlapPastDepth}  (must be > 0, or the depth is short rather than touching)`);
+  console.log(`  first contact   ${JSON.stringify(result.contactPoint)} (crop px)`);
+}
+
+const declared = manifest.stroke?.contact_depth ?? null;
+if ('contact_depth' in (manifest.stroke ?? {})) {
+  const agrees = declared === expected;
+  console.log(`  manifest says   ${JSON.stringify(declared)} -> ${agrees ? 'agrees' : 'DISAGREES with the plates'}`);
+  if (!agrees) process.exit(1);
+}
+if (result.touches && (result.overlapAtDepth !== 0 || result.overlapPastDepth === 0)) {
+  console.error('  the two-sided proof failed: this is not a tangency');
+  process.exit(1);
+}
+console.log(result.touches ? '  ok — tangent at the depth, overlapping one pixel past it' : '  ok — no ceiling to declare');