Automatic count by symbol matching

/** RGBA (canvas ImageData) → ink darkness 0..1. */
export function toInk(rgba, w, h) {
  const out = new Float32Array(w * h);
  for (let i = 0, j = 0; i < out.length; i++, j += 4) {
    const a = rgba[j + 3] / 255;
    const lum = (0.299 * rgba[j] + 0.587 * rgba[j + 1] + 0.114 * rgba[j + 2]) / 255;
    out[i] = 1 - (lum * a + (1 - a));       // transparent = paper
  }
  return out;
}

/**
 * Rotate a raster by `deg` clockwise (as seen on screen, y down) about its middle, into the box that holds it all;
 * bilinear, paper (0) outside. Right angles go through rot90 (exact).
 */
export function rotate(t, deg) {
  const r = ((deg % 360) + 360) % 360;
  if (r === 0) return t;
  if (r % 90 === 0) { let o = t; for (let k = 0; k < r / 90; k++) o = rot90(o); return o; }
  const a = r * Math.PI / 180, c = Math.cos(a), s = Math.sin(a);
  const w = Math.ceil(Math.abs(t.w * c) + Math.abs(t.h * s)), h = Math.ceil(Math.abs(t.w * s) + Math.abs(t.h * c));
  const out = new Float32Array(w * h);
  const cx0 = t.w / 2, cy0 = t.h / 2, cx1 = w / 2, cy1 = h / 2;
  for (let y = 0; y < h; y++) for (let x = 0; x < w; x++) {
    // the destination pixel's middle, turned back into the source
    const dx = x + 0.5 - cx1, dy = y + 0.5 - cy1;
    const u = c * dx + s * dy + cx0 - 0.5, v = -s * dx + c * dy + cy0 - 0.5;
    const x0 = Math.floor(u), y0 = Math.floor(v), fx = u - x0, fy = v - y0;
    const at = (xx, yy) => (xx >= 0 && yy >= 0 && xx < t.w && yy < t.h ? t.data[yy * t.w + xx] : 0);
    out[y * w + x] = (at(x0, y0) * (1 - fx) + at(x0 + 1, y0) * fx) * (1 - fy) + (at(x0, y0 + 1) * (1 - fx) + at(x0 + 1, y0 + 1) * fx) * fy;
  }
  return { data: out, w, h };
}

/**
 * NCC of one template over the image → local peaks ≥ floor: [{ x, y, score }] (top-left, px).
 * `tick(rowsDone)` is called now and then; returning true from `stop()` aborts (returns null).
 */
export function nccPeaks(img, t, { floor = 0.5, minStd = 0.02, I = integrals(img), tick = null, stop = null, gate = null } = {}) {
  const { mean: tm, std: ts } = stats(t);
  const n = t.w * t.h;
  // 0.8 EG.67: gate = [lo, hi] — skip a window whose ink is outside lo..hi times the symbol's (turning a symbol keeps its ink), so a big plan
  // costs a fraction of a full correlation; a symbol with a long line through it can fall outside (Auto count has no gate)
  const mass = gate ? tm * n : 0, gLo = gate ? gate[0] * mass : 0, gHi = gate ? gate[1] * mass : 0;
  const tz = new Float32Array(n);
  for (let i = 0; i < n; i++) tz[i] = t.data[i] - tm;
  const tnorm = ts * Math.sqrt(n);
  const W = img.w - t.w + 1, H = img.h - t.h + 1;
  if (W <= 0 || H <= 0) return [];
  const score = new Float32Array(W * H);
  const { s, s2, W: IW } = I;
  const d = img.data, iw = img.w;
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      const a = y * IW + x, b = a + t.w, c = (y + t.h) * IW + x, e = c + t.w;
      const sum = s[e] - s[b] - s[c] + s[a], sum2 = s2[e] - s2[b] - s2[c] + s2[a];
      const v = sum2 / n - (sum / n) * (sum / n);
      if (v < minStd * minStd) continue;                  // blank (or solid) paper: no match
      if (gate && (sum < gLo || sum > gHi)) continue;
      let dot = 0;
      for (let ty = 0, k = 0; ty < t.h; ty++) {
        const row = (y + ty) * iw + x;
        for (let tx = 0; tx < t.w; tx++, k++) dot += tz[k] * d[row + tx];
      }
      score[y * W + x] = dot / (tnorm * Math.sqrt(v * n));
    }
    if (tick && (y & 15) === 15) { if (stop?.()) return null; tick(y + 1, H); }
  }
  const peaks = [];
  for (let y = 0; y < H; y++) {
    for (let x = 0; x < W; x++) {
      const v = score[y * W + x];
      if (v < floor) continue;
      let best = true;
      for (let dy = -1; dy <= 1 && best; dy++) for (let dx = -1; dx <= 1; dx++) {
        if (!dx && !dy) continue;
        const xx = x + dx, yy = y + dy;
        if (xx < 0 || yy < 0 || xx >= W || yy >= H) continue;
        const u = score[yy * W + xx];
        if (u > v || (u === v && (dy < 0 || (dy === 0 && dx < 0)))) { best = false; break; }
      }
      if (best) {
        // the true peak usually sits between pixels: fit a parabola through the neighbours on each axis
        const at = (xx, yy) => (xx < 0 || yy < 0 || xx >= W || yy >= H ? v : score[yy * W + xx]);
        const fit = (a, c) => { const den = a - 2 * v + c; if (den >= 0) return [0, 0]; const d = Math.max(-0.5, Math.min(0.5, (a - c) / (2 * den))); return [d, -(a - c) * d / 4]; };
        const [dx, gx] = fit(at(x - 1, y), at(x + 1, y)), [dy, gy] = fit(at(x, y - 1), at(x, y + 1));
        peaks.push({ x, y, dx, dy, score: Math.min(1, v + Math.max(0, gx) + Math.max(0, gy)), raw: v });
      }
    }
  }
  return peaks;
}

/**
 * Search one image for a template at each of `rotations` (degrees clockwise; 0/90/180/270 by default, ANY_ANGLES for any
 * angle). → [{ x, y, w, h, rot, score }] in image px. progress(fraction) is called as it goes; stop() → true aborts (null).
 */
export function findSymbol(img0, template0, { rotations = [0, 90, 180, 270], floor = 0.5, smooth = BLUR, progress = null, stop = null, I: shared = null, gate = null } = {}) {
  const img = smooth ? blur(img0, smooth) : img0, template = smooth ? blur(template0, smooth) : template0;
  const I = shared && !smooth ? shared : integrals(img);      // 0.8 EG.67: a legend run searches many symbols on one sheet — one integral image
  const out = [];
  const list = [...new Set(rotations.map((r) => ((Math.round(r) % 360) + 360) % 360))];
  // any angle: a coarse pass at a lower floor, then each candidate's angle refined on a small window around it
  const fine = list.some((r) => r % 90 !== 0);
  const coarseFloor = fine ? Math.max(0.3, floor - 0.2) : floor;
  for (let i = 0; i < list.length; i++) {
    const r = list[i], tt = rotate(template, r);
    const peaks = nccPeaks(img, tt, { floor: coarseFloor, I, stop, gate, tick: progress ? (done, total) => progress((i + done / total) / list.length * (fine ? 0.8 : 1)) : null });
    if (!peaks) return null;
    for (const p of peaks) out.push({ x: p.x, y: p.y, w: tt.w, h: tt.h, rot: r, score: p.score });
  }
  if (!fine) { progress?.(1); return out; }
  const best = suppress(out, coarseFloor, 0.25).slice(0, 400);
  const refined = [];
  for (let k = 0; k < best.length; k++) {
    if (stop?.()) return null;
    const r = refineAngle(img, template, best[k]);
    if (r.score >= floor) refined.push(r);
    progress?.(0.8 + 0.2 * (k + 1) / best.length);
  }
  progress?.(1);
  return refined;
}

/** Try angles within ±7.5° of a candidate's (1.5° steps) on a window around it; the best fit. */
export function refineAngle(img, template, c) {
  const cx = c.x + c.w / 2, cy = c.y + c.h / 2;
  let best = c;
  for (let d = -7.5; d <= 7.5 + 1e-9; d += 1.5) {
    const r = ((c.rot + d) % 360 + 360) % 360, tt = rotate(template, r);
    const pad = 3;
    const x0 = Math.max(0, Math.floor(cx - tt.w / 2) - pad), y0 = Math.max(0, Math.floor(cy - tt.h / 2) - pad);
    const win = crop(img, x0, y0, tt.w + 2 * pad, tt.h + 2 * pad);
    if (win.w < tt.w || win.h < tt.h) continue;
    for (const p of nccPeaks(win, tt, { floor: 0 }) || []) {
      if (p.score > best.score + 1e-9) best = { x: x0 + p.x, y: y0 + p.y, w: tt.w, h: tt.h, rot: r, score: p.score };
    }
  }
  return best;
}

/** Keep candidates ≥ threshold, best first, dropping any that overlaps a kept one by IoU > maxOverlap. */
export function suppress(cands, threshold, maxOverlap = 0.25) {
  const keep = [];
  for (const c of cands.filter((c) => c.score >= threshold).sort((a, b) => b.score - a.score)) {
    if (!keep.some((k) => k.sheet === c.sheet && iou(k, c) > maxOverlap)) keep.push(c);
  }
  return keep;
}

/**
 * Hits (one per find, in sheet units): { entry, sheet, x, y, w, h, score, … }. Within one symbol, finds that overlap are one find (match.js
 * suppress, at that symbol's threshold); between symbols, a spot two of them match goes to the higher score.
 * `th(entry)` = that symbol's threshold. → { kept, mixed: Map("a|b" → count) }
 */
export function keepBest(hits, th) {
  const bySymbol = new Map();
  for (const h of hits) { const k = h.entry + '|' + h.sheet; (bySymbol.get(k) || bySymbol.set(k, []).get(k)).push(h); }
  let first = [];
  for (const list of bySymbol.values()) first = first.concat(suppress(list.map((h) => ({ ...h, sheet: h.sheet })), th(list[0].entry), 0.25));
  first.sort((a, b) => b.score - a.score);
  const kept = [], mixed = new Map(), bySheet = new Map();
  for (const h of first) {
    const here = bySheet.get(h.sheet) || bySheet.set(h.sheet, []).get(h.sheet);
    const clash = here.find((k) => k.entry !== h.entry && iou(k, h) > 0.5);
    if (clash) { const key = [clash.entry, h.entry].sort().join('|'); mixed.set(key, (mixed.get(key) || 0) + 1); continue; }
    here.push(h); kept.push(h);
  }
  return { kept, mixed };
}

export function packTemplate(tpl) {
  const n = tpl.w * tpl.h, b = new Uint8Array(n);
  for (let i = 0; i < n; i++) b[i] = Math.max(0, Math.min(255, Math.round((tpl.data[i] || 0) * 255)));
  return { w: tpl.w, h: tpl.h, ink: toBase64(b) };
}
/** …and back, for match.js (Float32Array 0…1). Null when damaged. */
export function unpackTemplate(p) {
  if (!p || !intIn(p.w, LEARN_LIMITS.tplMin, LEARN_LIMITS.tplMax) || !intIn(p.h, LEARN_LIMITS.tplMin, LEARN_LIMITS.tplMax)) return null;
  const b = fromBase64(p.ink);
  if (!b || b.length !== p.w * p.h) return null;
  const data = new Float32Array(b.length);
  for (let i = 0; i < b.length; i++) data[i] = b[i] / 255;
  return { data, w: p.w, h: p.h };
}