chore: the benchmark scripts follow the picture sizes, and one checks images with a fine texture

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>

Author: Shilo

bench/.gitignore

@@ -8,3 +8,5 @@ matrix.txt
 review-*
 committed/
 /codex-*
+codex-*
+review2-*

bench/alias.mjs

@@ -0,0 +1,29 @@
+// Images whose pixels repeat in a small pattern (dithered art, stippled transparency): does a
+// tile that draws them smaller show them as light as they are? Share of light pixels among the
+// solid ones, for the whole image and for pictures of it at the sizes a tile might have. 512 and
+// 256 are whole fractions of the image, where the same part of a texture is picked every time.
+import { pathToFileURL } from 'node:url';
+const B = await import(pathToFileURL(import.meta.dirname + '/../src/lib/bitify.js'));
+const w = 1024, h = 1024;
+const BAYER = [0, 8, 2, 10, 12, 4, 14, 6, 3, 11, 1, 9, 15, 7, 13, 5];
+const make = pixel => {
+  const data = new Uint8ClampedArray(w * h * 4);
+  for (let y = 0, i = 0; y < h; y++) for (let x = 0; x < w; x++, i += 4) data.set(pixel(x, y), i);
+  return B.analyze({ width: w, height: h, data });
+};
+const shade = (x, y) => 128 + 100 * Math.sin(x / 160) * Math.cos(y / 120);
+const cases = {
+  // a smooth picture seen through a stipple: 2 by 2 blocks, solid and see-through in turn
+  'stippled alpha': make((x, y) => { const v = shade(x, y); return [v, v, v, ((x >> 1) + (y >> 1)) % 2 ? 0 : 255]; }),
+  // the same picture already dithered to black and white, as 1-bit art is
+  'dithered source': make((x, y) => { const v = shade(x, y) / 255 > (BAYER[(y & 3) * 4 + (x & 3)] + 0.5) / 16 ? 255 : 0; return [v, v, v, 255]; }),
+  // one-pixel stripes
+  'striped source': make((x, y) => { const v = y % 2 ? 230 : 40; return [v, v, v, 255]; }),
+};
+const light = m => { let on = 0, solid = 0; for (const v of m) { solid += v > 0; on += v === 2; } return solid ? (100 * on / solid).toFixed(0).padStart(4) + '%' : '   -'; };
+const SIZES = [1024, 955, 700, 512, 478, 341, 256];
+console.log('image             style     ' + SIZES.map(s => (s === 1024 ? 'whole' : 'at ' + s).padStart(7)).join(''));
+for (const [name, img] of Object.entries(cases)) for (const style of ['solid', 'checker', 'bayer', 'atkinson', 'cutout']) {
+  console.log(name.padEnd(17), style.padEnd(9), SIZES.map(s => light(B.mask(img, style, style === 'solid' || style === 'cutout' ? 128 : null, s, s)).padStart(7)).join(''));
+}
+

bench/equiv.mjs

@@ -22,22 +22,23 @@ for (let n = 0; n < 400; n++) {
   for (const st of STYLES) for (const t of [null, 1, 60, 128, 200, 254]) {
     const ma = O.mask(a, st, t), mb = N.mask(b, st, t);
     assert.deepEqual([...mb], [...ma], `${st} t=${t} ${w}x${h} n=${n}`);
-    // the patterns and Atkinson are drawn afresh on the kept pixels, so only the others are the full mask sampled
-    for (const k of ['cutout', 'lines', 'solid', 'silhouette'].includes(st) ? [2, 3, 5, 16, 50] : []) {
+    // A smaller picture: in these four styles each of its pixels is the full mask's at the image pixel under its middle.
+    // (The patterns and Atkinson are drawn afresh on the picture's pixels, so they are not.)
+    for (const [mw, mh] of ['cutout', 'lines', 'solid', 'silhouette'].includes(st) ? [[w, h], [Math.ceil(w / 2), Math.ceil(h / 2)], [Math.ceil(w / 3), Math.ceil(h / 1.7)], [1, 1], [Math.max(1, w - 1), Math.max(1, h - 1)]] : []) {
       const want = [];
-      for (let y = 0; y < h; y += k) for (let x = 0; x < w; x += k) want.push(ma[y * w + x]);
-      assert.deepEqual([...N.mask(b, st, t, k)], want, `${st} t=${t} k=${k}`);
+      for (let j = 0; j < mh; j++) for (let i = 0; i < mw; i++) want.push(ma[Math.floor((j + 0.5) * h / mh) * w + Math.floor((i + 0.5) * w / mw)]);
+      assert.deepEqual([...N.mask(b, st, t, mw, mh)], want, `${st} t=${t} ${mw}x${mh}`);
     }
     checks++;
   }
   const m = O.mask(a, 'cutout');
   assert.deepEqual([...N.colorize(m, '#12ab9f', '#fe0180')], [...O.colorize(m, '#12ab9f', '#fe0180')]);
-  const sh = N.shrink(src, 3), want = [];
-  for (let y = 0; y < h; y += 3) for (let x = 0; x < w; x += 3) want.push(...data.subarray((y * w + x) * 4, (y * w + x) * 4 + 4));
+  const sw = Math.ceil(w / 3), shh = Math.ceil(h / 2), sh = N.shrink(src, sw, shh), want = [];
+  for (let j = 0; j < shh; j++) for (let i = 0; i < sw; i++) { const at = (Math.floor((j + 0.5) * h / shh) * w + Math.floor((i + 0.5) * w / sw)) * 4; want.push(...data.subarray(at, at + 4)); }
   assert.deepEqual([...sh], want);
 }
 // animations: unify
 const fr = [0, 1, 2].map(j => ({ width: 9, height: 7, data: Uint8ClampedArray.from({ length: 9 * 7 * 4 }, (_, i) => (i % 4 === 3 ? 255 : (i * (j + 3) * 37) % 256)) }));
 const ua = O.unify(fr.map(O.analyze)), ub = N.unify(fr.map(N.analyze));
 for (const f of ['auto', 'autoLine', 'autoTone', 'autoSeam', 'lo', 'hi']) assert.equal(ub[0][f], ua[0][f]);
-console.log(`identical: ${checks} image/style/threshold combinations, each also at 5 values of k`);
+console.log(`identical: ${checks} image/style/threshold combinations, each also as 5 smaller pictures`);

bench/kcost.mjs

@@ -1,4 +1,4 @@
-// Cost per converted pixel at different k, in nanoseconds.
+// Cost per converted pixel for the whole image and for smaller pictures of it, in nanoseconds.
 import { pathToFileURL } from 'node:url';
 const B = await import(pathToFileURL(import.meta.dirname + '/../src/lib/bitify.js'));
 function photo(w, h) {
@@ -14,10 +14,10 @@ for (const [w, h] of [[2048, 2048], [4000, 3000]]) {
   const img = B.analyze(photo(w, h));
   for (const style of (process.argv[2] ?? 'cutout,lines,solid,bayer').split(',')) {
     const line = [`${w}x${h} ${style}`.padEnd(20)];
-    for (const k of [1, 2, 3, 4, 8]) {
+    for (const k of [1, 1.07, 2, 2.14, 4.19, 8]) {
       let best = Infinity, n;
-      for (let i = 0; i < 12; i++) { const t = performance.now(); n = B.mask(img, style, 60 + i * 9, k).length; best = Math.min(best, performance.now() - t); }
-      line.push(`k${k}: ${(best * 1e6 / n).toFixed(1)}ns (${best.toFixed(1)}ms)`);
+      for (let i = 0; i < 12; i++) { const t = performance.now(); n = B.mask(img, style, 60 + i * 9, Math.round(w / k), Math.round(h / k)).length; best = Math.min(best, performance.now() - t); }
+      line.push(`1 in ${k}: ${(best * 1e6 / n).toFixed(1)}ns (${best.toFixed(1)}ms)`);
     }
     console.log(line.join('  '));
   }

bench/tone.mjs

@@ -11,8 +11,9 @@ const img = B.analyze({ width: w, height: h, data });
 const light = m => (100 * m.reduce((n, v) => n + (v === 2), 0) / m.length).toFixed(1).padStart(5);
 // how often a pixel has the same value as the one to its right: the texture, not just the tone
 const runs = (m, pw) => { let same = 0, n = 0; for (let p = 0; p + 1 < m.length; p++) if ((p + 1) % pw) { n++; same += m[p] === m[p + 1]; } return (100 * same / n).toFixed(1).padStart(5); };
-console.log('style      ' + [1, 2, 3, 4, 5, 8, 11, 16].map(k => `k=${k}`.padStart(13)).join(''));
+const SIZES = [1200, 955, 600, 400, 300, 240, 150, 109];
+console.log('style      ' + SIZES.map(s => `${s} wide`.padStart(12)).join(''));
 for (const style of ['solid', 'cutout', 'lines', 'checker', 'hatch', 'bayer', 'noise', 'atkinson']) {
-  console.log(style.padEnd(10), [1, 2, 3, 4, 5, 8, 11, 16].map(k => { const m = B.mask(img, style, null, k); return `${light(m)}/${runs(m, Math.ceil(w / k))}`; }).join(' '));
+  console.log(style.padEnd(10), SIZES.map(mw => { const mh = Math.round(h * mw / w), m = B.mask(img, style, null, mw, mh); return `${light(m)}/${runs(m, mw)}`; }).join(' '));
 }
 console.log('(each cell: % light / % of pixels equal to their right neighbour)');