Merge pull request #655 from ericblade/dev

A lot of pharmacode updates

Author: ericblade

.github/copilot-instructions.md

@@ -141,6 +141,31 @@ This file controls which packages `npm-check-updates` can upgrade:
 
 ## Testing Requirements
 
+### CRITICAL: NODE_OPTIONS Flag
+
+**⚠️ IMPORTANT:** Cypress tests MUST be run with `NODE_OPTIONS=--openssl-legacy-provider` due to Node.js 17+ security changes disabling legacy OpenSSL algorithms. Our build dependencies require these algorithms.
+
+**Always use npm scripts** (which include this flag automatically):
+```bash
+npm run cypress:run              # Correct - includes NODE_OPTIONS
+npm run cypress:open            # Correct - interactive runner with NODE_OPTIONS
+npm run test                    # Correct - full test suite with NODE_OPTIONS
+```
+
+**When running Cypress directly, include the flag:**
+```bash
+# Correct - runs specific spec with NODE_OPTIONS
+npm run cypress:run -- --spec cypress/e2e/integration.cy.ts
+
+# Also correct - explicit NODE_OPTIONS
+npx cross-env NODE_ENV=development BUILD_ENV=development NODE_OPTIONS=--openssl-legacy-provider npx cypress run --spec cypress/e2e/integration.cy.ts
+
+# WRONG - missing NODE_OPTIONS, will timeout
+npx cypress run --spec cypress/e2e/integration.cy.ts
+```
+
+Tests will appear to hang with "timed out waiting for async callback" if `NODE_OPTIONS` is missing.
+
 ### Running Tests
 
 - **Type checking**: `npm run check-types`

cypress/e2e/integration.cy.ts

@@ -1,19 +1,22 @@
 window.ENV = { development: true, production: false, node: false };
 
-import '../../test/integration/decoders/ean.spec.ts';
-import '../../test/integration/decoders/ean_extended.spec.ts';
-import '../../test/integration/decoders/ean_supplement_format.spec.ts';
+// Integration tests that aren't specific decoders
+import '../../test/integration/external-reader.spec.ts';
+import '../../test/integration/integration.spec.ts';
+import '../../test/integration/reader-order.spec.ts';
+
+// Decoders
+import '../../test/integration/decoders/2of5.spec.ts';
+import '../../test/integration/decoders/codabar.spec.ts';
 import '../../test/integration/decoders/code_128.spec.ts';
-import '../../test/integration/decoders/code_39.spec.ts';
-import '../../test/integration/decoders/code_39_vin.spec.ts';
 import '../../test/integration/decoders/code_32.spec.ts';
+import '../../test/integration/decoders/code_39_vin.spec.ts';
+import '../../test/integration/decoders/code_39.spec.ts';
+import '../../test/integration/decoders/code_93.spec.ts';
 import '../../test/integration/decoders/ean_8.spec.ts';
-import '../../test/integration/decoders/upc.spec.ts';
-import '../../test/integration/decoders/upc_e.spec.ts';
-import '../../test/integration/decoders/codabar.spec.ts';
+import '../../test/integration/decoders/ean_extended.spec.ts';
+import '../../test/integration/decoders/ean_supplement_format.spec.ts';
+import '../../test/integration/decoders/ean.spec.ts';
 import '../../test/integration/decoders/i2of5.spec.ts';
-import '../../test/integration/decoders/2of5.spec.ts';
-import '../../test/integration/decoders/code_93.spec.ts';
-import '../../test/integration/external-reader.spec.ts';
-import '../../test/integration/integration.spec.ts';
-import '../../test/integration/reader-order.spec.ts';
+import '../../test/integration/decoders/upc_e.spec.ts';
+import '../../test/integration/decoders/upc.spec.ts';

cypress/e2e/integration/decoder/pharmacode.cy.ts

@@ -0,0 +1 @@
+import '../../../../test/integration/decoders/pharmacode.spec.ts';

docs/examples/file_input.html

@@ -86,6 +86,10 @@ <h3>Working with file-input</h3>
                 <span>Single Channel</span>
                 <input type="checkbox" name="input-stream_single-channel" />
             </label>
+            <label>
+                <span>Locate (barcode finder)</span>
+                <input type="checkbox" checked="checked" name="locate" />
+            </label>
         </fieldset>
     </div>
     <div id="result_strip">

docs/examples/file_input.js

@@ -1,8 +1,19 @@
 $(function() {
     var App = {
         init: function() {
+            App.syncCheckboxesFromState();
             App.attachListeners();
         },
+        syncCheckboxesFromState: function() {
+            var self = this;
+            $(".controls .reader-config-group input[type=checkbox]").each(function() {
+                var $checkbox = $(this),
+                    name = $checkbox.attr("name"),
+                    state = self._convertNameToState(name),
+                    value = self._accessByPath(self.state, state);
+                $checkbox.prop("checked", !!value);
+            });
+        },
         attachListeners: function() {
             var self = this;
 
@@ -147,6 +158,7 @@ $(function() {
     }
 
     Quagga.onProcessed(function(result) {
+        console.warn('* onProcessed', result);
         var drawingCtx = Quagga.canvas.ctx.overlay,
             drawingCanvas = Quagga.canvas.dom.overlay,
             area;
@@ -174,10 +186,11 @@ $(function() {
                 drawingCtx.strokeStyle = "#0F0";
                 drawingCtx.strokeRect(area.x, area.y, area.width, area.height);
             }
-    }
+        }
     });
 
     Quagga.onDetected(function(result) {
+        console.warn('* onDetected', result);
         var code = result.codeResult.code,
             $node,
             canvas = Quagga.canvas.dom.image;

src/common/cv_utils.js

@@ -542,13 +542,25 @@ export function computeGray(imageData, outArray, config) {
 
     if (singleChannel) {
         for (let i = 0; i < l; i++) {
-            // eslint-disable-next-line no-param-reassign
-            outArray[i] = imageData[i * 4 + 0];
+            const alpha = imageData[i * 4 + 3];
+            if (alpha === 0) {
+                // eslint-disable-next-line no-param-reassign
+                outArray[i] = 255; // Treat transparent pixels as white
+            } else {
+                // eslint-disable-next-line no-param-reassign
+                outArray[i] = imageData[i * 4 + 0];
+            }
         }
     } else {
         for (let i = 0; i < l; i++) {
-            // eslint-disable-next-line no-param-reassign
-            outArray[i] = 0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2];
+            const alpha = imageData[i * 4 + 3];
+            if (alpha === 0) {
+                // eslint-disable-next-line no-param-reassign
+                outArray[i] = 255; // Treat transparent pixels as white
+            } else {
+                // eslint-disable-next-line no-param-reassign
+                outArray[i] = 0.299 * imageData[i * 4 + 0] + 0.587 * imageData[i * 4 + 1] + 0.114 * imageData[i * 4 + 2];
+            }
         }
     }
 }

src/common/test/cv_utils.spec.js

@@ -1049,6 +1049,87 @@ describe('CV Utils', () => {
             computeGray(imageData, outArray);
             expect(outArray[0]).to.equal(0);
         });
+
+        it('should treat transparent pixels as white regardless of RGB values', () => {
+            // Transparent black (0,0,0,0) should be treated as white
+            const imageData = new Uint8Array([
+                0, 0, 0, 0,  // transparent black
+            ]);
+            const outArray = new Uint8Array(1);
+            computeGray(imageData, outArray);
+            // Result should be 255 (white) because alpha=0
+            expect(outArray[0]).to.equal(255);
+            // Alpha channel should NOT be modified (imageData not used after computeGray)
+            expect(imageData[3]).to.equal(0);
+        });
+
+        it('should handle transparent white as white', () => {
+            // Transparent white (255,255,255,0) should still be white
+            const imageData = new Uint8Array([
+                255, 255, 255, 0,  // transparent white
+            ]);
+            const outArray = new Uint8Array(1);
+            computeGray(imageData, outArray);
+            // Result should be 255 (white)
+            expect(outArray[0]).to.equal(255);
+            // Alpha channel should NOT be modified
+            expect(imageData[3]).to.equal(0);
+        });
+
+        it('should handle semi-transparent pixels by their RGB value', () => {
+            // Semi-transparent red (255,0,0,128) should use RGB red luminance
+            const imageData = new Uint8Array([
+                255, 0, 0, 128,  // semi-transparent red
+            ]);
+            const outArray = new Uint8Array(1);
+            computeGray(imageData, outArray);
+            // Result should be red luminance (~76), alpha=128 is not fully transparent
+            expect(outArray[0]).to.be.closeTo(76, 1);
+            // Alpha channel should NOT be modified (not fully transparent)
+            expect(imageData[3]).to.equal(128);
+        });
+
+        it('should handle fully opaque pixels with various alpha values', () => {
+            // Same RGB but different alpha should produce same grayscale output (if not alpha=0)
+            const imageData = new Uint8Array([
+                255, 0, 0, 255,  // fully opaque red
+                255, 0, 0, 128,  // semi-transparent red
+                255, 0, 0, 1,    // barely opaque red
+            ]);
+            const outArray = new Uint8Array(3);
+            computeGray(imageData, outArray);
+            // All three should produce the same grayscale red luminance (none are alpha=0)
+            expect(outArray[0]).to.be.closeTo(76, 1);
+            expect(outArray[1]).to.be.closeTo(76, 1);
+            expect(outArray[2]).to.be.closeTo(76, 1);
+            // Alpha channels should NOT be modified
+            expect(imageData[3]).to.equal(255);
+            expect(imageData[7]).to.equal(128);
+            expect(imageData[11]).to.equal(1);
+        });
+
+        it('should handle PNG with transparent background and opaque content', () => {
+            // Simulating a PNG: transparent areas + opaque black text
+            const imageData = new Uint8Array([
+                0, 0, 0, 0,      // transparent (background)
+                0, 0, 0, 255,    // opaque black (text)
+                255, 255, 255, 0, // transparent white (background)
+                0, 0, 0, 255,    // opaque black (text)
+            ]);
+            const outArray = new Uint8Array(4);
+            computeGray(imageData, outArray);
+            // All transparent areas (alpha=0) should become white (255) in grayscale output
+            // All opaque areas should use their RGB values
+            expect(outArray[0]).to.equal(255);    // transparent black -> white
+            expect(outArray[1]).to.equal(0);      // opaque black -> black
+            expect(outArray[2]).to.equal(255);    // transparent white -> white
+            expect(outArray[3]).to.equal(0);      // opaque black -> black
+            // Alpha channels should NOT be modified (imageData not used after computeGray)
+            expect(imageData[3]).to.equal(0);     // first pixel alpha (unchanged)
+            expect(imageData[7]).to.equal(255);   // second pixel alpha (unchanged)
+            expect(imageData[11]).to.equal(0);    // third pixel alpha (unchanged)
+            expect(imageData[15]).to.equal(255);  // fourth pixel alpha (unchanged)
+        });
     });
 
     describe('grayAndHalfSampleFromCanvasData', () => {

src/decoder/barcode_decoder.js

@@ -235,6 +235,79 @@ export default {
             }];
         }
 
+        /**
+         * Validate that barcode position is stable across adjacent Y-scanlines.
+         * Real barcodes have consistent start position; tilted barcodes shift left/right as Y changes.
+         * @param {Array} line The original scan line [p1, p2]
+         * @param {Object} result The successful decode result with .start position
+         * @param {Object} reader The reader instance that succeeded
+         * @param {Object} inputImageWrapper The full image data
+         * @returns {boolean} true if barcode position is stable (≥1 adjacent Y-line matches)
+         */
+        function validateAdjacentYLines(line, result, reader, inputImageWrapper) {
+            // Extract original Y position and X start position
+            const originalY = Math.round(line[1].y);
+            const originalXStart = result.start;
+            const constructorFn = reader.constructor;
+            const requiredMatches = (constructorFn && constructorFn.adjacentLineValidationMatches) || 0;
+
+            if (requiredMatches <= 0) {
+                return true;
+            }
+
+            let matchCount = 0;
+            let done = false;
+
+            // Check Y±1, Y±2, Y±3 to see if barcode appears at same X position
+            for (const yOffset of [1, 2, 3]) {
+                if (done) {
+                    break;
+                }
+                for (const direction of [-1, 1]) {
+                    if (done) {
+                        break;
+                    }
+                    const newY = originalY + (yOffset * direction);
+
+                    // Bounds check
+                    if (newY < 0 || newY >= inputImageWrapper.size.y) {
+                        continue;
+                    }
+
+                    // Create new line at adjusted Y, keeping same X range
+                    const newP1 = { x: line[0].x, y: newY };
+                    const newP2 = { x: line[1].x, y: newY };
+
+                    try {
+                        // Extract grayscale at new Y
+                        const newBarcodeLine = Bresenham.getBarcodeLine(inputImageWrapper, newP1, newP2);
+
+                        // Binarize
+                        Bresenham.toBinaryLine(newBarcodeLine);
+
+                        // Set the row for _findStart() to search in
+                        reader._row = newBarcodeLine.line;
+
+                        // Try to find barcode start at this Y
+                        const startFound = reader._findStart();
+
+                        if (startFound !== null && startFound.start === originalXStart) {
+                            matchCount++;
+                            if (matchCount >= requiredMatches) {
+                                done = true;
+                                break;
+                            }
+                        }
+                    } catch (e) {
+                        // Ignore errors, treat failures as "no match" so we can try again on the next line to try
+                    }
+                }
+            }
+
+            const isValid = matchCount >= requiredMatches;
+            return isValid;
+        }
+
         /**
          * Attempts to decode a barcode from a scan line.
          * Readers are tried in order (as specified in config.readers).
@@ -261,12 +334,33 @@ export default {
             }
 
             // Iterate readers in order - first successful decode wins
+            let successfulReaderIndex = -1;
             for (i = 0; i < _barcodeReaders.length && result === null; i++) {
+                // Provide image context to readers that want it (e.g., pharmacode PGM dumps)
+                if (typeof _barcodeReaders[i].setImageWrapper === 'function') {
+                    _barcodeReaders[i].setImageWrapper(inputImageWrapper);
+                }
                 result = _barcodeReaders[i].decodePattern(barcodeLine.line);
+                if (result !== null) {
+                    successfulReaderIndex = i;
+                }
             }
             if (result === null) {
                 return null;
             }
+
+            // Validate that barcode position is stable across adjacent Y-scanlines
+            // This rejects tilted barcodes that only appear valid at one specific angle
+            // Only apply to PharmacodeReader (which explicitly made _findStart public for this validation)
+            if (successfulReaderIndex >= 0 && _barcodeReaders[successfulReaderIndex].constructor.name === 'PharmacodeReader') {
+                if (!validateAdjacentYLines(line, result, _barcodeReaders[successfulReaderIndex], inputImageWrapper)) {
+                    if (typeof process !== 'undefined' && process.env && process.env.NODE_ENV === 'test') {
+                        // console.log(`[DEBUG] REJECTED by adjacent Y-line validation: barcode position unstable (tilted barcode)`);
+                    }
+                    return null;
+                }
+            }
+
             return {
                 codeResult: result,
                 barcodeLine,

src/quagga.js

@@ -153,6 +153,9 @@ const QuaggaJSStaticInterface = {
         return new Promise((resolve, reject) => {
             try {
                 this.init(config, () => {
+                    // Sync the decodeSingle instance's canvas to the global _context so Quagga.canvas works
+                    _context.canvasContainer = quaggaInstance.context.canvasContainer;
+
                     Events.once('processed', (result) => {
                         quaggaInstance.stop();
                         if (resultCallback) {

src/reader/barcode_reader.ts

@@ -47,6 +47,7 @@ export interface Barcode {
     end: number,
     endInfo?: BarcodePosition,
     format: BarcodeFormat,
+    pattern?: string,
     start: number,
     startInfo: BarcodePosition,
     supplement?: Barcode,
@@ -77,6 +78,9 @@ export abstract class BarcodeReader {
         };
     }
 
+    // Reader-specific adjacent-line validation threshold (0 => disabled)
+    static adjacentLineValidationMatches = 0;
+
     constructor(config: BarcodeReaderConfig, supplements?: Array<BarcodeReader>) {
         this._row = [];
         this.config = config || {};