@scanfit/browser 0.1.0-alpha.0

package/dist/detector.js

@@ -0,0 +1,580 @@
+import { v as _ } from "./chunks/geometry-57LNKdIq.js";
+const O = 0.5, P = (t, n = 0, o = 1) => Math.max(n, Math.min(o, t)), V = () => typeof performance > "u" ? Date.now() : performance.now();
+function T(t) {
+  const n = new Uint8Array(t.width * t.height);
+  for (let o = 0, r = 0; r < n.length; r++, o += 4) {
+    const e = t.data[o + 3] / 255, c = 77 * t.data[o] + 150 * t.data[o + 1] + 29 * t.data[o + 2] >> 8;
+    n[r] = Math.round(c * e + 255 * (1 - e));
+  }
+  return n;
+}
+function G(t, n, o) {
+  const r = Math.max(n, o) >= 600 ? 2 : 1, e = r * 2 + 1, c = new Uint8Array(t.length), a = new Uint8Array(t.length);
+  for (let s = 0; s < o; s++) {
+    const h = s * n;
+    for (let u = 0; u < n; u++) {
+      let f = 0;
+      for (let m = -r; m <= r; m++)
+        f += t[h + Math.max(0, Math.min(n - 1, u + m))];
+      c[h + u] = Math.round(f / e);
+    }
+  }
+  for (let s = 0; s < o; s++)
+    for (let h = 0; h < n; h++) {
+      let u = 0;
+      for (let f = -r; f <= r; f++)
+        u += c[Math.max(0, Math.min(o - 1, s + f)) * n + h];
+      a[s * n + h] = Math.round(u / e);
+    }
+  return a;
+}
+function J(t, n, o) {
+  const r = new Uint16Array(t.length), e = new Uint32Array(2041);
+  let c = 0;
+  for (let u = 1; u < o - 1; u++)
+    for (let f = 1; f < n - 1; f++) {
+      const m = u * n + f, M = -t[m - n - 1] + t[m - n + 1] - 2 * t[m - 1] + 2 * t[m + 1] - t[m + n - 1] + t[m + n + 1], I = -t[m - n - 1] - 2 * t[m - n] - t[m - n + 1] + t[m + n - 1] + 2 * t[m + n] + t[m + n + 1], d = Math.min(2040, Math.abs(M) + Math.abs(I));
+      r[m] = d, d && (e[d]++, c++);
+    }
+  let a = 0;
+  const s = c * 0.82;
+  let h = 0;
+  for (let u = 1; u < e.length; u++)
+    if (a += e[u], a >= s) {
+      h = u;
+      break;
+    }
+  return {
+    magnitude: r,
+    threshold: Math.round(P(h || 24, 24, 600)),
+    nonzero: c
+  };
+}
+function K(t, n, o, r) {
+  const e = new Uint8Array(t.length), c = new Int32Array(t.length), a = r * 0.42;
+  let s = 0, h = 0, u = 0;
+  for (let M = 0; M < t.length; M++)
+    t[M] >= r ? (e[M] = 2, c[h++] = M, u++) : t[M] >= a && (e[M] = 1);
+  for (; s < h; ) {
+    const M = c[s++], I = M % n, d = Math.floor(M / n);
+    for (let y = -1; y <= 1; y++)
+      for (let b = -1; b <= 1; b++) {
+        if (!b && !y || I + b < 0 || I + b >= n || d + y < 0 || d + y >= o)
+          continue;
+        const A = M + y * n + b;
+        e[A] === 1 && (e[A] = 2, c[h++] = A);
+      }
+  }
+  const f = new Uint8Array(e.length);
+  let m = 0;
+  for (let M = 0; M < e.length; M++)
+    e[M] === 2 && (f[M] = 1, m++);
+  return { binary: f, density: m / f.length, strong: u };
+}
+function R(t, n, o) {
+  const r = new Uint8Array(t.length);
+  for (let e = 1; e < o - 1; e++)
+    for (let c = 1; c < n - 1; c++) {
+      const a = e * n + c;
+      (t[a] || t[a - 1] || t[a + 1] || t[a - n] || t[a + n] || t[a - n - 1] || t[a - n + 1] || t[a + n - 1] || t[a + n + 1]) && (r[a] = 1);
+    }
+  return r;
+}
+function W(t) {
+  const n = new Uint32Array(256);
+  for (const s of t) n[s]++;
+  let o = 0;
+  for (let s = 0; s < 256; s++) o += s * n[s];
+  let r = 0, e = 0, c = -1, a = 127;
+  for (let s = 0; s < 255; s++) {
+    r += n[s], e += s * n[s];
+    const h = t.length - r;
+    if (!r || !h) continue;
+    const u = e / r - (o - e) / h, f = r * h * u * u;
+    f > c && (c = f, a = s);
+  }
+  return a;
+}
+function Z(t, n, o) {
+  const r = new Uint32Array(256);
+  let e = 0;
+  const c = (f) => {
+    r[f]++, e++;
+  };
+  for (let f = 0; f < n; f++)
+    c(t[f]), c(t[(o - 1) * n + f]);
+  for (let f = 1; f < o - 1; f++)
+    c(t[f * n]), c(t[f * n + n - 1]);
+  let a = 0, s = 127;
+  for (let f = 0; f < r.length; f++)
+    if (a += r[f], a >= e / 2) {
+      s = f;
+      break;
+    }
+  const h = new Uint32Array(256);
+  for (let f = 0; f < r.length; f++)
+    h[Math.abs(f - s)] += r[f];
+  a = 0;
+  let u = 0;
+  for (let f = 0; f < h.length; f++)
+    if (a += h[f], a >= e / 2) {
+      u = f;
+      break;
+    }
+  return { median: s, deviation: u };
+}
+function w(t, n, o) {
+  const r = W(t), e = Z(t, n, o), c = new Uint8Array(t.length), a = new Uint8Array(t.length), s = new Uint8Array(t.length), h = Math.max(16, e.deviation * 2.5);
+  for (let u = 0; u < t.length; u++)
+    c[u] = t[u] > r ? 1 : 0, a[u] = t[u] <= r ? 1 : 0, s[u] = Math.abs(t[u] - e.median) >= h ? 1 : 0;
+  return { bright: c, dark: a, contrast: s };
+}
+function tt(t, n, o, r, e) {
+  const c = new Uint8Array(t.length), a = new Int32Array(t.length), s = [], h = r ? Math.max(64, t.length * 0.025) : Math.max(40, (n + o) * 0.06);
+  for (let u = 0; u < t.length; u++) {
+    if (!t[u] || c[u]) continue;
+    let f = 0, m = 0, M = 0, I = 0, d = n, y = o, b = 0, A = 0, i = 0;
+    const l = [], C = new Array(8), U = [
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0,
+      1 / 0,
+      -1 / 0
+    ];
+    for (a[m++] = u, c[u] = 1; f < m; ) {
+      const g = a[f++], p = g % n, x = Math.floor(g / n);
+      M++, d = Math.min(d, p), y = Math.min(y, x), b = Math.max(b, p), A = Math.max(A, x), (p === 0 || p === n - 1 || x === 0 || x === o - 1) && i++;
+      const S = [p + x, p + x, p - x, p - x, p, p, x, x];
+      for (let v = 0; v < 8; v++)
+        (v % 2 ? S[v] > U[v] : S[v] < U[v]) && (U[v] = S[v], C[v] = { x: p, y: x });
+      let N = !1;
+      for (let v = -1; v <= 1; v++)
+        for (let k = -1; k <= 1; k++) {
+          if (!k && !v) continue;
+          const z = p + k, D = x + v;
+          if (z < 0 || z >= n || D < 0 || D >= o) {
+            N = !0;
+            continue;
+          }
+          const q = D * n + z;
+          t[q] ? c[q] || (c[q] = 1, a[m++] = q) : N = !0;
+        }
+      if (N)
+        if (I++, l.length < 2048) l.push({ x: p, y: x });
+        else {
+          const v = (Math.imul(I, 2654435761) >>> 0) % I | 0;
+          v < l.length && (l[v] = { x: p, y: x });
+        }
+    }
+    const F = (b - d + 1) * (A - y + 1);
+    if (M >= h && F >= t.length * 0.055 && M < t.length * 0.985) {
+      for (const g of C) g && l.push(g);
+      s.push({ count: M, boundsArea: F, touches: i, boundary: l });
+    }
+  }
+  return s.sort(
+    (u, f) => f.boundsArea * Math.min(1, f.count / h) - u.boundsArea * Math.min(1, u.count / h)
+  ).slice(0, e);
+}
+const Q = (t, n, o) => (n.x - t.x) * (o.y - t.y) - (n.y - t.y) * (o.x - t.x);
+function nt(t) {
+  const n = [...t].sort((e, c) => e.x - c.x || e.y - c.y).filter(
+    (e, c, a) => !c || e.x !== a[c - 1].x || e.y !== a[c - 1].y
+  );
+  if (n.length <= 4) return n;
+  const o = [], r = [];
+  for (const e of n) {
+    for (; o.length >= 2 && Q(o.at(-2), o.at(-1), e) <= 0; )
+      o.pop();
+    o.push(e);
+  }
+  for (let e = n.length - 1; e >= 0; e--) {
+    const c = n[e];
+    for (; r.length >= 2 && Q(r.at(-2), r.at(-1), c) <= 0; )
+      r.pop();
+    r.push(c);
+  }
+  return o.pop(), r.pop(), [...o, ...r];
+}
+function et(t) {
+  const n = [...t];
+  for (; n.length > 4; ) {
+    let o = 0, r = 1 / 0;
+    for (let e = 0; e < n.length; e++) {
+      const c = n[(e + n.length - 1) % n.length], a = n[e], s = n[(e + 1) % n.length], h = Math.abs(Q(c, a, s));
+      h < r && (r = h, o = e);
+    }
+    n.splice(o, 1);
+  }
+  return n;
+}
+function H(t, n) {
+  const o = Math.abs(t - n) % Math.PI;
+  return Math.min(o, Math.PI - o);
+}
+function j(t, n) {
+  const o = Math.cos(t.theta), r = Math.sin(t.theta), e = Math.cos(n.theta), c = Math.sin(n.theta), a = o * c - r * e;
+  return Math.abs(a) < 0.08 ? null : {
+    x: (t.rho * c - r * n.rho) / a,
+    y: (o * n.rho - t.rho * e) / a
+  };
+}
+function ot(t, n, o, r) {
+  const e = [];
+  let c = 0;
+  for (let i = 1; i < r - 1; i++)
+    for (let l = 1; l < o - 1; l++)
+      if (!(t[i * o + l] < n))
+        if (c++, e.length < 5e3) e.push({ x: l, y: i });
+        else {
+          const C = (Math.imul(c, 2246822519) >>> 0) % c | 0;
+          C < e.length && (e[C] = { x: l, y: i });
+        }
+  if (e.length < 24) return [];
+  const a = 90, s = 2, h = Math.hypot(o, r), u = Math.ceil(h * 2 / s) + 1, f = new Uint16Array(a * u), m = new Float32Array(a), M = new Float32Array(a);
+  for (let i = 0; i < a; i++) {
+    const l = i * Math.PI / a;
+    m[i] = Math.cos(l), M[i] = Math.sin(l);
+  }
+  for (const i of e)
+    for (let l = 0; l < a; l++) {
+      const C = Math.round(
+        (i.x * m[l] + i.y * M[l] + h) / s
+      ), U = l * u + C;
+      f[U] < 65535 && f[U]++;
+    }
+  const I = Math.max(10, Math.round(Math.min(o, r) * 0.055)), d = [];
+  for (let i = 0; i < a; i++)
+    for (let l = 1; l < u - 1; l++) {
+      const C = f[i * u + l];
+      C < I || d.push({
+        theta: i * Math.PI / a,
+        rho: l * s - h,
+        votes: C
+      });
+    }
+  d.sort((i, l) => l.votes - i.votes);
+  const y = [];
+  for (const i of d)
+    if (!y.some(
+      (l) => H(i.theta, l.theta) < 4 * Math.PI / a && Math.abs(i.rho - l.rho) < s * 5
+    ) && (y.push(i), y.length >= 28))
+      break;
+  const b = [];
+  for (let i = 0; i < y.length; i++)
+    for (let l = i + 1; l < y.length; l++) {
+      const C = Math.abs(y[i].rho - y[l].rho), U = H(y[i].theta, y[l].theta);
+      U <= 16 * Math.PI / 180 && C >= Math.min(o, r) * 0.16 && b.push({
+        lines: [y[i], y[l]],
+        score: y[i].votes + y[l].votes - U * 180 / Math.PI
+      });
+    }
+  b.sort((i, l) => l.score - i.score);
+  const A = [];
+  for (let i = 0; i < Math.min(16, b.length); i++)
+    for (let l = i + 1; l < Math.min(16, b.length); l++) {
+      if (H(
+        b[i].lines[0].theta,
+        b[l].lines[0].theta
+      ) < 38 * Math.PI / 180) continue;
+      const [U, F] = b[i].lines, [g, p] = b[l].lines, x = [
+        j(U, g),
+        j(F, g),
+        j(F, p),
+        j(U, p)
+      ];
+      x.some(
+        (S) => !S || S.x < -o * 0.03 || S.x > o * 1.03 || S.y < -r * 0.03 || S.y > r * 1.03
+      ) || A.push({
+        points: x,
+        source: "hough-lines",
+        score: b[i].score + b[l].score
+      });
+    }
+  return A.sort((i, l) => l.score - i.score).slice(0, 20).map(({ points: i, source: l }) => ({ points: i, source: l }));
+}
+function rt(t) {
+  return t.length < 4 ? [] : [
+    (o) => o.x + o.y,
+    (o) => -(o.x - o.y),
+    (o) => -(o.x + o.y),
+    (o) => o.x - o.y
+  ].map(
+    (o) => t.reduce(
+      (r, e) => o(e) < o(r) ? e : r
+    )
+  );
+}
+function at(t, n, o) {
+  if (t.length !== 4 || new Set(t.map((s) => `${s.x},${s.y}`)).size !== 4)
+    return null;
+  const r = t.reduce(
+    (s, h) => ({
+      x: s.x + h.x / 4,
+      y: s.y + h.y / 4
+    }),
+    { x: 0, y: 0 }
+  );
+  let e = [...t].sort(
+    (s, h) => Math.atan2(s.y - r.y, s.x - r.x) - Math.atan2(h.y - r.y, h.x - r.x)
+  ), c = 0;
+  for (let s = 1; s < 4; s++)
+    e[s].x + e[s].y < e[c].x + e[c].y && (c = s);
+  e = [...e.slice(c), ...e.slice(0, c)], Q(e[0], e[1], e[2]) < 0 && (e = [e[0], e[3], e[2], e[1]]);
+  const a = e.map((s) => ({
+    x: P(s.x / Math.max(1, n - 1)),
+    y: P(s.y / Math.max(1, o - 1))
+  }));
+  try {
+    return _(a), a;
+  } catch {
+    return null;
+  }
+}
+function st(t) {
+  let n = 0;
+  for (let o = 0; o < 4; o++) {
+    const r = t[o], e = t[(o + 1) % 4];
+    n += r.x * e.y - e.x * r.y;
+  }
+  return Math.abs(n) / 2;
+}
+function L(t, n, o, r, e) {
+  const c = Math.max(0, Math.min(n - 1, Math.round(r))), a = Math.max(0, Math.min(o - 1, Math.round(e)));
+  return t[a * n + c];
+}
+function ct(t, n, o, r, e, c) {
+  const a = st(t);
+  if (a < 0.055 || a > 0.985) return null;
+  const s = t.map((g) => ({
+    x: g.x * (e - 1),
+    y: g.y * (c - 1)
+  })), h = s.map((g, p) => {
+    const x = s[(p + 1) % 4];
+    return {
+      dx: x.x - g.x,
+      dy: x.y - g.y,
+      length: Math.hypot(x.x - g.x, x.y - g.y)
+    };
+  }), u = Math.hypot(e, c), f = Math.min(...h.map((g) => g.length)) / u;
+  if (f < 0.055) return null;
+  let m = 0;
+  for (let g = 0; g < 4; g++) {
+    const p = s[(g + 3) % 4], x = s[g], S = s[(g + 1) % 4], N = p.x - x.x, v = p.y - x.y, k = S.x - x.x, z = S.y - x.y, D = Math.abs(
+      (N * k + v * z) / Math.max(1, Math.hypot(N, v) * Math.hypot(k, z))
+    );
+    m += 1 - P(D / 0.72);
+  }
+  m /= 4;
+  let M = 0, I = 0, d = 0, y = 0;
+  for (let g = 0; g < 4; g++) {
+    const p = s[g], x = h[g], S = Math.max(12, Math.min(180, Math.round(x.length / 2))), N = -x.dy / Math.max(1, x.length), v = x.dx / Math.max(1, x.length);
+    for (let k = 1; k < S; k++) {
+      const z = k / S, D = p.x + x.dx * z, q = p.y + x.dy * z;
+      let E = 0;
+      for (let $ = -2; $ <= 2; $++)
+        E = Math.max(
+          E,
+          L(
+            o,
+            e,
+            c,
+            D + N * $,
+            q + v * $
+          )
+        );
+      M += E >= r * 0.7 ? 1 : 0, I += P(E / Math.max(1, r * 1.8));
+      const X = L(
+        n,
+        e,
+        c,
+        D + N * 4,
+        q + v * 4
+      ), Y = L(
+        n,
+        e,
+        c,
+        D - N * 4,
+        q - v * 4
+      );
+      d += P(Math.abs(X - Y) / 48), y++;
+    }
+  }
+  const b = y ? 0.67 * (M / y) + 0.33 * (I / y) : 0;
+  d = y ? d / y : 0;
+  const A = P((a - 0.055) / 0.3) * P((0.985 - a) / 0.08), i = P((f - 0.055) / 0.18), l = 0.72 * m + 0.28 * i, C = t.reduce(
+    (g, p) => g + P(
+      Math.min(p.x, p.y, 1 - p.x, 1 - p.y) / 0.025
+    ),
+    0
+  ) / 4, F = (0.43 * b + 0.2 * d + 0.15 * A + 0.17 * l + 0.05 * i) * (0.56 + 0.44 * C);
+  return {
+    score: F,
+    confidence: P((F - 0.3) / 0.55),
+    coverage: a,
+    edgeSupport: b,
+    contrast: d,
+    rectangularity: l
+  };
+}
+function B(t, n, o, r, e, c, a) {
+  return {
+    engine: "scanfit-classical",
+    confidence: n,
+    candidateCount: o,
+    edgeThreshold: r,
+    edgeDensity: e,
+    durationMs: Math.max(0, V() - t),
+    coverage: c?.coverage ?? 0,
+    edgeSupport: c?.edgeSupport ?? 0,
+    contrast: c?.contrast ?? 0,
+    rectangularity: c?.rectangularity ?? 0,
+    fallbackReason: a
+  };
+}
+function it(t, n = {}) {
+  const o = V(), r = t.width, e = t.height;
+  if (!Number.isSafeInteger(r) || !Number.isSafeInteger(e) || r < 32 || e < 32 || t.data.length !== r * e * 4)
+    return {
+      corners: null,
+      confidence: 0,
+      diagnostics: B(
+        o,
+        0,
+        0,
+        0,
+        0,
+        void 0,
+        "invalid-image"
+      )
+    };
+  const c = G(T(t), r, e), a = J(c, r, e), s = K(
+    a.magnitude,
+    r,
+    e,
+    a.threshold
+  );
+  if (a.nonzero < t.width + t.height || s.strong < 8)
+    return {
+      corners: null,
+      confidence: 0,
+      diagnostics: B(
+        o,
+        0,
+        0,
+        a.threshold,
+        s.density,
+        void 0,
+        "uniform-image"
+      )
+    };
+  const h = w(c, r, e), u = [
+    {
+      binary: R(s.binary, r, e),
+      source: "edges",
+      filled: !1
+    },
+    { binary: h.bright, source: "bright-region", filled: !0 },
+    { binary: h.dark, source: "dark-region", filled: !0 },
+    { binary: h.contrast, source: "border-contrast", filled: !0 }
+  ], f = Math.max(
+    1,
+    Math.min(
+      16,
+      Number.isSafeInteger(n.maxComponents) ? n.maxComponents : 8
+    )
+  ), m = [];
+  m.push(
+    ...ot(
+      a.magnitude,
+      a.threshold,
+      r,
+      e
+    )
+  );
+  for (const A of u)
+    for (const i of tt(
+      A.binary,
+      r,
+      e,
+      A.filled,
+      f
+    )) {
+      if (i.touches > i.count * 0.45 && i.boundsArea > r * e * 0.9)
+        continue;
+      const l = nt(i.boundary);
+      l.length >= 4 && (m.push({ points: et(l), source: A.source }), m.push({ points: rt(l), source: A.source }));
+    }
+  const M = Math.max(
+    1,
+    Math.min(
+      64,
+      Number.isSafeInteger(n.maxCandidates) ? n.maxCandidates : 24
+    )
+  ), I = /* @__PURE__ */ new Map();
+  for (const A of m) {
+    const i = at(A.points, r, e);
+    if (!i) continue;
+    const l = i.map(
+      (C) => `${Math.round(C.x * 40)},${Math.round(C.y * 40)}`
+    ).join(";");
+    if (I.has(l) || I.set(l, { quad: i, source: A.source }), I.size >= M) break;
+  }
+  let d;
+  for (const A of I.values()) {
+    const i = ct(
+      A.quad,
+      c,
+      a.magnitude,
+      a.threshold,
+      r,
+      e
+    );
+    i && (!d || i.score > d.metrics.score) && (d = { ...A, metrics: i });
+  }
+  const y = d?.metrics.confidence ?? 0, b = P(
+    Number.isFinite(n.minConfidence) ? n.minConfidence : O,
+    0.15,
+    0.95
+  );
+  return !d || y < b || d.metrics.edgeSupport < 0.28 ? {
+    corners: null,
+    confidence: y,
+    diagnostics: B(
+      o,
+      y,
+      I.size,
+      a.threshold,
+      s.density,
+      d?.metrics,
+      d ? "low-confidence" : "no-candidate"
+    )
+  } : {
+    corners: d.quad,
+    confidence: y,
+    diagnostics: {
+      ...B(
+        o,
+        y,
+        I.size,
+        a.threshold,
+        s.density,
+        d.metrics
+      ),
+      source: d.source
+    }
+  };
+}
+function ft(t = {}) {
+  return {
+    async detect(n) {
+      return it(n, t);
+    }
+  };
+}
+export {
+  ft as createDetector
+};