Text positions: search hits and the OCR text layer

/** The box of characters [i0, i1) of one item, in user space. */
function partBox(it, i0, i1) {
  const [a, b, c, d, e, f] = it.transform || [1, 0, 0, 1, 0, 0];
  const n = Math.max(1, String(it.str).length);
  const len = Math.hypot(a, b) || 1, up = Math.hypot(c, d) || 1;
  const ux = a / len, uy = b / len, vx = c / up, vy = d / up;
  const size = up;
  const w = Number.isFinite(it.width) && it.width > 0 ? it.width : n * size * 0.5;
  const s0 = (w * i0) / n, s1 = (w * i1) / n;
  const lo = -0.22 * size, hi = 0.9 * size;   // descenders and cap height around the baseline
  const pts = [[s0, lo], [s1, lo], [s1, hi], [s0, hi]].map(([s, t]) => [e + ux * s + vx * t, f + uy * s + vy * t]);
  const xs = pts.map((p) => p[0]), ys = pts.map((p) => p[1]);
  return [Math.min(...xs), Math.min(...ys), Math.max(...xs), Math.max(...ys)];
}

export function hitCloud(hit, { pad = 4, rot = 0, sheet, author = '', subject = '' } = {}) {
  const [x0, y0, x1, y1] = hit.rect;
  return { sheet, type: 'cloudrect', rot, author, subject, rect: [x0 - pad, y0 - pad, x1 + pad, y1 + pad] };
}

export function ocrScale(w, h, { dpi = OCR_DPI, maxSide = 6000, maxPixels = 36e6 } = {}) {
  let s = dpi / 72;
  s = Math.min(s, maxSide / Math.max(w, h, 1));
  s = Math.min(s, Math.sqrt(maxPixels / Math.max(1, w * h)));
  return Math.max(0.05, s);
}

/**
 * The text-only page (points, y up, as big as the picture at its dpi) → PDF user space of the sheet: points → picture pixels
 * (y down), then back through the viewport the picture was drawn with.
 */
export function ocrMatrix(vpT, picW, picH, mediaW, mediaH) {
  const kx = picW / mediaW, ky = picH / mediaH;
  const toPixels = [kx, 0, 0, -ky, 0, picH];
  return mul(inv(vpT), toPixels);
}

/**
 * Words → text items in user space. Each word's baseline comes from its line's baseline (Tesseract gives it in pixels),
 * its size so that textsearch's box (−0.22 … 0.9 of the size round the baseline) reaches the word's top.
 * `minConf`: words read with less confidence (0–100) are left out (none by default: search finds what Tesseract found).
 */
export function ocrItems(blocks, vpT, { minConf = 0 } = {}) {
  const back = inv(vpT);
  const items = [];
  for (const b of blocks || []) for (const par of b.paragraphs || []) for (const line of par.lines || []) {
    const words = (line.words || []).filter((w) => /\S/.test(w.text || '') && (w.confidence ?? 100) >= minConf);
    const bl = line.baseline || null;
    words.forEach((w, i) => {
      const { x0, y0, x1, y1 } = w.bbox;
      const baseAt = (x) => (bl && bl.x1 !== bl.x0 ? bl.y0 + (bl.y1 - bl.y0) * (x - bl.x0) / (bl.x1 - bl.x0) : y1);
      const by0 = Math.min(y1, Math.max(y0 + 1, baseAt(x0))), by1 = Math.min(y1, Math.max(y0 + 1, baseAt(x1)));
      const p0 = apply(back, [x0, by0]), p1 = apply(back, [x1, by1]);
      const len = Math.hypot(p1[0] - p0[0], p1[1] - p0[1]) || 1;
      const ux = (p1[0] - p0[0]) / len, uy = (p1[1] - p0[1]) / len;
      // "up" in user space: the picture's up (−y) taken through the viewport, kept square to the baseline
      const t = apply(back, [x0, by0 - 10]);
      let vx = t[0] - p0[0], vy = t[1] - p0[1];
      const side = ux * vy - uy * vx >= 0 ? 1 : -1;
      vx = -uy * side; vy = ux * side;
      const topPx = Math.max(1, by0 - y0);
      const top = apply(back, [x0, by0 - topPx]);
      const size = Math.max(0.5, Math.hypot(top[0] - p0[0], top[1] - p0[1]) / 0.9);
      items.push({ str: w.text, transform: [ux * size, uy * size, vx * size, vy * size, p0[0], p0[1]], width: len, height: size, hasEOL: i === words.length - 1, ocr: true, conf: w.confidence ?? null });
    });
  }
  return items;
}

/** Word count and mean confidence of a page's result (for the status line). */
export function ocrSummary(items) {
  const n = items.length;
  const conf = items.filter((i) => Number.isFinite(i.conf));
  return { words: n, conf: conf.length ? Math.round(conf.reduce((s, i) => s + i.conf, 0) / conf.length) : null };
}