@sythos/js_barcode_universal 1.5.8 → 1.5.10

package/src/js/image/luminance.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Greyscale conversion — the boundary between "an image" and "our problem".
  *
@@ -39,158 +38,148 @@
  *
  * @module image/luminance
  */
-
 import { NotFoundError } from '../core/errors.js';
-
 /**
  * @typedef {object} ImageLike
  * @property {Uint8ClampedArray | Uint8Array | number[]} data RGBA, 4 bytes per pixel.
  * @property {number} width
  * @property {number} height
  */
-
 export class LuminanceSource {
-  /**
-   * @param {Uint8Array} grey One byte per pixel.
-   * @param {number} width
-   * @param {number} height
-   */
-  constructor(grey, width, height) {
-    this.grey = grey;
-    this.width = width;
-    this.height = height;
-  }
-
-  /**
-   * Build from any ImageData-shaped object.
-   *
-   * Transparent pixels are composited over white rather than read as black:
-   * a PNG barcode with a transparent background is common, and treating alpha
-   * as ink turns the entire quiet zone into a solid dark field.
-   *
-   * @param {ImageLike} image
-   * @returns {LuminanceSource}
-   */
-  static fromImageData(image) {
-    const { data, width, height } = image;
-    if (!data || !width || !height) {
-      throw new NotFoundError('Image must be { data, width, height } with RGBA data');
+    /**
+     * @param {Uint8Array} grey One byte per pixel.
+     * @param {number} width
+     * @param {number} height
+     */
+    constructor(grey, width, height) {
+        this.grey = grey;
+        this.width = width;
+        this.height = height;
     }
-    if (data.length < width * height * 4) {
-      throw new NotFoundError(
-        `Image data too short: ${data.length} bytes for ${width}x${height} RGBA ` +
-        `(expected ${width * height * 4})`
-      );
+    /**
+     * Build from any ImageData-shaped object.
+     *
+     * Transparent pixels are composited over white rather than read as black:
+     * a PNG barcode with a transparent background is common, and treating alpha
+     * as ink turns the entire quiet zone into a solid dark field.
+     *
+     * @param {ImageLike} image
+     * @returns {LuminanceSource}
+     */
+    static fromImageData(image) {
+        const { data, width, height } = image;
+        if (!data || !width || !height) {
+            throw new NotFoundError('Image must be { data, width, height } with RGBA data');
+        }
+        if (data.length < width * height * 4) {
+            throw new NotFoundError(`Image data too short: ${data.length} bytes for ${width}x${height} RGBA ` +
+                `(expected ${width * height * 4})`);
+        }
+        const grey = new Uint8Array(width * height);
+        for (let i = 0, p = 0; i < grey.length; i++, p += 4) {
+            const a = data[p + 3];
+            let r = data[p], g = data[p + 1], b = data[p + 2];
+            if (a !== 255) {
+                // Composite over white.
+                const inv = 255 - a;
+                r = (r * a + 255 * inv) / 255;
+                g = (g * a + 255 * inv) / 255;
+                b = (b * a + 255 * inv) / 255;
+            }
+            // Integer luma approximation of Rec. 601: 0.299/0.587/0.114 scaled by 256.
+            grey[i] = (r * 77 + g * 150 + b * 29) >> 8;
+        }
+        return new LuminanceSource(grey, width, height);
     }
-
-    const grey = new Uint8Array(width * height);
-    for (let i = 0, p = 0; i < grey.length; i++, p += 4) {
-      const a = data[p + 3];
-      let r = data[p], g = data[p + 1], b = data[p + 2];
-      if (a !== 255) {
-        // Composite over white.
-        const inv = 255 - a;
-        r = (r * a + 255 * inv) / 255;
-        g = (g * a + 255 * inv) / 255;
-        b = (b * a + 255 * inv) / 255;
-      }
-      // Integer luma approximation of Rec. 601: 0.299/0.587/0.114 scaled by 256.
-      grey[i] = (r * 77 + g * 150 + b * 29) >> 8;
+    /**
+     * Build directly from single-channel data, skipping conversion.
+     *
+     * @param {Uint8Array} grey
+     * @param {number} width
+     * @param {number} height
+     * @returns {LuminanceSource}
+     */
+    static fromGrey(grey, width, height) {
+        if (grey.length < width * height) {
+            throw new NotFoundError('Greyscale buffer shorter than width * height');
+        }
+        return new LuminanceSource(grey, width, height);
     }
-    return new LuminanceSource(grey, width, height);
-  }
-
-  /**
-   * Build directly from single-channel data, skipping conversion.
-   *
-   * @param {Uint8Array} grey
-   * @param {number} width
-   * @param {number} height
-   * @returns {LuminanceSource}
-   */
-  static fromGrey(grey, width, height) {
-    if (grey.length < width * height) {
-      throw new NotFoundError('Greyscale buffer shorter than width * height');
+    /**
+     * @param {number} x @param {number} y
+     * @returns {number} 0-255.
+     */
+    get(x, y) {
+        return this.grey[y * this.width + x];
     }
-    return new LuminanceSource(grey, width, height);
-  }
-
-  /**
-   * @param {number} x @param {number} y
-   * @returns {number} 0-255.
-   */
-  get(x, y) {
-    return this.grey[y * this.width + x];
-  }
-
-  /**
-   * @param {number} y
-   * @param {Uint8Array} [out]
-   * @returns {Uint8Array}
-   */
-  getRow(y, out) {
-    const row = out && out.length >= this.width ? out : new Uint8Array(this.width);
-    row.set(this.grey.subarray(y * this.width, (y + 1) * this.width));
-    return row;
-  }
-
-  /**
-   * Rotate 90 degrees clockwise.
-   *
-   * The 1D readers scan horizontally, so this is how they find vertically
-   * oriented barcodes: scan, rotate, scan again.
-   *
-   * @returns {LuminanceSource}
-   */
-  rotate90() {
-    const { width: w, height: h, grey } = this;
-    const out = new Uint8Array(grey.length);
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        out[x * h + (h - 1 - y)] = grey[y * w + x];
-      }
+    /**
+     * @param {number} y
+     * @param {Uint8Array} [out]
+     * @returns {Uint8Array}
+     */
+    getRow(y, out) {
+        const row = out && out.length >= this.width ? out : new Uint8Array(this.width);
+        row.set(this.grey.subarray(y * this.width, (y + 1) * this.width));
+        return row;
     }
-    return new LuminanceSource(out, h, w);
-  }
-
-  /**
-   * Downscale by an integer factor with box averaging.
-   *
-   * Large camera frames are slow to scan and no more informative than a
-   * half-size copy; detectors use this to find candidates cheaply.
-   *
-   * @param {number} factor
-   * @returns {LuminanceSource}
-   */
-  downscale(factor) {
-    const f = Math.max(1, Math.floor(factor));
-    if (f === 1) return this;
-    const w = Math.floor(this.width / f);
-    const h = Math.floor(this.height / f);
-    const out = new Uint8Array(w * h);
-    const area = f * f;
-    for (let y = 0; y < h; y++) {
-      for (let x = 0; x < w; x++) {
-        let sum = 0;
-        for (let dy = 0; dy < f; dy++) {
-          const base = (y * f + dy) * this.width + x * f;
-          for (let dx = 0; dx < f; dx++) sum += this.grey[base + dx];
+    /**
+     * Rotate 90 degrees clockwise.
+     *
+     * The 1D readers scan horizontally, so this is how they find vertically
+     * oriented barcodes: scan, rotate, scan again.
+     *
+     * @returns {LuminanceSource}
+     */
+    rotate90() {
+        const { width: w, height: h, grey } = this;
+        const out = new Uint8Array(grey.length);
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                out[x * h + (h - 1 - y)] = grey[y * w + x];
+            }
         }
-        out[y * w + x] = (sum / area) | 0;
-      }
+        return new LuminanceSource(out, h, w);
+    }
+    /**
+     * Downscale by an integer factor with box averaging.
+     *
+     * Large camera frames are slow to scan and no more informative than a
+     * half-size copy; detectors use this to find candidates cheaply.
+     *
+     * @param {number} factor
+     * @returns {LuminanceSource}
+     */
+    downscale(factor) {
+        const f = Math.max(1, Math.floor(factor));
+        if (f === 1)
+            return this;
+        const w = Math.floor(this.width / f);
+        const h = Math.floor(this.height / f);
+        const out = new Uint8Array(w * h);
+        const area = f * f;
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                let sum = 0;
+                for (let dy = 0; dy < f; dy++) {
+                    const base = (y * f + dy) * this.width + x * f;
+                    for (let dx = 0; dx < f; dx++)
+                        sum += this.grey[base + dx];
+                }
+                out[y * w + x] = (sum / area) | 0;
+            }
+        }
+        return new LuminanceSource(out, w, h);
+    }
+    /**
+     * Invert. Some symbols are printed light-on-dark, and readers retry inverted
+     * when a first pass finds nothing.
+     *
+     * @returns {LuminanceSource}
+     */
+    invert() {
+        const out = new Uint8Array(this.grey.length);
+        for (let i = 0; i < out.length; i++)
+            out[i] = 255 - this.grey[i];
+        return new LuminanceSource(out, this.width, this.height);
     }
-    return new LuminanceSource(out, w, h);
-  }
-
-  /**
-   * Invert. Some symbols are printed light-on-dark, and readers retry inverted
-   * when a first pass finds nothing.
-   *
-   * @returns {LuminanceSource}
-   */
-  invert() {
-    const out = new Uint8Array(this.grey.length);
-    for (let i = 0; i < out.length; i++) out[i] = 255 - this.grey[i];
-    return new LuminanceSource(out, this.width, this.height);
-  }
 }

package/src/js/image/perspective.js

@@ -27,7 +27,6 @@
  *
  * Original work. No code from any other barcode implementation.
  */
-
 /**
  * Projective (perspective) transforms.
  *
@@ -41,155 +40,119 @@
  *
  * @module image/perspective
  */
-
 export class PerspectiveTransform {
-  /* eslint-disable-next-line max-params */
-  constructor(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
-    this.a11 = a11; this.a21 = a21; this.a31 = a31;
-    this.a12 = a12; this.a22 = a22; this.a32 = a32;
-    this.a13 = a13; this.a23 = a23; this.a33 = a33;
-  }
-
-  /**
-   * Transform points in place.
-   *
-   * @param {Float32Array | number[]} points Interleaved [x0, y0, x1, y1, ...].
-   * @returns {Float32Array | number[]} The same array.
-   */
-  transform(points) {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    for (let i = 0; i < points.length; i += 2) {
-      const x = points[i];
-      const y = points[i + 1];
-      const w = a13 * x + a23 * y + a33;
-      points[i] = (a11 * x + a21 * y + a31) / w;
-      points[i + 1] = (a12 * x + a22 * y + a32) / w;
+    /* eslint-disable-next-line max-params */
+    constructor(a11, a21, a31, a12, a22, a32, a13, a23, a33) {
+        this.a11 = a11;
+        this.a21 = a21;
+        this.a31 = a31;
+        this.a12 = a12;
+        this.a22 = a22;
+        this.a32 = a32;
+        this.a13 = a13;
+        this.a23 = a23;
+        this.a33 = a33;
     }
-    return points;
-  }
-
-  /**
-   * Transform a single point.
-   *
-   * @param {number} x @param {number} y
-   * @returns {{x: number, y: number}}
-   */
-  transformPoint(x, y) {
-    const w = this.a13 * x + this.a23 * y + this.a33;
-    return {
-      x: (this.a11 * x + this.a21 * y + this.a31) / w,
-      y: (this.a12 * x + this.a22 * y + this.a32) / w,
-    };
-  }
-
-  /**
-   * Map the unit square — (0,0), (1,0), (1,1), (0,1) — onto an arbitrary quad.
-   *
-   * Corners are given in that same order, i.e. going around the quad, not
-   * as opposite pairs.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3) {
-    const dx3 = x0 - x1 + x2 - x3;
-    const dy3 = y0 - y1 + y2 - y3;
-
-    if (dx3 === 0 && dy3 === 0) {
-      // The quad is a parallelogram, so the map is affine and the projective
-      // terms vanish. Worth special-casing: it is the common case for flat
-      // scans, and the general solution divides by zero here.
-      return new PerspectiveTransform(
-        x1 - x0, x2 - x1, x0,
-        y1 - y0, y2 - y1, y0,
-        0, 0, 1
-      );
+    /**
+     * Transform points in place.
+     *
+     * @param {Float32Array | number[]} points Interleaved [x0, y0, x1, y1, ...].
+     * @returns {Float32Array | number[]} The same array.
+     */
+    transform(points) {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        for (let i = 0; i < points.length; i += 2) {
+            const x = points[i];
+            const y = points[i + 1];
+            const w = a13 * x + a23 * y + a33;
+            points[i] = (a11 * x + a21 * y + a31) / w;
+            points[i + 1] = (a12 * x + a22 * y + a32) / w;
+        }
+        return points;
+    }
+    /**
+     * Transform a single point.
+     *
+     * @param {number} x @param {number} y
+     * @returns {{x: number, y: number}}
+     */
+    transformPoint(x, y) {
+        const w = this.a13 * x + this.a23 * y + this.a33;
+        return {
+            x: (this.a11 * x + this.a21 * y + this.a31) / w,
+            y: (this.a12 * x + this.a22 * y + this.a32) / w,
+        };
+    }
+    /**
+     * Map the unit square — (0,0), (1,0), (1,1), (0,1) — onto an arbitrary quad.
+     *
+     * Corners are given in that same order, i.e. going around the quad, not
+     * as opposite pairs.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3) {
+        const dx3 = x0 - x1 + x2 - x3;
+        const dy3 = y0 - y1 + y2 - y3;
+        if (dx3 === 0 && dy3 === 0) {
+            // The quad is a parallelogram, so the map is affine and the projective
+            // terms vanish. Worth special-casing: it is the common case for flat
+            // scans, and the general solution divides by zero here.
+            return new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0, 0, 1);
+        }
+        const dx1 = x1 - x2;
+        const dx2 = x3 - x2;
+        const dy1 = y1 - y2;
+        const dy2 = y3 - y2;
+        const denominator = dx1 * dy2 - dx2 * dy1;
+        const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+        const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+        return new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1);
+    }
+    /**
+     * Map an arbitrary quad onto the unit square — the inverse of
+     * {@link squareToQuad}, via the adjugate.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static quadToSquare(x0, y0, x1, y1, x2, y2, x3, y3) {
+        return PerspectiveTransform.squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3).inverse();
+    }
+    /**
+     * Map one quad onto another, corner for corner.
+     *
+     * This is what turns four detected finder corners into a sampling grid:
+     * compose "detected quad -> unit square" with "unit square -> ideal grid".
+     *
+     * @returns {PerspectiveTransform}
+     */
+    /* eslint-disable-next-line max-params */
+    static quadToQuad(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3, dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3) {
+        const toSquare = PerspectiveTransform.quadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
+        const toQuad = PerspectiveTransform.squareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3);
+        return toSquare.times(toQuad);
+    }
+    /**
+     * Adjugate — the inverse up to a scale factor, which is irrelevant in
+     * homogeneous coordinates because the division by w cancels it.
+     *
+     * @returns {PerspectiveTransform}
+     */
+    inverse() {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        return new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32 - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22, a13 * a21 - a11 * a23, a11 * a22 - a12 * a21);
+    }
+    /**
+     * Matrix product: apply `this` first, then `other`.
+     *
+     * @param {PerspectiveTransform} other
+     * @returns {PerspectiveTransform}
+     */
+    times(other) {
+        const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
+        const o = other;
+        return new PerspectiveTransform(o.a11 * a11 + o.a21 * a12 + o.a31 * a13, o.a11 * a21 + o.a21 * a22 + o.a31 * a23, o.a11 * a31 + o.a21 * a32 + o.a31 * a33, o.a12 * a11 + o.a22 * a12 + o.a32 * a13, o.a12 * a21 + o.a22 * a22 + o.a32 * a23, o.a12 * a31 + o.a22 * a32 + o.a32 * a33, o.a13 * a11 + o.a23 * a12 + o.a33 * a13, o.a13 * a21 + o.a23 * a22 + o.a33 * a23, o.a13 * a31 + o.a23 * a32 + o.a33 * a33);
     }
-
-    const dx1 = x1 - x2;
-    const dx2 = x3 - x2;
-    const dy1 = y1 - y2;
-    const dy2 = y3 - y2;
-    const denominator = dx1 * dy2 - dx2 * dy1;
-    const a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
-    const a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
-
-    return new PerspectiveTransform(
-      x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0,
-      y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0,
-      a13, a23, 1
-    );
-  }
-
-  /**
-   * Map an arbitrary quad onto the unit square — the inverse of
-   * {@link squareToQuad}, via the adjugate.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static quadToSquare(x0, y0, x1, y1, x2, y2, x3, y3) {
-    return PerspectiveTransform.squareToQuad(x0, y0, x1, y1, x2, y2, x3, y3).inverse();
-  }
-
-  /**
-   * Map one quad onto another, corner for corner.
-   *
-   * This is what turns four detected finder corners into a sampling grid:
-   * compose "detected quad -> unit square" with "unit square -> ideal grid".
-   *
-   * @returns {PerspectiveTransform}
-   */
-  /* eslint-disable-next-line max-params */
-  static quadToQuad(
-    sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3,
-    dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3
-  ) {
-    const toSquare = PerspectiveTransform.quadToSquare(sx0, sy0, sx1, sy1, sx2, sy2, sx3, sy3);
-    const toQuad = PerspectiveTransform.squareToQuad(dx0, dy0, dx1, dy1, dx2, dy2, dx3, dy3);
-    return toSquare.times(toQuad);
-  }
-
-  /**
-   * Adjugate — the inverse up to a scale factor, which is irrelevant in
-   * homogeneous coordinates because the division by w cancels it.
-   *
-   * @returns {PerspectiveTransform}
-   */
-  inverse() {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    return new PerspectiveTransform(
-      a22 * a33 - a23 * a32,
-      a23 * a31 - a21 * a33,
-      a21 * a32 - a22 * a31,
-      a13 * a32 - a12 * a33,
-      a11 * a33 - a13 * a31,
-      a12 * a31 - a11 * a32,
-      a12 * a23 - a13 * a22,
-      a13 * a21 - a11 * a23,
-      a11 * a22 - a12 * a21
-    );
-  }
-
-  /**
-   * Matrix product: apply `this` first, then `other`.
-   *
-   * @param {PerspectiveTransform} other
-   * @returns {PerspectiveTransform}
-   */
-  times(other) {
-    const { a11, a21, a31, a12, a22, a32, a13, a23, a33 } = this;
-    const o = other;
-    return new PerspectiveTransform(
-      o.a11 * a11 + o.a21 * a12 + o.a31 * a13,
-      o.a11 * a21 + o.a21 * a22 + o.a31 * a23,
-      o.a11 * a31 + o.a21 * a32 + o.a31 * a33,
-      o.a12 * a11 + o.a22 * a12 + o.a32 * a13,
-      o.a12 * a21 + o.a22 * a22 + o.a32 * a23,
-      o.a12 * a31 + o.a22 * a32 + o.a32 * a33,
-      o.a13 * a11 + o.a23 * a12 + o.a33 * a13,
-      o.a13 * a21 + o.a23 * a22 + o.a33 * a23,
-      o.a13 * a31 + o.a23 * a32 + o.a33 * a33
-    );
-  }
 }