@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/aztec/detector.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Aztec image detection.
  *
@@ -47,109 +46,118 @@
  *
  * @module aztec/detector
  */
-
 import { NotFoundError } from '../core/errors.js';
 import { sampleQuad } from '../image/grid-sampler.js';
 import { decodeAztec } from './decoder.js';
-
 /** @typedef {{x:number, y:number}} Point */
 /** @typedef {{corners: Point[], dimension: number, compact: boolean, moduleSize: number, matrix: import('../core/bit-matrix.js').BitMatrix}} Detection */
-
 // Compact: 11 + 4 layers. Full symbols add reference-grid rows/columns every
 // 15 modules measured from their central 14-module base, not every 15 layers.
 const DIMENSIONS = [
-  ...[1, 2, 3, 4].map((layers) => ({ compact: true, dimension: 11 + 4 * layers })),
-  ...Array.from({ length: 32 }, (_, index) => {
-    const layers = index + 1;
-    return { compact: false, dimension: 15 + 4 * layers + 2 * Math.floor((2 * layers + 6) / 15) };
-  }),
+    ...[1, 2, 3, 4].map((layers) => ({ compact: true, dimension: 11 + 4 * layers })),
+    ...Array.from({ length: 32 }, (_, index) => {
+        const layers = index + 1;
+        return { compact: false, dimension: 15 + 4 * layers + 2 * Math.floor((2 * layers + 6) / 15) };
+    }),
 ];
-
 function pixel(image, x, y) {
-  const ix = Math.round(x);
-  const iy = Math.round(y);
-  return ix >= 0 && iy >= 0 && ix < image.width && iy < image.height && image.get(ix, iy);
+    const ix = Math.round(x);
+    const iy = Math.round(y);
+    return ix >= 0 && iy >= 0 && ix < image.width && iy < image.height && image.get(ix, iy);
 }
-
 /** Connected components of either polarity, retaining only plausible modules. */
 function components(image, value) {
-  const seen = new Uint8Array(image.width * image.height);
-  const out = [];
-  const maximumArea = Math.max(4, Math.floor(image.width * image.height * 0.08));
-  for (let y = 0; y < image.height; y++) for (let x = 0; x < image.width; x++) {
-    const start = y * image.width + x;
-    if (seen[start] || image.get(x, y) !== value) continue;
-    const xs = [x];
-    const ys = [y];
-    seen[start] = 1;
-    let head = 0;
-    let minX = x; let maxX = x; let minY = y; let maxY = y;
-    while (head < xs.length) {
-      const px = xs[head]; const py = ys[head++];
-      if (px < minX) minX = px; if (px > maxX) maxX = px;
-      if (py < minY) minY = py; if (py > maxY) maxY = py;
-      for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
-        if (nx < 0 || ny < 0 || nx >= image.width || ny >= image.height) continue;
-        const at = ny * image.width + nx;
-        if (!seen[at] && image.get(nx, ny) === value) {
-          seen[at] = 1; xs.push(nx); ys.push(ny);
+    const seen = new Uint8Array(image.width * image.height);
+    const out = [];
+    const maximumArea = Math.max(4, Math.floor(image.width * image.height * 0.08));
+    for (let y = 0; y < image.height; y++)
+        for (let x = 0; x < image.width; x++) {
+            const start = y * image.width + x;
+            if (seen[start] || image.get(x, y) !== value)
+                continue;
+            const xs = [x];
+            const ys = [y];
+            seen[start] = 1;
+            let head = 0;
+            let minX = x;
+            let maxX = x;
+            let minY = y;
+            let maxY = y;
+            while (head < xs.length) {
+                const px = xs[head];
+                const py = ys[head++];
+                if (px < minX)
+                    minX = px;
+                if (px > maxX)
+                    maxX = px;
+                if (py < minY)
+                    minY = py;
+                if (py > maxY)
+                    maxY = py;
+                for (const [nx, ny] of [[px - 1, py], [px + 1, py], [px, py - 1], [px, py + 1]]) {
+                    if (nx < 0 || ny < 0 || nx >= image.width || ny >= image.height)
+                        continue;
+                    const at = ny * image.width + nx;
+                    if (!seen[at] && image.get(nx, ny) === value) {
+                        seen[at] = 1;
+                        xs.push(nx);
+                        ys.push(ny);
+                    }
+                }
+            }
+            const width = maxX - minX + 1;
+            const height = maxY - minY + 1;
+            const area = width * height;
+            // The central module is solid and approximately square. This filter is
+            // intentionally permissive because a rotated raster module is diamond-ish.
+            if (xs.length <= maximumArea && Math.abs(width - height) <= Math.max(1, Math.ceil(Math.max(width, height) * 0.35)) &&
+                xs.length >= area * 0.45) {
+                out.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width, height, pixels: xs.length });
+            }
         }
-      }
-    }
-    const width = maxX - minX + 1;
-    const height = maxY - minY + 1;
-    const area = width * height;
-    // The central module is solid and approximately square. This filter is
-    // intentionally permissive because a rotated raster module is diamond-ish.
-    if (xs.length <= maximumArea && Math.abs(width - height) <= Math.max(1, Math.ceil(Math.max(width, height) * 0.35)) &&
-      xs.length >= area * 0.45) {
-      out.push({ x: (minX + maxX) / 2, y: (minY + maxY) / 2, width, height, pixels: xs.length });
-    }
-  }
-  return out.sort((a, b) => b.pixels - a.pixels).slice(0, 2000);
+    return out.sort((a, b) => b.pixels - a.pixels).slice(0, 2000);
 }
-
 function expectedDark(ring, inverted) {
-  return inverted ? (ring & 1) === 1 : (ring & 1) === 0;
+    return inverted ? (ring & 1) === 1 : (ring & 1) === 0;
 }
-
 /** Score one square bull's-eye at an angle and a candidate module pitch. */
 function ringScore(image, centre, pitch, angle, inverted, rings) {
-  const cos = Math.cos(angle);
-  const sin = Math.sin(angle);
-  let correct = 0;
-  let total = 0;
-  for (let ring = 0; ring < rings; ring++) {
-    const wanted = expectedDark(ring, inverted);
-    for (let j = -ring; j <= ring; j++) for (let i = -ring; i <= ring; i++) {
-      if (ring && Math.abs(i) !== ring && Math.abs(j) !== ring) continue;
-      const x = centre.x + (i * cos - j * sin) * pitch;
-      const y = centre.y + (i * sin + j * cos) * pitch;
-      if (pixel(image, x, y) === wanted) correct++;
-      total++;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    let correct = 0;
+    let total = 0;
+    for (let ring = 0; ring < rings; ring++) {
+        const wanted = expectedDark(ring, inverted);
+        for (let j = -ring; j <= ring; j++)
+            for (let i = -ring; i <= ring; i++) {
+                if (ring && Math.abs(i) !== ring && Math.abs(j) !== ring)
+                    continue;
+                const x = centre.x + (i * cos - j * sin) * pitch;
+                const y = centre.y + (i * sin + j * cos) * pitch;
+                if (pixel(image, x, y) === wanted)
+                    correct++;
+                total++;
+            }
     }
-  }
-  return correct / total;
+    return correct / total;
 }
-
 function rotateCorners(corners, turn) {
-  return corners.slice(turn).concat(corners.slice(0, turn));
+    return corners.slice(turn).concat(corners.slice(0, turn));
 }
-
 function invert(matrix) {
-  const out = matrix.clone();
-  for (let y = 0; y < out.height; y++) for (let x = 0; x < out.width; x++) out.flip(x, y);
-  return out;
+    const out = matrix.clone();
+    for (let y = 0; y < out.height; y++)
+        for (let x = 0; x < out.width; x++)
+            out.flip(x, y);
+    return out;
 }
-
 function cornersFor(centre, pitch, angle, dimension) {
-  const half = dimension * pitch / 2;
-  const cos = Math.cos(angle);
-  const sin = Math.sin(angle);
-  const point = (x, y) => ({ x: centre.x + x * cos - y * sin, y: centre.y + x * sin + y * cos });
-  return [point(-half, -half), point(half, -half), point(half, half), point(-half, half)];
+    const half = dimension * pitch / 2;
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    const point = (x, y) => ({ x: centre.x + x * cos - y * sin, y: centre.y + x * sin + y * cos });
+    return [point(-half, -half), point(half, -half), point(half, half), point(-half, half)];
 }
-
 /**
  * Find an Aztec symbol in a binarized image.
  *
@@ -161,53 +169,62 @@ function cornersFor(centre, pitch, angle, dimension) {
  * @returns {Detection | null}
  */
 export function detectAztec(binaryImage) {
-  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
-    throw new NotFoundError('detectAztec: no image supplied');
-  }
-  const candidates = [];
-  for (const inverted of [false, true]) {
-    for (const core of components(binaryImage, !inverted)) {
-      // A non-rotated one-module component directly gives its pitch. For
-      // rotated modules its bounding box grows by |sin| + |cos|, compensated
-      // below for every tested angle.
-      for (let degrees = 0; degrees < 180; degrees += 4) {
-        const angle = degrees * Math.PI / 180;
-        const scale = Math.abs(Math.cos(angle)) + Math.abs(Math.sin(angle));
-        const pitch = ((core.width + core.height) / 2) / scale;
-        if (pitch < 0.8) continue;
-        // Test Full first: its seven rings also exclude Compact candidates.
-        const fullScore = ringScore(binaryImage, core, pitch, angle, inverted, 7);
-        const rings = fullScore >= 0.88 ? 7 : 5;
-        const score = rings === 7 ? fullScore : ringScore(binaryImage, core, pitch, angle, inverted, 5);
-        if (score < 0.91) continue;
-        const symbolKinds = rings === 7 ? DIMENSIONS.filter((item) => !item.compact) : DIMENSIONS.filter((item) => item.compact);
-        for (const kind of symbolKinds) {
-          const baseCorners = cornersFor(core, pitch, angle, kind.dimension);
-          for (let turn = 0; turn < 4; turn++) {
-            const corners = rotateCorners(baseCorners, turn);
-            let matrix;
-            try { matrix = sampleQuad(binaryImage, kind.dimension, corners); } catch (e) { continue; }
-            if (inverted) matrix = invert(matrix);
-            try {
-              // The decoder verifies the mode-message ECC and exact geometry.
-              // We do not expose its result here so callers can use pure
-              // detection without treating payload decoding as an API contract.
-              decodeAztec(matrix);
-              candidates.push({ corners, dimension: kind.dimension, compact: kind.compact,
-                moduleSize: pitch, matrix, score });
-            } catch (e) { /* Not an Aztec mode message at this dimension. */ }
-          }
+    if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+        throw new NotFoundError('detectAztec: no image supplied');
+    }
+    const candidates = [];
+    for (const inverted of [false, true]) {
+        for (const core of components(binaryImage, !inverted)) {
+            // A non-rotated one-module component directly gives its pitch. For
+            // rotated modules its bounding box grows by |sin| + |cos|, compensated
+            // below for every tested angle.
+            for (let degrees = 0; degrees < 180; degrees += 4) {
+                const angle = degrees * Math.PI / 180;
+                const scale = Math.abs(Math.cos(angle)) + Math.abs(Math.sin(angle));
+                const pitch = ((core.width + core.height) / 2) / scale;
+                if (pitch < 0.8)
+                    continue;
+                // Test Full first: its seven rings also exclude Compact candidates.
+                const fullScore = ringScore(binaryImage, core, pitch, angle, inverted, 7);
+                const rings = fullScore >= 0.88 ? 7 : 5;
+                const score = rings === 7 ? fullScore : ringScore(binaryImage, core, pitch, angle, inverted, 5);
+                if (score < 0.91)
+                    continue;
+                const symbolKinds = rings === 7 ? DIMENSIONS.filter((item) => !item.compact) : DIMENSIONS.filter((item) => item.compact);
+                for (const kind of symbolKinds) {
+                    const baseCorners = cornersFor(core, pitch, angle, kind.dimension);
+                    for (let turn = 0; turn < 4; turn++) {
+                        const corners = rotateCorners(baseCorners, turn);
+                        let matrix;
+                        try {
+                            matrix = sampleQuad(binaryImage, kind.dimension, corners);
+                        }
+                        catch (e) {
+                            continue;
+                        }
+                        if (inverted)
+                            matrix = invert(matrix);
+                        try {
+                            // The decoder verifies the mode-message ECC and exact geometry.
+                            // We do not expose its result here so callers can use pure
+                            // detection without treating payload decoding as an API contract.
+                            decodeAztec(matrix);
+                            candidates.push({ corners, dimension: kind.dimension, compact: kind.compact,
+                                moduleSize: pitch, matrix, score });
+                        }
+                        catch (e) { /* Not an Aztec mode message at this dimension. */ }
+                    }
+                }
+            }
         }
-      }
     }
-  }
-  candidates.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
-  const best = candidates[0];
-  if (!best) return null;
-  delete best.score;
-  return best;
+    candidates.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
+    const best = candidates[0];
+    if (!best)
+        return null;
+    delete best.score;
+    return best;
 }
-
 /**
  * Detect then decode an Aztec symbol. Detection failure is a normal result for
  * images without an Aztec code, therefore invalid candidates return null.
@@ -216,9 +233,19 @@ export function detectAztec(binaryImage) {
  * @returns {(import('./decoder.js').DecodeResult & {corners: Point[]}) | null}
  */
 export function detectAndDecodeAztec(binaryImage) {
-  let detection;
-  try { detection = detectAztec(binaryImage); } catch (e) { return null; }
-  if (!detection) return null;
-  try { return Object.assign({ corners: detection.corners }, decodeAztec(detection.matrix)); }
-  catch (e) { return null; }
+    let detection;
+    try {
+        detection = detectAztec(binaryImage);
+    }
+    catch (e) {
+        return null;
+    }
+    if (!detection)
+        return null;
+    try {
+        return Object.assign({ corners: detection.corners }, decodeAztec(detection.matrix));
+    }
+    catch (e) {
+        return null;
+    }
 }