@sythos/js_barcode_universal 1.5.8 → 1.5.9

package/src/js/datamatrix/detector.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Data Matrix ECC 200 detection in a binarized image.
  *
@@ -44,104 +43,111 @@
  *
  * @module datamatrix/detector
  */
-
 import { NotFoundError } from '../core/errors.js';
 import { sampleGrid, sampleQuad } from '../image/grid-sampler.js';
 import { PerspectiveTransform } from '../image/perspective.js';
 import { decodeDataMatrix } from './decoder.js';
-
 // ECC 200 dimensions.  DMRE is deliberately not included: it uses a separate
 // size table and is not part of the original ECC 200 family implemented here.
 const SIZES = [
-  [10, 10], [12, 12], [14, 14], [16, 16], [18, 18], [20, 20], [22, 22], [24, 24], [26, 26],
-  [32, 32], [36, 36], [40, 40], [44, 44], [48, 48], [52, 52], [64, 64], [72, 72], [80, 80],
-  [88, 88], [96, 96], [104, 104], [120, 120], [132, 132], [144, 144],
-  [18, 8], [32, 8], [26, 12], [36, 12], [36, 16], [48, 16],
+    [10, 10], [12, 12], [14, 14], [16, 16], [18, 18], [20, 20], [22, 22], [24, 24], [26, 26],
+    [32, 32], [36, 36], [40, 40], [44, 44], [48, 48], [52, 52], [64, 64], [72, 72], [80, 80],
+    [88, 88], [96, 96], [104, 104], [120, 120], [132, 132], [144, 144],
+    [18, 8], [32, 8], [26, 12], [36, 12], [36, 16], [48, 16],
 ];
-
 /** @typedef {{x:number, y:number}} Point */
 /** @typedef {{corners: Point[], dimension: number, width: number, height: number, moduleSize: number, matrix: import('../core/bit-matrix.js').BitMatrix}} Detection */
-
 function dark(image, x, y) {
-  return image.get(Math.max(0, Math.min(image.width - 1, Math.round(x))),
-    Math.max(0, Math.min(image.height - 1, Math.round(y))));
+    return image.get(Math.max(0, Math.min(image.width - 1, Math.round(x))), Math.max(0, Math.min(image.height - 1, Math.round(y))));
 }
-
 /** Return components which are large enough to plausibly contain a symbol. */
 function components(image) {
-  const seen = new Uint8Array(image.width * image.height);
-  const out = [];
-  const push = (x, y, xs, ys) => { xs.push(x); ys.push(y); };
-  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)) continue;
-    const xs = [x], ys = [y]; seen[start] = 1;
-    let head = 0, minX = x, maxX = x, minY = y, maxY = y;
-    while (head < xs.length) {
-      const px = xs[head], 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)) { seen[at] = 1; push(nx, ny, xs, ys); }
-      }
-    }
-    if (maxX - minX >= 7 && maxY - minY >= 7) out.push({ minX, minY, maxX, maxY, pixels: xs.length });
-  }
-  return out.sort((a, b) => b.pixels - a.pixels).slice(0, 40);
+    const seen = new Uint8Array(image.width * image.height);
+    const out = [];
+    const push = (x, y, xs, ys) => { xs.push(x); ys.push(y); };
+    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))
+                continue;
+            const xs = [x], ys = [y];
+            seen[start] = 1;
+            let head = 0, minX = x, maxX = x, minY = y, maxY = y;
+            while (head < xs.length) {
+                const px = xs[head], 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)) {
+                        seen[at] = 1;
+                        push(nx, ny, xs, ys);
+                    }
+                }
+            }
+            if (maxX - minX >= 7 && maxY - minY >= 7)
+                out.push({ minX, minY, maxX, maxY, pixels: xs.length });
+        }
+    return out.sort((a, b) => b.pixels - a.pixels).slice(0, 40);
 }
-
 /** Sample a physical edge at module centres. */
 function edge(image, a, b, count) {
-  const values = [];
-  for (let i = 0; i < count; i++) {
-    const t = (i + 0.5) / count;
-    values.push(dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t));
-  }
-  return values;
+    const values = [];
+    for (let i = 0; i < count; i++) {
+        const t = (i + 0.5) / count;
+        values.push(dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t));
+    }
+    return values;
 }
-
 function solidScore(values) {
-  let n = 0; for (const value of values) if (value) n++;
-  return n / values.length;
+    let n = 0;
+    for (const value of values)
+        if (value)
+            n++;
+    return n / values.length;
 }
-
 function clockScore(values, startsDark) {
-  let n = 0;
-  for (let i = 0; i < values.length; i++) if (values[i] === ((i & 1) === 0 ? startsDark : !startsDark)) n++;
-  return n / values.length;
+    let n = 0;
+    for (let i = 0; i < values.length; i++)
+        if (values[i] === ((i & 1) === 0 ? startsDark : !startsDark))
+            n++;
+    return n / values.length;
 }
-
 /** Count light/dark changes along a physical edge at approximately one-pixel intervals. */
 function edgeTransitions(image, a, b) {
-  const steps = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y)));
-  let previous = dark(image, a.x, a.y);
-  let changes = 0;
-  for (let i = 1; i <= steps; i++) {
-    const t = i / steps;
-    const value = dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
-    if (value !== previous) changes++;
-    previous = value;
-  }
-  return changes;
+    const steps = Math.max(1, Math.ceil(Math.hypot(b.x - a.x, b.y - a.y)));
+    let previous = dark(image, a.x, a.y);
+    let changes = 0;
+    for (let i = 1; i <= steps; i++) {
+        const t = i / steps;
+        const value = dark(image, a.x + (b.x - a.x) * t, a.y + (b.y - a.y) * t);
+        if (value !== previous)
+            changes++;
+        previous = value;
+    }
+    return changes;
 }
-
 /** Reject a smaller harmonic whose module-centre samples happen to alternate. */
 function transitionCountFits(observed, modules) {
-  const expected = modules - 1;
-  const tolerance = Math.max(2, Math.floor(expected * 0.08));
-  return Math.abs(observed - expected) <= tolerance;
+    const expected = modules - 1;
+    const tolerance = Math.max(2, Math.floor(expected * 0.08));
+    return Math.abs(observed - expected) <= tolerance;
 }
-
 function sample(image, width, height, corners, voting) {
-  if (width === height) return sampleQuad(image, width, corners, voting);
-  const [tl, tr, br, bl] = corners;
-  const transform = PerspectiveTransform.quadToQuad(0, 0, width, 0, width, height, 0, height,
-    tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y);
-  return sampleGrid(image, width, height, transform);
+    if (width === height)
+        return sampleQuad(image, width, corners, voting);
+    const [tl, tr, br, bl] = corners;
+    const transform = PerspectiveTransform.quadToQuad(0, 0, width, 0, width, height, 0, height, tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y);
+    return sampleGrid(image, width, height, transform);
 }
-
 /**
  * Find Data Matrix symbols in a binarized image.
  *
@@ -149,61 +155,70 @@ function sample(image, width, height, corners, voting) {
  * @returns {Detection | null} The strongest candidate, or null when absent.
  */
 export function detectDataMatrix(binaryImage) {
-  if (!binaryImage || !binaryImage.width || !binaryImage.height) {
-    throw new NotFoundError('detectDataMatrix: no image supplied');
-  }
-  const detections = [];
-  const used = new Set();
-  for (const box of components(binaryImage)) {
-    const base = [
-      { x: box.minX, y: box.minY }, { x: box.maxX + 1, y: box.minY },
-      { x: box.maxX + 1, y: box.maxY + 1 }, { x: box.minX, y: box.maxY + 1 },
-    ];
-    // Profile the actual ink, rather than the outer sampling quadrilateral:
-    // its far x/y boundary lies one pixel beyond the last dark pixel.
-    const ink = [
-      { x: box.minX, y: box.minY }, { x: box.maxX, y: box.minY },
-      { x: box.maxX, y: box.maxY }, { x: box.minX, y: box.maxY },
-    ];
-    for (const [w, h] of SIZES) for (let turn = 0; turn < 4; turn++) {
-      // A 90 degree turn swaps physical width and height.
-      const physicalW = (turn & 1) ? h : w, physicalH = (turn & 1) ? w : h;
-      const pitchX = (box.maxX - box.minX + 1) / physicalW;
-      const pitchY = (box.maxY - box.minY + 1) / physicalH;
-      if (Math.min(pitchX, pitchY) < 1 || Math.abs(pitchX - pitchY) > Math.max(pitchX, pitchY) * 0.22) continue;
-      const corners = base.slice(turn).concat(base.slice(0, turn));
-      const profile = ink.slice(turn).concat(ink.slice(0, turn));
-      // Canonical edge order: top clock, right clock, bottom solid, left solid.
-      const top = edge(binaryImage, profile[0], profile[1], w);
-      const right = edge(binaryImage, profile[1], profile[2], h);
-      const bottom = edge(binaryImage, profile[2], profile[3], w);
-      const left = edge(binaryImage, profile[3], profile[0], h);
-      // Sampling only the proposed module centres aliases exact harmonics: an
-      // 80-module clock border, for example, can look like a perfect 16-module
-      // border.  Count transitions at image-pixel resolution as an independent
-      // dimension measurement before accepting the candidate.
-      if (!transitionCountFits(edgeTransitions(binaryImage, profile[0], profile[1]), w) ||
-          !transitionCountFits(edgeTransitions(binaryImage, profile[1], profile[2]), h)) continue;
-      // The top clock starts dark at the solid left border.  The right clock is
-      // anchored dark at the solid bottom border instead, so its top phase
-      // depends on the symbol height (all ECC 200 heights are even and
-      // therefore start light).
-      const score = (clockScore(top, true) + clockScore(right, (h & 1) === 1) +
-        solidScore(bottom) + solidScore(left)) / 4;
-      if (score < 0.88) continue;
-      const key = `${box.minX},${box.minY},${box.maxX},${box.maxY}`;
-      if (used.has(key)) continue;
-      let matrix;
-      try { matrix = sample(binaryImage, w, h, corners, false); } catch (e) { continue; }
-      used.add(key);
-      detections.push({ corners, dimension: w === h ? w : 0, width: w, height: h,
-        moduleSize: (pitchX + pitchY) / 2, matrix, score });
+    if (!binaryImage || !binaryImage.width || !binaryImage.height) {
+        throw new NotFoundError('detectDataMatrix: no image supplied');
+    }
+    const detections = [];
+    const used = new Set();
+    for (const box of components(binaryImage)) {
+        const base = [
+            { x: box.minX, y: box.minY }, { x: box.maxX + 1, y: box.minY },
+            { x: box.maxX + 1, y: box.maxY + 1 }, { x: box.minX, y: box.maxY + 1 },
+        ];
+        // Profile the actual ink, rather than the outer sampling quadrilateral:
+        // its far x/y boundary lies one pixel beyond the last dark pixel.
+        const ink = [
+            { x: box.minX, y: box.minY }, { x: box.maxX, y: box.minY },
+            { x: box.maxX, y: box.maxY }, { x: box.minX, y: box.maxY },
+        ];
+        for (const [w, h] of SIZES)
+            for (let turn = 0; turn < 4; turn++) {
+                // A 90 degree turn swaps physical width and height.
+                const physicalW = (turn & 1) ? h : w, physicalH = (turn & 1) ? w : h;
+                const pitchX = (box.maxX - box.minX + 1) / physicalW;
+                const pitchY = (box.maxY - box.minY + 1) / physicalH;
+                if (Math.min(pitchX, pitchY) < 1 || Math.abs(pitchX - pitchY) > Math.max(pitchX, pitchY) * 0.22)
+                    continue;
+                const corners = base.slice(turn).concat(base.slice(0, turn));
+                const profile = ink.slice(turn).concat(ink.slice(0, turn));
+                // Canonical edge order: top clock, right clock, bottom solid, left solid.
+                const top = edge(binaryImage, profile[0], profile[1], w);
+                const right = edge(binaryImage, profile[1], profile[2], h);
+                const bottom = edge(binaryImage, profile[2], profile[3], w);
+                const left = edge(binaryImage, profile[3], profile[0], h);
+                // Sampling only the proposed module centres aliases exact harmonics: an
+                // 80-module clock border, for example, can look like a perfect 16-module
+                // border.  Count transitions at image-pixel resolution as an independent
+                // dimension measurement before accepting the candidate.
+                if (!transitionCountFits(edgeTransitions(binaryImage, profile[0], profile[1]), w) ||
+                    !transitionCountFits(edgeTransitions(binaryImage, profile[1], profile[2]), h))
+                    continue;
+                // The top clock starts dark at the solid left border.  The right clock is
+                // anchored dark at the solid bottom border instead, so its top phase
+                // depends on the symbol height (all ECC 200 heights are even and
+                // therefore start light).
+                const score = (clockScore(top, true) + clockScore(right, (h & 1) === 1) +
+                    solidScore(bottom) + solidScore(left)) / 4;
+                if (score < 0.88)
+                    continue;
+                const key = `${box.minX},${box.minY},${box.maxX},${box.maxY}`;
+                if (used.has(key))
+                    continue;
+                let matrix;
+                try {
+                    matrix = sample(binaryImage, w, h, corners, false);
+                }
+                catch (e) {
+                    continue;
+                }
+                used.add(key);
+                detections.push({ corners, dimension: w === h ? w : 0, width: w, height: h,
+                    moduleSize: (pitchX + pitchY) / 2, matrix, score });
+            }
     }
-  }
-  detections.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
-  return detections[0] ?? null;
+    detections.sort((a, b) => b.score - a.score || b.moduleSize - a.moduleSize);
+    return detections[0] ?? null;
 }
-
 /**
  * Detect and decode Data Matrix symbols.  Detection failure is normal for an
  * image without a symbol, so candidates that cannot decode are skipped.
@@ -212,14 +227,28 @@ export function detectDataMatrix(binaryImage) {
  * @returns {(import('./decoder.js').DecodeResult & {corners: Point[]}) | null}
  */
 export function detectAndDecodeDataMatrix(binaryImage) {
-  let detection;
-  try { detection = detectDataMatrix(binaryImage); } catch (e) { return null; }
-  if (!detection) return null;
-  for (const voting of [false, true]) {
-    let matrix = detection.matrix;
-    try { if (voting) matrix = sample(binaryImage, detection.width, detection.height, detection.corners, true); } catch (e) { continue; }
-    try { return Object.assign({ corners: detection.corners }, decodeDataMatrix(matrix)); }
-    catch (e) { /* A geometric candidate is not necessarily a symbol. */ }
-  }
-  return null;
+    let detection;
+    try {
+        detection = detectDataMatrix(binaryImage);
+    }
+    catch (e) {
+        return null;
+    }
+    if (!detection)
+        return null;
+    for (const voting of [false, true]) {
+        let matrix = detection.matrix;
+        try {
+            if (voting)
+                matrix = sample(binaryImage, detection.width, detection.height, detection.corners, true);
+        }
+        catch (e) {
+            continue;
+        }
+        try {
+            return Object.assign({ corners: detection.corners }, decodeDataMatrix(matrix));
+        }
+        catch (e) { /* A geometric candidate is not necessarily a symbol. */ }
+    }
+    return null;
 }