@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/image/binarizer.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Greyscale to black-and-white.
  *
@@ -46,17 +45,13 @@
  *
  * @module image/binarizer
  */
-
 import { BitMatrix } from '../core/bit-matrix.js';
 import { NotFoundError } from '../core/errors.js';
-
 /** Side of a block, in pixels. */
 const BLOCK = 8;
 const BLOCK_SHIFT = 3;
-
 /** Below this spread, a block is treated as uniform rather than as edges. */
 const MIN_DYNAMIC_RANGE = 24;
-
 /**
  * One threshold for the entire image, chosen from the luminance histogram.
  *
@@ -68,74 +63,70 @@ const MIN_DYNAMIC_RANGE = 24;
  * @returns {BitMatrix} Set bit = dark module.
  */
 export function binarizeGlobal(source) {
-  const { grey, width, height } = source;
-  const buckets = new Int32Array(32);
-  for (let i = 0; i < grey.length; i++) buckets[grey[i] >> 3]++;
-
-  const threshold = pickThreshold(buckets);
-  const out = new BitMatrix(width, height);
-  for (let y = 0; y < height; y++) {
-    const base = y * width;
-    for (let x = 0; x < width; x++) {
-      if (grey[base + x] < threshold) out.set(x, y);
+    const { grey, width, height } = source;
+    const buckets = new Int32Array(32);
+    for (let i = 0; i < grey.length; i++)
+        buckets[grey[i] >> 3]++;
+    const threshold = pickThreshold(buckets);
+    const out = new BitMatrix(width, height);
+    for (let y = 0; y < height; y++) {
+        const base = y * width;
+        for (let x = 0; x < width; x++) {
+            if (grey[base + x] < threshold)
+                out.set(x, y);
+        }
     }
-  }
-  return out;
+    return out;
 }
-
 /**
  * @param {Int32Array} buckets
  * @returns {number} Threshold in 0-255.
  */
 function pickThreshold(buckets) {
-  const n = buckets.length;
-
-  let firstPeak = 0, firstPeakSize = 0;
-  for (let i = 0; i < n; i++) {
-    if (buckets[i] > firstPeakSize) {
-      firstPeakSize = buckets[i];
-      firstPeak = i;
+    const n = buckets.length;
+    let firstPeak = 0, firstPeakSize = 0;
+    for (let i = 0; i < n; i++) {
+        if (buckets[i] > firstPeakSize) {
+            firstPeakSize = buckets[i];
+            firstPeak = i;
+        }
     }
-  }
-
-  // Score candidates by population scaled by squared distance from the first
-  // peak: the second peak must be both populous and clearly separated.
-  let secondPeak = 0, secondScore = 0;
-  for (let i = 0; i < n; i++) {
-    const d = i - firstPeak;
-    const score = buckets[i] * d * d;
-    if (score > secondScore) {
-      secondScore = score;
-      secondPeak = i;
+    // Score candidates by population scaled by squared distance from the first
+    // peak: the second peak must be both populous and clearly separated.
+    let secondPeak = 0, secondScore = 0;
+    for (let i = 0; i < n; i++) {
+        const d = i - firstPeak;
+        const score = buckets[i] * d * d;
+        if (score > secondScore) {
+            secondScore = score;
+            secondPeak = i;
+        }
+    }
+    let low = Math.min(firstPeak, secondPeak);
+    let high = Math.max(firstPeak, secondPeak);
+    if (high - low <= n >> 4) {
+        // Effectively unimodal — a blank region, or an image with no ink. Fall
+        // back to the midpoint of the occupied range rather than inventing edges.
+        let lo = 0, hi = n - 1;
+        while (lo < n && buckets[lo] === 0)
+            lo++;
+        while (hi > 0 && buckets[hi] === 0)
+            hi--;
+        return (((lo + hi) >> 1) << 3) + 4;
     }
-  }
-
-  let low = Math.min(firstPeak, secondPeak);
-  let high = Math.max(firstPeak, secondPeak);
-
-  if (high - low <= n >> 4) {
-    // Effectively unimodal — a blank region, or an image with no ink. Fall
-    // back to the midpoint of the occupied range rather than inventing edges.
-    let lo = 0, hi = n - 1;
-    while (lo < n && buckets[lo] === 0) lo++;
-    while (hi > 0 && buckets[hi] === 0) hi--;
-    return (((lo + hi) >> 1) << 3) + 4;
-  }
-
-  // Deepest valley between the peaks, biased toward the middle.
-  let valley = low, valleyScore = -1;
-  for (let i = low + 1; i < high; i++) {
-    const fromLow = i - low;
-    const fromHigh = high - i;
-    const score = fromLow * fromHigh * (firstPeakSize - buckets[i]);
-    if (score > valleyScore) {
-      valleyScore = score;
-      valley = i;
+    // Deepest valley between the peaks, biased toward the middle.
+    let valley = low, valleyScore = -1;
+    for (let i = low + 1; i < high; i++) {
+        const fromLow = i - low;
+        const fromHigh = high - i;
+        const score = fromLow * fromHigh * (firstPeakSize - buckets[i]);
+        if (score > valleyScore) {
+            valleyScore = score;
+            valley = i;
+        }
     }
-  }
-  return (valley << 3) + 4;
+    return (valley << 3) + 4;
 }
-
 /**
  * Locally adaptive thresholding.
  *
@@ -153,100 +144,92 @@ function pickThreshold(buckets) {
  * @returns {BitMatrix}
  */
 export function binarizeHybrid(source) {
-  const { grey, width, height } = source;
-
-  // Too small to block up meaningfully; the global pass is strictly better.
-  if (width < BLOCK * 5 || height < BLOCK * 5) return binarizeGlobal(source);
-
-  const bw = (width + BLOCK - 1) >> BLOCK_SHIFT;
-  const bh = (height + BLOCK - 1) >> BLOCK_SHIFT;
-  const means = new Int32Array(bw * bh);
-  const ranges = new Int32Array(bw * bh);
-
-  for (let by = 0; by < bh; by++) {
-    const y0 = by << BLOCK_SHIFT;
-    const y1 = Math.min(y0 + BLOCK, height);
-    for (let bx = 0; bx < bw; bx++) {
-      const x0 = bx << BLOCK_SHIFT;
-      const x1 = Math.min(x0 + BLOCK, width);
-
-      let sum = 0, min = 255, max = 0, count = 0;
-      for (let y = y0; y < y1; y++) {
-        const base = y * width;
-        for (let x = x0; x < x1; x++) {
-          const v = grey[base + x];
-          sum += v;
-          if (v < min) min = v;
-          if (v > max) max = v;
-          count++;
+    const { grey, width, height } = source;
+    // Too small to block up meaningfully; the global pass is strictly better.
+    if (width < BLOCK * 5 || height < BLOCK * 5)
+        return binarizeGlobal(source);
+    const bw = (width + BLOCK - 1) >> BLOCK_SHIFT;
+    const bh = (height + BLOCK - 1) >> BLOCK_SHIFT;
+    const means = new Int32Array(bw * bh);
+    const ranges = new Int32Array(bw * bh);
+    for (let by = 0; by < bh; by++) {
+        const y0 = by << BLOCK_SHIFT;
+        const y1 = Math.min(y0 + BLOCK, height);
+        for (let bx = 0; bx < bw; bx++) {
+            const x0 = bx << BLOCK_SHIFT;
+            const x1 = Math.min(x0 + BLOCK, width);
+            let sum = 0, min = 255, max = 0, count = 0;
+            for (let y = y0; y < y1; y++) {
+                const base = y * width;
+                for (let x = x0; x < x1; x++) {
+                    const v = grey[base + x];
+                    sum += v;
+                    if (v < min)
+                        min = v;
+                    if (v > max)
+                        max = v;
+                    count++;
+                }
+            }
+            const idx = by * bw + bx;
+            means[idx] = count ? (sum / count) | 0 : 128;
+            ranges[idx] = max - min;
         }
-      }
-      const idx = by * bw + bx;
-      means[idx] = count ? (sum / count) | 0 : 128;
-      ranges[idx] = max - min;
-    }
-  }
-
-  // Flat blocks adopt a threshold from context. Looking left and up is enough
-  // because those neighbours are already resolved, and it makes the pass
-  // single-shot rather than iterative.
-  for (let by = 0; by < bh; by++) {
-    for (let bx = 0; bx < bw; bx++) {
-      const idx = by * bw + bx;
-      if (ranges[idx] >= MIN_DYNAMIC_RANGE) continue;
-
-      let inherited = means[idx];
-      if (bx > 0 && by > 0) {
-        const neighbours = [
-          means[idx - 1],
-          means[idx - bw],
-          means[idx - bw - 1],
-        ];
-        const avg = (neighbours[0] + neighbours[1] + neighbours[2]) / 3;
-        // A flat block darker than its surroundings is ink; lighter is paper.
-        // Either way the local minimum is the safer threshold than the mean.
-        inherited = Math.min(avg, means[idx]);
-      }
-      means[idx] = inherited | 0;
     }
-  }
-
-  const out = new BitMatrix(width, height);
-  const R = 2; // 5x5 block window
-
-  for (let by = 0; by < bh; by++) {
-    const y0 = by << BLOCK_SHIFT;
-    const y1 = Math.min(y0 + BLOCK, height);
-    const byLo = Math.max(0, by - R);
-    const byHi = Math.min(bh - 1, by + R);
-
-    for (let bx = 0; bx < bw; bx++) {
-      const bxLo = Math.max(0, bx - R);
-      const bxHi = Math.min(bw - 1, bx + R);
-
-      let sum = 0, count = 0;
-      for (let ny = byLo; ny <= byHi; ny++) {
-        for (let nx = bxLo; nx <= bxHi; nx++) {
-          sum += means[ny * bw + nx];
-          count++;
+    // Flat blocks adopt a threshold from context. Looking left and up is enough
+    // because those neighbours are already resolved, and it makes the pass
+    // single-shot rather than iterative.
+    for (let by = 0; by < bh; by++) {
+        for (let bx = 0; bx < bw; bx++) {
+            const idx = by * bw + bx;
+            if (ranges[idx] >= MIN_DYNAMIC_RANGE)
+                continue;
+            let inherited = means[idx];
+            if (bx > 0 && by > 0) {
+                const neighbours = [
+                    means[idx - 1],
+                    means[idx - bw],
+                    means[idx - bw - 1],
+                ];
+                const avg = (neighbours[0] + neighbours[1] + neighbours[2]) / 3;
+                // A flat block darker than its surroundings is ink; lighter is paper.
+                // Either way the local minimum is the safer threshold than the mean.
+                inherited = Math.min(avg, means[idx]);
+            }
+            means[idx] = inherited | 0;
         }
-      }
-      const threshold = sum / count;
-
-      const x0 = bx << BLOCK_SHIFT;
-      const x1 = Math.min(x0 + BLOCK, width);
-      for (let y = y0; y < y1; y++) {
-        const base = y * width;
-        for (let x = x0; x < x1; x++) {
-          if (grey[base + x] < threshold) out.set(x, y);
+    }
+    const out = new BitMatrix(width, height);
+    const R = 2; // 5x5 block window
+    for (let by = 0; by < bh; by++) {
+        const y0 = by << BLOCK_SHIFT;
+        const y1 = Math.min(y0 + BLOCK, height);
+        const byLo = Math.max(0, by - R);
+        const byHi = Math.min(bh - 1, by + R);
+        for (let bx = 0; bx < bw; bx++) {
+            const bxLo = Math.max(0, bx - R);
+            const bxHi = Math.min(bw - 1, bx + R);
+            let sum = 0, count = 0;
+            for (let ny = byLo; ny <= byHi; ny++) {
+                for (let nx = bxLo; nx <= bxHi; nx++) {
+                    sum += means[ny * bw + nx];
+                    count++;
+                }
+            }
+            const threshold = sum / count;
+            const x0 = bx << BLOCK_SHIFT;
+            const x1 = Math.min(x0 + BLOCK, width);
+            for (let y = y0; y < y1; y++) {
+                const base = y * width;
+                for (let x = x0; x < x1; x++) {
+                    if (grey[base + x] < threshold)
+                        out.set(x, y);
+                }
+            }
         }
-      }
     }
-  }
-
-  return out;
+    return out;
 }
-
 /**
  * Binarize with the named strategy.
  *
@@ -255,16 +238,17 @@ export function binarizeHybrid(source) {
  * @returns {BitMatrix}
  */
 export function binarize(source, strategy = 'auto') {
-  if (!source || !source.grey) throw new NotFoundError('binarize: no luminance source');
-  switch (strategy) {
-    case 'global': return binarizeGlobal(source);
-    case 'hybrid': return binarizeHybrid(source);
-    case 'auto':
-      // Small images are almost always generated rather than photographed.
-      return source.width * source.height < 200 * 200
-        ? binarizeGlobal(source)
-        : binarizeHybrid(source);
-    default:
-      throw new NotFoundError(`Unknown binarizer strategy: ${strategy}`);
-  }
+    if (!source || !source.grey)
+        throw new NotFoundError('binarize: no luminance source');
+    switch (strategy) {
+        case 'global': return binarizeGlobal(source);
+        case 'hybrid': return binarizeHybrid(source);
+        case 'auto':
+            // Small images are almost always generated rather than photographed.
+            return source.width * source.height < 200 * 200
+                ? binarizeGlobal(source)
+                : binarizeHybrid(source);
+        default:
+            throw new NotFoundError(`Unknown binarizer strategy: ${strategy}`);
+    }
 }

package/src/js/image/grid-sampler.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Resample a distorted symbol in the image into an upright module grid.
  *
@@ -38,11 +37,9 @@
  *
  * @module image/grid-sampler
  */
-
 import { BitMatrix } from '../core/bit-matrix.js';
 import { NotFoundError } from '../core/errors.js';
 import { PerspectiveTransform } from './perspective.js';
-
 /**
  * Sample a `dimension` x `dimension` grid (or `width` x `height`).
  *
@@ -54,33 +51,28 @@ import { PerspectiveTransform } from './perspective.js';
  * @throws {NotFoundError} If the grid falls outside the image.
  */
 export function sampleGrid(image, width, height, transform) {
-  const out = new BitMatrix(width, height);
-  const points = new Float32Array(width * 2);
-
-  for (let y = 0; y < height; y++) {
-    // Module centres: offset by half a module in both axes.
-    const gridY = y + 0.5;
-    for (let x = 0; x < width; x++) {
-      points[x * 2] = x + 0.5;
-      points[x * 2 + 1] = gridY;
-    }
-    transform.transform(points);
-
-    for (let x = 0; x < width; x++) {
-      const px = points[x * 2] | 0;
-      const py = points[x * 2 + 1] | 0;
-      if (px < 0 || py < 0 || px >= image.width || py >= image.height) {
-        throw new NotFoundError(
-          `Sampling grid escapes the image at module (${x}, ${y})`
-        );
-      }
-      if (image.get(px, py)) out.set(x, y);
+    const out = new BitMatrix(width, height);
+    const points = new Float32Array(width * 2);
+    for (let y = 0; y < height; y++) {
+        // Module centres: offset by half a module in both axes.
+        const gridY = y + 0.5;
+        for (let x = 0; x < width; x++) {
+            points[x * 2] = x + 0.5;
+            points[x * 2 + 1] = gridY;
+        }
+        transform.transform(points);
+        for (let x = 0; x < width; x++) {
+            const px = points[x * 2] | 0;
+            const py = points[x * 2 + 1] | 0;
+            if (px < 0 || py < 0 || px >= image.width || py >= image.height) {
+                throw new NotFoundError(`Sampling grid escapes the image at module (${x}, ${y})`);
+            }
+            if (image.get(px, py))
+                out.set(x, y);
+        }
     }
-  }
-
-  return out;
+    return out;
 }
-
 /**
  * Sample with a 3x3 majority vote per module.
  *
@@ -95,48 +87,44 @@ export function sampleGrid(image, width, height, transform) {
  * @returns {BitMatrix}
  */
 export function sampleGridVoting(image, width, height, transform) {
-  const out = new BitMatrix(width, height);
-
-  // Spacing between module centres, measured in image pixels, so the vote
-  // spreads across the module rather than a fixed pixel radius that would be
-  // meaningless at a different scale.
-  const p0 = transform.transformPoint(0.5, 0.5);
-  const p1 = transform.transformPoint(1.5, 0.5);
-  const p2 = transform.transformPoint(0.5, 1.5);
-  const stepX = Math.hypot(p1.x - p0.x, p1.y - p0.y);
-  const stepY = Math.hypot(p2.x - p0.x, p2.y - p0.y);
-  const rx = Math.max(1, Math.round(stepX / 4));
-  const ry = Math.max(1, Math.round(stepY / 4));
-
-  for (let y = 0; y < height; y++) {
-    for (let x = 0; x < width; x++) {
-      const c = transform.transformPoint(x + 0.5, y + 0.5);
-      const cx = c.x | 0;
-      const cy = c.y | 0;
-      if (cx < 0 || cy < 0 || cx >= image.width || cy >= image.height) {
-        throw new NotFoundError(
-          `Sampling grid escapes the image at module (${x}, ${y})`
-        );
-      }
-
-      let dark = 0;
-      let total = 0;
-      for (let dy = -1; dy <= 1; dy++) {
-        for (let dx = -1; dx <= 1; dx++) {
-          const sx = cx + dx * rx;
-          const sy = cy + dy * ry;
-          if (sx < 0 || sy < 0 || sx >= image.width || sy >= image.height) continue;
-          total++;
-          if (image.get(sx, sy)) dark++;
+    const out = new BitMatrix(width, height);
+    // Spacing between module centres, measured in image pixels, so the vote
+    // spreads across the module rather than a fixed pixel radius that would be
+    // meaningless at a different scale.
+    const p0 = transform.transformPoint(0.5, 0.5);
+    const p1 = transform.transformPoint(1.5, 0.5);
+    const p2 = transform.transformPoint(0.5, 1.5);
+    const stepX = Math.hypot(p1.x - p0.x, p1.y - p0.y);
+    const stepY = Math.hypot(p2.x - p0.x, p2.y - p0.y);
+    const rx = Math.max(1, Math.round(stepX / 4));
+    const ry = Math.max(1, Math.round(stepY / 4));
+    for (let y = 0; y < height; y++) {
+        for (let x = 0; x < width; x++) {
+            const c = transform.transformPoint(x + 0.5, y + 0.5);
+            const cx = c.x | 0;
+            const cy = c.y | 0;
+            if (cx < 0 || cy < 0 || cx >= image.width || cy >= image.height) {
+                throw new NotFoundError(`Sampling grid escapes the image at module (${x}, ${y})`);
+            }
+            let dark = 0;
+            let total = 0;
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const sx = cx + dx * rx;
+                    const sy = cy + dy * ry;
+                    if (sx < 0 || sy < 0 || sx >= image.width || sy >= image.height)
+                        continue;
+                    total++;
+                    if (image.get(sx, sy))
+                        dark++;
+                }
+            }
+            if (total > 0 && dark * 2 > total)
+                out.set(x, y);
         }
-      }
-      if (total > 0 && dark * 2 > total) out.set(x, y);
     }
-  }
-
-  return out;
+    return out;
 }
-
 /**
  * Build the transform for a symbol whose four corners are known, and sample it.
  *
@@ -149,16 +137,12 @@ export function sampleGridVoting(image, width, height, transform) {
  * @returns {BitMatrix}
  */
 export function sampleQuad(image, dimension, corners, voting = false) {
-  if (corners.length !== 4) throw new NotFoundError('sampleQuad needs exactly 4 corners');
-  const [tl, tr, br, bl] = corners;
-  const d = dimension;
-
-  const transform = PerspectiveTransform.quadToQuad(
-    0, 0, d, 0, d, d, 0, d,
-    tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y
-  );
-
-  return voting
-    ? sampleGridVoting(image, d, d, transform)
-    : sampleGrid(image, d, d, transform);
+    if (corners.length !== 4)
+        throw new NotFoundError('sampleQuad needs exactly 4 corners');
+    const [tl, tr, br, bl] = corners;
+    const d = dimension;
+    const transform = PerspectiveTransform.quadToQuad(0, 0, d, 0, d, d, 0, d, tl.x, tl.y, tr.x, tr.y, br.x, br.y, bl.x, bl.y);
+    return voting
+        ? sampleGridVoting(image, d, d, transform)
+        : sampleGrid(image, d, d, transform);
 }

package/src/js/image/index.js

@@ -27,13 +27,11 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Image pipeline, re-exported.
  *
  * @module image
  */
-
 export { LuminanceSource } from './luminance.js';
 export { binarize, binarizeGlobal, binarizeHybrid } from './binarizer.js';
 export { PerspectiveTransform } from './perspective.js';