zedbar 0.3.1 → 0.4.1

package/README.md

@@ -113,6 +113,30 @@ const results = scanImageBytes(imageBytes, { symbologies: ['QR-Code'] });
 - `symbolType` (`string`) - Barcode format (e.g., `"QR-Code"`, `"EAN-13"`)
 - `data` (`Uint8Array`) - Raw decoded bytes
 - `text` (`string | undefined`) - Decoded data as UTF-8 string, or `undefined` if not valid UTF-8
+- `points` (`Point[]`) - Position points in image coordinates. For QR codes, the four corners of the QR's bounding rectangle (in implementation-defined order). For linear barcodes, one or more touchpoints accumulated as the symbol was scanned. Empty if no points were recorded.
+- `bounds` (`Bounds | undefined`) - Axis-aligned bounding rectangle of `points`, or `undefined` if no points were recorded.
+
+### `Point`
+
+- `x` (`number`)
+- `y` (`number`)
+
+### `Bounds`
+
+- `x`, `y` (`number`) - Top-left corner in image coordinates.
+- `width`, `height` (`number`) - Reported as `max - min` of the recorded points (the horizontal and vertical extent between the outermost points), not as a pixel count.
+
+```javascript
+for (const result of scanImageBytes(imageBytes)) {
+  for (const { x, y } of result.points) {
+    console.log(`  point at (${x}, ${y})`);
+  }
+  if (result.bounds) {
+    const { x, y, width, height } = result.bounds;
+    console.log(`  bounds: ${width}×${height} at (${x}, ${y})`);
+  }
+}
+```
 
 ## Supported Formats
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "zedbar",
   "description": "Fast QR code and barcode scanner for Node.js, powered by WebAssembly",
-  "version": "0.3.1",
+  "version": "0.4.1",
   "license": "LGPL-3.0-or-later",
   "repository": {
     "type": "git",

package/zedbar.d.ts

@@ -1,5 +1,14 @@
 /* tslint:disable */
 /* eslint-disable */
+/**
+ * Scan grayscale image data for barcodes and QR codes.
+ *
+ * `data` must be an array of 8-bit grayscale pixel values,
+ * row-major, with dimensions `width` x `height`.
+ *
+ * Returns an array of `DecodeResult` objects.
+ */
+export function scanGrayscale(data: Uint8Array, width: number, height: number, options?: ScanOptions | null): DecodeResult[];
 /**
  * Scan an encoded image (PNG, JPEG, BMP, WebP) for barcodes and QR codes.
  *
@@ -13,14 +22,20 @@
  */
 export function scanImageBytes(bytes: Uint8Array, options?: ScanOptions | null): DecodeResult[];
 /**
- * Scan grayscale image data for barcodes and QR codes.
- *
- * `data` must be an array of 8-bit grayscale pixel values,
- * row-major, with dimensions `width` x `height`.
- *
- * Returns an array of `DecodeResult` objects.
+ * Axis-aligned bounding rectangle of a decoded symbol in image
+ * coordinates. `width` and `height` are reported as `max - min` of the
+ * recorded points (i.e. the horizontal and vertical extent between the
+ * outermost points), not as a pixel count.
  */
-export function scanGrayscale(data: Uint8Array, width: number, height: number, options?: ScanOptions | null): DecodeResult[];
+export class Bounds {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly x: number;
+  readonly y: number;
+  readonly width: number;
+  readonly height: number;
+}
 /**
  * A decoded barcode/QR code result.
  */
@@ -47,6 +62,30 @@ export class DecodeResult {
    * For linear barcodes, the data is always ASCII text.
    */
   readonly text: string | undefined;
+  /**
+   * The axis-aligned bounding rectangle of this symbol's recorded
+   * points, or `null` if no points were recorded.
+   */
+  readonly bounds: Bounds | undefined;
+  /**
+   * The recorded position points of this symbol in image coordinates.
+   *
+   * For QR codes, this is the four corner points of the QR's bounding
+   * rectangle (in implementation-defined order). For linear barcodes,
+   * this is one or more touchpoints accumulated as the symbol was
+   * scanned. Empty if no points were recorded.
+   */
+  readonly points: Point[];
+}
+/**
+ * A 2D pixel coordinate in image space.
+ */
+export class Point {
+  private constructor();
+  free(): void;
+  [Symbol.dispose](): void;
+  readonly x: number;
+  readonly y: number;
 }
 /**
  * Options for barcode scanning.

package/zedbar.js

@@ -112,6 +112,17 @@ function getArrayU8FromWasm0(ptr, len) {
     return getUint8ArrayMemory0().subarray(ptr / 1, ptr / 1 + len);
 }
 
+function getArrayJsValueFromWasm0(ptr, len) {
+    ptr = ptr >>> 0;
+    const mem = getDataViewMemory0();
+    const result = [];
+    for (let i = ptr; i < ptr + 4 * len; i += 4) {
+        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
+    }
+    wasm.__externref_drop_slice(ptr, len);
+    return result;
+}
+
 function passArray8ToWasm0(arg, malloc) {
     const ptr = malloc(arg.length * 1, 1) >>> 0;
     getUint8ArrayMemory0().set(arg, ptr / 1);
@@ -130,40 +141,28 @@ function takeFromExternrefTable0(idx) {
     wasm.__externref_table_dealloc(idx);
     return value;
 }
-
-function getArrayJsValueFromWasm0(ptr, len) {
-    ptr = ptr >>> 0;
-    const mem = getDataViewMemory0();
-    const result = [];
-    for (let i = ptr; i < ptr + 4 * len; i += 4) {
-        result.push(wasm.__wbindgen_export_2.get(mem.getUint32(i, true)));
-    }
-    wasm.__externref_drop_slice(ptr, len);
-    return result;
-}
 /**
- * Scan an encoded image (PNG, JPEG, BMP, WebP) for barcodes and QR codes.
- *
- * `bytes` should contain the raw bytes of an image file in one of the
- * supported formats: PNG, JPEG, BMP, or WebP.
+ * Scan grayscale image data for barcodes and QR codes.
  *
- * The image will be automatically decoded and converted to grayscale
- * before scanning.
+ * `data` must be an array of 8-bit grayscale pixel values,
+ * row-major, with dimensions `width` x `height`.
  *
  * Returns an array of `DecodeResult` objects.
- * @param {Uint8Array} bytes
+ * @param {Uint8Array} data
+ * @param {number} width
+ * @param {number} height
  * @param {ScanOptions | null} [options]
  * @returns {DecodeResult[]}
  */
-exports.scanImageBytes = function(bytes, options) {
-    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
+exports.scanGrayscale = function(data, width, height, options) {
+    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     let ptr1 = 0;
     if (!isLikeNone(options)) {
         _assertClass(options, ScanOptions);
         ptr1 = options.__destroy_into_raw();
     }
-    const ret = wasm.scanImageBytes(ptr0, len0, ptr1);
+    const ret = wasm.scanGrayscale(ptr0, len0, width, height, ptr1);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -173,27 +172,28 @@ exports.scanImageBytes = function(bytes, options) {
 };
 
 /**
- * Scan grayscale image data for barcodes and QR codes.
+ * Scan an encoded image (PNG, JPEG, BMP, WebP) for barcodes and QR codes.
  *
- * `data` must be an array of 8-bit grayscale pixel values,
- * row-major, with dimensions `width` x `height`.
+ * `bytes` should contain the raw bytes of an image file in one of the
+ * supported formats: PNG, JPEG, BMP, or WebP.
+ *
+ * The image will be automatically decoded and converted to grayscale
+ * before scanning.
  *
  * Returns an array of `DecodeResult` objects.
- * @param {Uint8Array} data
- * @param {number} width
- * @param {number} height
+ * @param {Uint8Array} bytes
  * @param {ScanOptions | null} [options]
  * @returns {DecodeResult[]}
  */
-exports.scanGrayscale = function(data, width, height, options) {
-    const ptr0 = passArray8ToWasm0(data, wasm.__wbindgen_malloc);
+exports.scanImageBytes = function(bytes, options) {
+    const ptr0 = passArray8ToWasm0(bytes, wasm.__wbindgen_malloc);
     const len0 = WASM_VECTOR_LEN;
     let ptr1 = 0;
     if (!isLikeNone(options)) {
         _assertClass(options, ScanOptions);
         ptr1 = options.__destroy_into_raw();
     }
-    const ret = wasm.scanGrayscale(ptr0, len0, width, height, ptr1);
+    const ret = wasm.scanImageBytes(ptr0, len0, ptr1);
     if (ret[3]) {
         throw takeFromExternrefTable0(ret[2]);
     }
@@ -202,6 +202,69 @@ exports.scanGrayscale = function(data, width, height, options) {
     return v3;
 };
 
+const BoundsFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_bounds_free(ptr >>> 0, 1));
+/**
+ * Axis-aligned bounding rectangle of a decoded symbol in image
+ * coordinates. `width` and `height` are reported as `max - min` of the
+ * recorded points (i.e. the horizontal and vertical extent between the
+ * outermost points), not as a pixel count.
+ */
+class Bounds {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Bounds.prototype);
+        obj.__wbg_ptr = ptr;
+        BoundsFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        BoundsFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_bounds_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get x() {
+        const ret = wasm.bounds_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.bounds_y(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get width() {
+        const ret = wasm.bounds_width(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+    /**
+     * @returns {number}
+     */
+    get height() {
+        const ret = wasm.bounds_height(this.__wbg_ptr);
+        return ret >>> 0;
+    }
+}
+if (Symbol.dispose) Bounds.prototype[Symbol.dispose] = Bounds.prototype.free;
+
+exports.Bounds = Bounds;
+
 const DecodeResultFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_decoderesult_free(ptr >>> 0, 1));
@@ -275,11 +338,81 @@ class DecodeResult {
         }
         return v1;
     }
+    /**
+     * The axis-aligned bounding rectangle of this symbol's recorded
+     * points, or `null` if no points were recorded.
+     * @returns {Bounds | undefined}
+     */
+    get bounds() {
+        const ret = wasm.decoderesult_bounds(this.__wbg_ptr);
+        return ret === 0 ? undefined : Bounds.__wrap(ret);
+    }
+    /**
+     * The recorded position points of this symbol in image coordinates.
+     *
+     * For QR codes, this is the four corner points of the QR's bounding
+     * rectangle (in implementation-defined order). For linear barcodes,
+     * this is one or more touchpoints accumulated as the symbol was
+     * scanned. Empty if no points were recorded.
+     * @returns {Point[]}
+     */
+    get points() {
+        const ret = wasm.decoderesult_points(this.__wbg_ptr);
+        var v1 = getArrayJsValueFromWasm0(ret[0], ret[1]).slice();
+        wasm.__wbindgen_free(ret[0], ret[1] * 4, 4);
+        return v1;
+    }
 }
 if (Symbol.dispose) DecodeResult.prototype[Symbol.dispose] = DecodeResult.prototype.free;
 
 exports.DecodeResult = DecodeResult;
 
+const PointFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_point_free(ptr >>> 0, 1));
+/**
+ * A 2D pixel coordinate in image space.
+ */
+class Point {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(Point.prototype);
+        obj.__wbg_ptr = ptr;
+        PointFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
+    }
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        PointFinalization.unregister(this);
+        return ptr;
+    }
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_point_free(ptr, 0);
+    }
+    /**
+     * @returns {number}
+     */
+    get x() {
+        const ret = wasm.bounds_x(this.__wbg_ptr);
+        return ret;
+    }
+    /**
+     * @returns {number}
+     */
+    get y() {
+        const ret = wasm.bounds_y(this.__wbg_ptr);
+        return ret;
+    }
+}
+if (Symbol.dispose) Point.prototype[Symbol.dispose] = Point.prototype.free;
+
+exports.Point = Point;
+
 const ScanOptionsFinalization = (typeof FinalizationRegistry === 'undefined')
     ? { register: () => {}, unregister: () => {} }
     : new FinalizationRegistry(ptr => wasm.__wbg_scanoptions_free(ptr >>> 0, 1));
@@ -355,6 +488,11 @@ exports.__wbg_decoderesult_new = function(arg0) {
     return ret;
 };
 
+exports.__wbg_point_new = function(arg0) {
+    const ret = Point.__wrap(arg0);
+    return ret;
+};
+
 exports.__wbg_wbindgenstringget_0f16a6ddddef376f = function(arg0, arg1) {
     const obj = arg1;
     const ret = typeof(obj) === 'string' ? obj : undefined;