@cloudbase/framework-plugin-low-code 0.4.45 → 0.5.1

package/template/node_modules/@zxing/library/es2015/core/pdf417/decoder/PDF417ScanningDecoder.js

@@ -1,636 +0,0 @@
-/*
-* Copyright 2013 ZXing authors
-*
-* Licensed under the Apache License, Version 2.0 (the "License");
-* you may not use this file except in compliance with the License.
-* You may obtain a copy of the License at
-*
-*      http://www.apache.org/licenses/LICENSE-2.0
-*
-* Unless required by applicable law or agreed to in writing, software
-* distributed under the License is distributed on an "AS IS" BASIS,
-* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-* See the License for the specific language governing permissions and
-* limitations under the License.
-*/
-// package com.google.zxing.pdf417.decoder;
-// import com.google.zxing.ChecksumException;
-import ChecksumException from '../../ChecksumException';
-// import com.google.zxing.FormatException;
-import FormatException from '../../FormatException';
-// import com.google.zxing.NotFoundException;
-import NotFoundException from '../../NotFoundException';
-// import com.google.zxing.common.detector.MathUtils;
-import MathUtils from '../../common/detector/MathUtils';
-// import com.google.zxing.pdf417.PDF417Common;
-import PDF417Common from '../PDF417Common';
-// import com.google.zxing.pdf417.decoder.ec.ErrorCorrection;
-import ErrorCorrection from './ec/ErrorCorrection';
-// local
-import BoundingBox from './BoundingBox';
-import DetectionResultRowIndicatorColumn from './DetectionResultRowIndicatorColumn';
-import DetectionResult from './DetectionResult';
-import DetectionResultColumn from './DetectionResultColumn';
-import Codeword from './Codeword';
-import BarcodeValue from './BarcodeValue';
-import PDF417CodewordDecoder from './PDF417CodewordDecoder';
-import DecodedBitStreamParser from './DecodedBitStreamParser';
-// utils
-import Formatter from '../../util/Formatter';
-// import java.util.ArrayList;
-// import java.util.Collection;
-// import java.util.Formatter;
-// import java.util.List;
-/**
- * @author Guenther Grau
- */
-export default /*public final*/ class PDF417ScanningDecoder {
-    constructor() { }
-    /**
-     * @TODO don't pass in minCodewordWidth and maxCodewordWidth, pass in barcode columns for start and stop pattern
-     *
-     * columns. That way width can be deducted from the pattern column.
-     * This approach also allows to detect more details about the barcode, e.g. if a bar type (white or black) is wider
-     * than it should be. This can happen if the scanner used a bad blackpoint.
-     *
-     * @param BitMatrix
-     * @param image
-     * @param ResultPoint
-     * @param imageTopLeft
-     * @param ResultPoint
-     * @param imageBottomLeft
-     * @param ResultPoint
-     * @param imageTopRight
-     * @param ResultPoint
-     * @param imageBottomRight
-     * @param int
-     * @param minCodewordWidth
-     * @param int
-     * @param maxCodewordWidth
-     *
-     * @throws NotFoundException
-     * @throws FormatException
-     * @throws ChecksumException
-     */
-    static decode(image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight, minCodewordWidth, maxCodewordWidth) {
-        let boundingBox = new BoundingBox(image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight);
-        let leftRowIndicatorColumn = null;
-        let rightRowIndicatorColumn = null;
-        let detectionResult;
-        for (let firstPass /*boolean*/ = true;; firstPass = false) {
-            if (imageTopLeft != null) {
-                leftRowIndicatorColumn = PDF417ScanningDecoder.getRowIndicatorColumn(image, boundingBox, imageTopLeft, true, minCodewordWidth, maxCodewordWidth);
-            }
-            if (imageTopRight != null) {
-                rightRowIndicatorColumn = PDF417ScanningDecoder.getRowIndicatorColumn(image, boundingBox, imageTopRight, false, minCodewordWidth, maxCodewordWidth);
-            }
-            detectionResult = PDF417ScanningDecoder.merge(leftRowIndicatorColumn, rightRowIndicatorColumn);
-            if (detectionResult == null) {
-                throw NotFoundException.getNotFoundInstance();
-            }
-            let resultBox = detectionResult.getBoundingBox();
-            if (firstPass && resultBox != null &&
-                (resultBox.getMinY() < boundingBox.getMinY() || resultBox.getMaxY() > boundingBox.getMaxY())) {
-                boundingBox = resultBox;
-            }
-            else {
-                break;
-            }
-        }
-        detectionResult.setBoundingBox(boundingBox);
-        let maxBarcodeColumn = detectionResult.getBarcodeColumnCount() + 1;
-        detectionResult.setDetectionResultColumn(0, leftRowIndicatorColumn);
-        detectionResult.setDetectionResultColumn(maxBarcodeColumn, rightRowIndicatorColumn);
-        let leftToRight = leftRowIndicatorColumn != null;
-        for (let barcodeColumnCount /*int*/ = 1; barcodeColumnCount <= maxBarcodeColumn; barcodeColumnCount++) {
-            let barcodeColumn = leftToRight ? barcodeColumnCount : maxBarcodeColumn - barcodeColumnCount;
-            if (detectionResult.getDetectionResultColumn(barcodeColumn) !== /* null */ undefined) {
-                // This will be the case for the opposite row indicator column, which doesn't need to be decoded again.
-                continue;
-            }
-            let detectionResultColumn;
-            if (barcodeColumn === 0 || barcodeColumn === maxBarcodeColumn) {
-                detectionResultColumn = new DetectionResultRowIndicatorColumn(boundingBox, barcodeColumn === 0);
-            }
-            else {
-                detectionResultColumn = new DetectionResultColumn(boundingBox);
-            }
-            detectionResult.setDetectionResultColumn(barcodeColumn, detectionResultColumn);
-            let startColumn = -1;
-            let previousStartColumn = startColumn;
-            // TODO start at a row for which we know the start position, then detect upwards and downwards from there.
-            for (let imageRow /*int*/ = boundingBox.getMinY(); imageRow <= boundingBox.getMaxY(); imageRow++) {
-                startColumn = PDF417ScanningDecoder.getStartColumn(detectionResult, barcodeColumn, imageRow, leftToRight);
-                if (startColumn < 0 || startColumn > boundingBox.getMaxX()) {
-                    if (previousStartColumn === -1) {
-                        continue;
-                    }
-                    startColumn = previousStartColumn;
-                }
-                let codeword = PDF417ScanningDecoder.detectCodeword(image, boundingBox.getMinX(), boundingBox.getMaxX(), leftToRight, startColumn, imageRow, minCodewordWidth, maxCodewordWidth);
-                if (codeword != null) {
-                    detectionResultColumn.setCodeword(imageRow, codeword);
-                    previousStartColumn = startColumn;
-                    minCodewordWidth = Math.min(minCodewordWidth, codeword.getWidth());
-                    maxCodewordWidth = Math.max(maxCodewordWidth, codeword.getWidth());
-                }
-            }
-        }
-        return PDF417ScanningDecoder.createDecoderResult(detectionResult);
-    }
-    /**
-     *
-     * @param leftRowIndicatorColumn
-     * @param rightRowIndicatorColumn
-     *
-     * @throws NotFoundException
-     */
-    static merge(leftRowIndicatorColumn, rightRowIndicatorColumn) {
-        if (leftRowIndicatorColumn == null && rightRowIndicatorColumn == null) {
-            return null;
-        }
-        let barcodeMetadata = PDF417ScanningDecoder.getBarcodeMetadata(leftRowIndicatorColumn, rightRowIndicatorColumn);
-        if (barcodeMetadata == null) {
-            return null;
-        }
-        let boundingBox = BoundingBox.merge(PDF417ScanningDecoder.adjustBoundingBox(leftRowIndicatorColumn), PDF417ScanningDecoder.adjustBoundingBox(rightRowIndicatorColumn));
-        return new DetectionResult(barcodeMetadata, boundingBox);
-    }
-    /**
-     *
-     * @param rowIndicatorColumn
-     *
-     * @throws NotFoundException
-     */
-    static adjustBoundingBox(rowIndicatorColumn) {
-        if (rowIndicatorColumn == null) {
-            return null;
-        }
-        let rowHeights = rowIndicatorColumn.getRowHeights();
-        if (rowHeights == null) {
-            return null;
-        }
-        let maxRowHeight = PDF417ScanningDecoder.getMax(rowHeights);
-        let missingStartRows = 0;
-        for (let rowHeight /*int*/ of rowHeights) {
-            missingStartRows += maxRowHeight - rowHeight;
-            if (rowHeight > 0) {
-                break;
-            }
-        }
-        let codewords = rowIndicatorColumn.getCodewords();
-        for (let row /*int*/ = 0; missingStartRows > 0 && codewords[row] == null; row++) {
-            missingStartRows--;
-        }
-        let missingEndRows = 0;
-        for (let row /*int*/ = rowHeights.length - 1; row >= 0; row--) {
-            missingEndRows += maxRowHeight - rowHeights[row];
-            if (rowHeights[row] > 0) {
-                break;
-            }
-        }
-        for (let row /*int*/ = codewords.length - 1; missingEndRows > 0 && codewords[row] == null; row--) {
-            missingEndRows--;
-        }
-        return rowIndicatorColumn.getBoundingBox().addMissingRows(missingStartRows, missingEndRows, rowIndicatorColumn.isLeft());
-    }
-    static getMax(values) {
-        let maxValue = -1;
-        for (let value /*int*/ of values) {
-            maxValue = Math.max(maxValue, value);
-        }
-        return maxValue;
-    }
-    static getBarcodeMetadata(leftRowIndicatorColumn, rightRowIndicatorColumn) {
-        let leftBarcodeMetadata;
-        if (leftRowIndicatorColumn == null ||
-            (leftBarcodeMetadata = leftRowIndicatorColumn.getBarcodeMetadata()) == null) {
-            return rightRowIndicatorColumn == null ? null : rightRowIndicatorColumn.getBarcodeMetadata();
-        }
-        let rightBarcodeMetadata;
-        if (rightRowIndicatorColumn == null ||
-            (rightBarcodeMetadata = rightRowIndicatorColumn.getBarcodeMetadata()) == null) {
-            return leftBarcodeMetadata;
-        }
-        if (leftBarcodeMetadata.getColumnCount() !== rightBarcodeMetadata.getColumnCount() &&
-            leftBarcodeMetadata.getErrorCorrectionLevel() !== rightBarcodeMetadata.getErrorCorrectionLevel() &&
-            leftBarcodeMetadata.getRowCount() !== rightBarcodeMetadata.getRowCount()) {
-            return null;
-        }
-        return leftBarcodeMetadata;
-    }
-    static getRowIndicatorColumn(image, boundingBox, startPoint, leftToRight, minCodewordWidth, maxCodewordWidth) {
-        let rowIndicatorColumn = new DetectionResultRowIndicatorColumn(boundingBox, leftToRight);
-        for (let i /*int*/ = 0; i < 2; i++) {
-            let increment = i === 0 ? 1 : -1;
-            let startColumn = Math.trunc(Math.trunc(startPoint.getX()));
-            for (let imageRow /*int*/ = Math.trunc(Math.trunc(startPoint.getY())); imageRow <= boundingBox.getMaxY() &&
-                imageRow >= boundingBox.getMinY(); imageRow += increment) {
-                let codeword = PDF417ScanningDecoder.detectCodeword(image, 0, image.getWidth(), leftToRight, startColumn, imageRow, minCodewordWidth, maxCodewordWidth);
-                if (codeword != null) {
-                    rowIndicatorColumn.setCodeword(imageRow, codeword);
-                    if (leftToRight) {
-                        startColumn = codeword.getStartX();
-                    }
-                    else {
-                        startColumn = codeword.getEndX();
-                    }
-                }
-            }
-        }
-        return rowIndicatorColumn;
-    }
-    /**
-     *
-     * @param detectionResult
-     * @param BarcodeValue
-     * @param param2
-     * @param param3
-     * @param barcodeMatrix
-     *
-     * @throws NotFoundException
-     */
-    static adjustCodewordCount(detectionResult, barcodeMatrix) {
-        let barcodeMatrix01 = barcodeMatrix[0][1];
-        let numberOfCodewords = barcodeMatrix01.getValue();
-        let calculatedNumberOfCodewords = detectionResult.getBarcodeColumnCount() *
-            detectionResult.getBarcodeRowCount() -
-            PDF417ScanningDecoder.getNumberOfECCodeWords(detectionResult.getBarcodeECLevel());
-        if (numberOfCodewords.length === 0) {
-            if (calculatedNumberOfCodewords < 1 || calculatedNumberOfCodewords > PDF417Common.MAX_CODEWORDS_IN_BARCODE) {
-                throw NotFoundException.getNotFoundInstance();
-            }
-            barcodeMatrix01.setValue(calculatedNumberOfCodewords);
-        }
-        else if (numberOfCodewords[0] !== calculatedNumberOfCodewords) {
-            // The calculated one is more reliable as it is derived from the row indicator columns
-            barcodeMatrix01.setValue(calculatedNumberOfCodewords);
-        }
-    }
-    /**
-     *
-     * @param detectionResult
-     *
-     * @throws FormatException
-     * @throws ChecksumException
-     * @throws NotFoundException
-     */
-    static createDecoderResult(detectionResult) {
-        let barcodeMatrix = PDF417ScanningDecoder.createBarcodeMatrix(detectionResult);
-        PDF417ScanningDecoder.adjustCodewordCount(detectionResult, barcodeMatrix);
-        let erasures /*Collection<Integer>*/ = new Array();
-        let codewords = new Int32Array(detectionResult.getBarcodeRowCount() * detectionResult.getBarcodeColumnCount());
-        let ambiguousIndexValuesList = /*List<int[]>*/ [];
-        let ambiguousIndexesList = /*Collection<Integer>*/ new Array();
-        for (let row /*int*/ = 0; row < detectionResult.getBarcodeRowCount(); row++) {
-            for (let column /*int*/ = 0; column < detectionResult.getBarcodeColumnCount(); column++) {
-                let values = barcodeMatrix[row][column + 1].getValue();
-                let codewordIndex = row * detectionResult.getBarcodeColumnCount() + column;
-                if (values.length === 0) {
-                    erasures.push(codewordIndex);
-                }
-                else if (values.length === 1) {
-                    codewords[codewordIndex] = values[0];
-                }
-                else {
-                    ambiguousIndexesList.push(codewordIndex);
-                    ambiguousIndexValuesList.push(values);
-                }
-            }
-        }
-        let ambiguousIndexValues = new Array(ambiguousIndexValuesList.length);
-        for (let i /*int*/ = 0; i < ambiguousIndexValues.length; i++) {
-            ambiguousIndexValues[i] = ambiguousIndexValuesList[i];
-        }
-        return PDF417ScanningDecoder.createDecoderResultFromAmbiguousValues(detectionResult.getBarcodeECLevel(), codewords, PDF417Common.toIntArray(erasures), PDF417Common.toIntArray(ambiguousIndexesList), ambiguousIndexValues);
-    }
-    /**
-     * This method deals with the fact, that the decoding process doesn't always yield a single most likely value. The
-     * current error correction implementation doesn't deal with erasures very well, so it's better to provide a value
-     * for these ambiguous codewords instead of treating it as an erasure. The problem is that we don't know which of
-     * the ambiguous values to choose. We try decode using the first value, and if that fails, we use another of the
-     * ambiguous values and try to decode again. This usually only happens on very hard to read and decode barcodes,
-     * so decoding the normal barcodes is not affected by this.
-     *
-     * @param erasureArray contains the indexes of erasures
-     * @param ambiguousIndexes array with the indexes that have more than one most likely value
-     * @param ambiguousIndexValues two dimensional array that contains the ambiguous values. The first dimension must
-     * be the same length as the ambiguousIndexes array
-     *
-     * @throws FormatException
-     * @throws ChecksumException
-     */
-    static createDecoderResultFromAmbiguousValues(ecLevel, codewords, erasureArray, ambiguousIndexes, ambiguousIndexValues) {
-        let ambiguousIndexCount = new Int32Array(ambiguousIndexes.length);
-        let tries = 100;
-        while (tries-- > 0) {
-            for (let i /*int*/ = 0; i < ambiguousIndexCount.length; i++) {
-                codewords[ambiguousIndexes[i]] = ambiguousIndexValues[i][ambiguousIndexCount[i]];
-            }
-            try {
-                return PDF417ScanningDecoder.decodeCodewords(codewords, ecLevel, erasureArray);
-            }
-            catch (err) {
-                let ignored = err instanceof ChecksumException;
-                if (!ignored) {
-                    throw err;
-                }
-            }
-            if (ambiguousIndexCount.length === 0) {
-                throw ChecksumException.getChecksumInstance();
-            }
-            for (let i /*int*/ = 0; i < ambiguousIndexCount.length; i++) {
-                if (ambiguousIndexCount[i] < ambiguousIndexValues[i].length - 1) {
-                    ambiguousIndexCount[i]++;
-                    break;
-                }
-                else {
-                    ambiguousIndexCount[i] = 0;
-                    if (i === ambiguousIndexCount.length - 1) {
-                        throw ChecksumException.getChecksumInstance();
-                    }
-                }
-            }
-        }
-        throw ChecksumException.getChecksumInstance();
-    }
-    static createBarcodeMatrix(detectionResult) {
-        // let barcodeMatrix: BarcodeValue[][] =
-        // new BarcodeValue[detectionResult.getBarcodeRowCount()][detectionResult.getBarcodeColumnCount() + 2];
-        let barcodeMatrix = Array.from({ length: detectionResult.getBarcodeRowCount() }, () => new Array(detectionResult.getBarcodeColumnCount() + 2));
-        for (let row /*int*/ = 0; row < barcodeMatrix.length; row++) {
-            for (let column /*int*/ = 0; column < barcodeMatrix[row].length; column++) {
-                barcodeMatrix[row][column] = new BarcodeValue();
-            }
-        }
-        let column = 0;
-        for (let detectionResultColumn /*DetectionResultColumn*/ of detectionResult.getDetectionResultColumns()) {
-            if (detectionResultColumn != null) {
-                for (let codeword /*Codeword*/ of detectionResultColumn.getCodewords()) {
-                    if (codeword != null) {
-                        let rowNumber = codeword.getRowNumber();
-                        if (rowNumber >= 0) {
-                            if (rowNumber >= barcodeMatrix.length) {
-                                // We have more rows than the barcode metadata allows for, ignore them.
-                                continue;
-                            }
-                            barcodeMatrix[rowNumber][column].setValue(codeword.getValue());
-                        }
-                    }
-                }
-            }
-            column++;
-        }
-        return barcodeMatrix;
-    }
-    static isValidBarcodeColumn(detectionResult, barcodeColumn) {
-        return barcodeColumn >= 0 && barcodeColumn <= detectionResult.getBarcodeColumnCount() + 1;
-    }
-    static getStartColumn(detectionResult, barcodeColumn, imageRow, leftToRight) {
-        let offset = leftToRight ? 1 : -1;
-        let codeword = null;
-        if (PDF417ScanningDecoder.isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
-            codeword = detectionResult.getDetectionResultColumn(barcodeColumn - offset).getCodeword(imageRow);
-        }
-        if (codeword != null) {
-            return leftToRight ? codeword.getEndX() : codeword.getStartX();
-        }
-        codeword = detectionResult.getDetectionResultColumn(barcodeColumn).getCodewordNearby(imageRow);
-        if (codeword != null) {
-            return leftToRight ? codeword.getStartX() : codeword.getEndX();
-        }
-        if (PDF417ScanningDecoder.isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
-            codeword = detectionResult.getDetectionResultColumn(barcodeColumn - offset).getCodewordNearby(imageRow);
-        }
-        if (codeword != null) {
-            return leftToRight ? codeword.getEndX() : codeword.getStartX();
-        }
-        let skippedColumns = 0;
-        while (PDF417ScanningDecoder.isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
-            barcodeColumn -= offset;
-            for (let previousRowCodeword /*Codeword*/ of detectionResult.getDetectionResultColumn(barcodeColumn).getCodewords()) {
-                if (previousRowCodeword != null) {
-                    return (leftToRight ? previousRowCodeword.getEndX() : previousRowCodeword.getStartX()) +
-                        offset *
-                            skippedColumns *
-                            (previousRowCodeword.getEndX() - previousRowCodeword.getStartX());
-                }
-            }
-            skippedColumns++;
-        }
-        return leftToRight ? detectionResult.getBoundingBox().getMinX() : detectionResult.getBoundingBox().getMaxX();
-    }
-    static detectCodeword(image, minColumn, maxColumn, leftToRight, startColumn, imageRow, minCodewordWidth, maxCodewordWidth) {
-        startColumn = PDF417ScanningDecoder.adjustCodewordStartColumn(image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
-        // we usually know fairly exact now how long a codeword is. We should provide minimum and maximum expected length
-        // and try to adjust the read pixels, e.g. remove single pixel errors or try to cut off exceeding pixels.
-        // min and maxCodewordWidth should not be used as they are calculated for the whole barcode an can be inaccurate
-        // for the current position
-        let moduleBitCount = PDF417ScanningDecoder.getModuleBitCount(image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
-        if (moduleBitCount == null) {
-            return null;
-        }
-        let endColumn;
-        let codewordBitCount = MathUtils.sum(moduleBitCount);
-        if (leftToRight) {
-            endColumn = startColumn + codewordBitCount;
-        }
-        else {
-            for (let i /*int*/ = 0; i < moduleBitCount.length / 2; i++) {
-                let tmpCount = moduleBitCount[i];
-                moduleBitCount[i] = moduleBitCount[moduleBitCount.length - 1 - i];
-                moduleBitCount[moduleBitCount.length - 1 - i] = tmpCount;
-            }
-            endColumn = startColumn;
-            startColumn = endColumn - codewordBitCount;
-        }
-        // TODO implement check for width and correction of black and white bars
-        // use start (and maybe stop pattern) to determine if black bars are wider than white bars. If so, adjust.
-        // should probably done only for codewords with a lot more than 17 bits.
-        // The following fixes 10-1.png, which has wide black bars and small white bars
-        //    for (let i /*int*/ = 0; i < moduleBitCount.length; i++) {
-        //      if (i % 2 === 0) {
-        //        moduleBitCount[i]--;
-        //      } else {
-        //        moduleBitCount[i]++;
-        //      }
-        //    }
-        // We could also use the width of surrounding codewords for more accurate results, but this seems
-        // sufficient for now
-        if (!PDF417ScanningDecoder.checkCodewordSkew(codewordBitCount, minCodewordWidth, maxCodewordWidth)) {
-            // We could try to use the startX and endX position of the codeword in the same column in the previous row,
-            // create the bit count from it and normalize it to 8. This would help with single pixel errors.
-            return null;
-        }
-        let decodedValue = PDF417CodewordDecoder.getDecodedValue(moduleBitCount);
-        let codeword = PDF417Common.getCodeword(decodedValue);
-        if (codeword === -1) {
-            return null;
-        }
-        return new Codeword(startColumn, endColumn, PDF417ScanningDecoder.getCodewordBucketNumber(decodedValue), codeword);
-    }
-    static getModuleBitCount(image, minColumn, maxColumn, leftToRight, startColumn, imageRow) {
-        let imageColumn = startColumn;
-        let moduleBitCount = new Int32Array(8);
-        let moduleNumber = 0;
-        let increment = leftToRight ? 1 : -1;
-        let previousPixelValue = leftToRight;
-        while ((leftToRight ? imageColumn < maxColumn : imageColumn >= minColumn) &&
-            moduleNumber < moduleBitCount.length) {
-            if (image.get(imageColumn, imageRow) === previousPixelValue) {
-                moduleBitCount[moduleNumber]++;
-                imageColumn += increment;
-            }
-            else {
-                moduleNumber++;
-                previousPixelValue = !previousPixelValue;
-            }
-        }
-        if (moduleNumber === moduleBitCount.length ||
-            ((imageColumn === (leftToRight ? maxColumn : minColumn)) &&
-                moduleNumber === moduleBitCount.length - 1)) {
-            return moduleBitCount;
-        }
-        return null;
-    }
-    static getNumberOfECCodeWords(barcodeECLevel) {
-        return 2 << barcodeECLevel;
-    }
-    static adjustCodewordStartColumn(image, minColumn, maxColumn, leftToRight, codewordStartColumn, imageRow) {
-        let correctedStartColumn = codewordStartColumn;
-        let increment = leftToRight ? -1 : 1;
-        // there should be no black pixels before the start column. If there are, then we need to start earlier.
-        for (let i /*int*/ = 0; i < 2; i++) {
-            while ((leftToRight ? correctedStartColumn >= minColumn : correctedStartColumn < maxColumn) &&
-                leftToRight === image.get(correctedStartColumn, imageRow)) {
-                if (Math.abs(codewordStartColumn - correctedStartColumn) > PDF417ScanningDecoder.CODEWORD_SKEW_SIZE) {
-                    return codewordStartColumn;
-                }
-                correctedStartColumn += increment;
-            }
-            increment = -increment;
-            leftToRight = !leftToRight;
-        }
-        return correctedStartColumn;
-    }
-    static checkCodewordSkew(codewordSize, minCodewordWidth, maxCodewordWidth) {
-        return minCodewordWidth - PDF417ScanningDecoder.CODEWORD_SKEW_SIZE <= codewordSize &&
-            codewordSize <= maxCodewordWidth + PDF417ScanningDecoder.CODEWORD_SKEW_SIZE;
-    }
-    /**
-     * @throws FormatException,
-     * @throws ChecksumException
-     */
-    static decodeCodewords(codewords, ecLevel, erasures) {
-        if (codewords.length === 0) {
-            throw FormatException.getFormatInstance();
-        }
-        let numECCodewords = 1 << (ecLevel + 1);
-        let correctedErrorsCount = PDF417ScanningDecoder.correctErrors(codewords, erasures, numECCodewords);
-        PDF417ScanningDecoder.verifyCodewordCount(codewords, numECCodewords);
-        // Decode the codewords
-        let decoderResult = DecodedBitStreamParser.decode(codewords, '' + ecLevel);
-        decoderResult.setErrorsCorrected(correctedErrorsCount);
-        decoderResult.setErasures(erasures.length);
-        return decoderResult;
-    }
-    /**
-     * <p>Given data and error-correction codewords received, possibly corrupted by errors, attempts to
-     * correct the errors in-place.</p>
-     *
-     * @param codewords   data and error correction codewords
-     * @param erasures positions of any known erasures
-     * @param numECCodewords number of error correction codewords that are available in codewords
-     * @throws ChecksumException if error correction fails
-     */
-    static correctErrors(codewords, erasures, numECCodewords) {
-        if (erasures != null &&
-            erasures.length > numECCodewords / 2 + PDF417ScanningDecoder.MAX_ERRORS ||
-            numECCodewords < 0 ||
-            numECCodewords > PDF417ScanningDecoder.MAX_EC_CODEWORDS) {
-            // Too many errors or EC Codewords is corrupted
-            throw ChecksumException.getChecksumInstance();
-        }
-        return PDF417ScanningDecoder.errorCorrection.decode(codewords, numECCodewords, erasures);
-    }
-    /**
-     * Verify that all is OK with the codeword array.
-     * @throws FormatException
-     */
-    static verifyCodewordCount(codewords, numECCodewords) {
-        if (codewords.length < 4) {
-            // Codeword array size should be at least 4 allowing for
-            // Count CW, At least one Data CW, Error Correction CW, Error Correction CW
-            throw FormatException.getFormatInstance();
-        }
-        // The first codeword, the Symbol Length Descriptor, shall always encode the total number of data
-        // codewords in the symbol, including the Symbol Length Descriptor itself, data codewords and pad
-        // codewords, but excluding the number of error correction codewords.
-        let numberOfCodewords = codewords[0];
-        if (numberOfCodewords > codewords.length) {
-            throw FormatException.getFormatInstance();
-        }
-        if (numberOfCodewords === 0) {
-            // Reset to the length of the array - 8 (Allow for at least level 3 Error Correction (8 Error Codewords)
-            if (numECCodewords < codewords.length) {
-                codewords[0] = codewords.length - numECCodewords;
-            }
-            else {
-                throw FormatException.getFormatInstance();
-            }
-        }
-    }
-    static getBitCountForCodeword(codeword) {
-        let result = new Int32Array(8);
-        let previousValue = 0;
-        let i = result.length - 1;
-        while (true) {
-            if ((codeword & 0x1) !== previousValue) {
-                previousValue = codeword & 0x1;
-                i--;
-                if (i < 0) {
-                    break;
-                }
-            }
-            result[i]++;
-            codeword >>= 1;
-        }
-        return result;
-    }
-    static getCodewordBucketNumber(codeword) {
-        if (codeword instanceof Int32Array) {
-            return this.getCodewordBucketNumber_Int32Array(codeword);
-        }
-        return this.getCodewordBucketNumber_number(codeword);
-    }
-    static getCodewordBucketNumber_number(codeword) {
-        return PDF417ScanningDecoder.getCodewordBucketNumber(PDF417ScanningDecoder.getBitCountForCodeword(codeword));
-    }
-    static getCodewordBucketNumber_Int32Array(moduleBitCount) {
-        return (moduleBitCount[0] - moduleBitCount[2] + moduleBitCount[4] - moduleBitCount[6] + 9) % 9;
-    }
-    static toString(barcodeMatrix) {
-        let formatter = new Formatter();
-        // try (let formatter = new Formatter()) {
-        for (let row /*int*/ = 0; row < barcodeMatrix.length; row++) {
-            formatter.format('Row %2d: ', row);
-            for (let column /*int*/ = 0; column < barcodeMatrix[row].length; column++) {
-                let barcodeValue = barcodeMatrix[row][column];
-                if (barcodeValue.getValue().length === 0) {
-                    formatter.format('        ', null);
-                }
-                else {
-                    formatter.format('%4d(%2d)', barcodeValue.getValue()[0], barcodeValue.getConfidence(barcodeValue.getValue()[0]));
-                }
-            }
-            formatter.format('%n');
-        }
-        return formatter.toString();
-        // }
-    }
-}
-/*final*/ PDF417ScanningDecoder.CODEWORD_SKEW_SIZE = 2;
-/*final*/ PDF417ScanningDecoder.MAX_ERRORS = 3;
-/*final*/ PDF417ScanningDecoder.MAX_EC_CODEWORDS = 512;
-/*final*/ PDF417ScanningDecoder.errorCorrection = new ErrorCorrection();
-//# sourceMappingURL=PDF417ScanningDecoder.js.map