/// <summary>
        /// Gets the closest decoded value.
        /// </summary>
        /// <returns>The closest decoded value.</returns>
        /// <param name="moduleBitCount">Module bit count.</param>
        private static int GetClosestDecodedValue(int[] moduleBitCount)
        {
            int bitCountSum = PDF417Common.GetBitCountSum(moduleBitCount);

            float[] bitCountRatios = new float[PDF417Common.BARS_IN_MODULE];
            for (int i = 0; i < bitCountRatios.Length; i++)
            {
                bitCountRatios[i] = moduleBitCount[i] / (float)bitCountSum;
            }
            float bestMatchError = float.MaxValue;
            int   bestMatch      = PDF417Common.INVALID_CODEWORD;

            for (int j = 0; j < RATIOS_TABLE.Length; j++)
            {
                float error = 0.0f;
                for (int k = 0; k < PDF417Common.BARS_IN_MODULE; k++)
                {
                    float diff = RATIOS_TABLE[j][k] - bitCountRatios[k];
                    error += diff * diff;
                }
                if (error < bestMatchError)
                {
                    bestMatchError = error;
                    bestMatch      = PDF417Common.SYMBOL_TABLE[j];
                }
            }
            return(bestMatch);
        }
        /// <summary>
        /// Gets the closest decoded value.
        /// </summary>
        /// <returns>The closest decoded value.</returns>
        /// <param name="moduleBitCount">Module bit count.</param>
        private static int getClosestDecodedValue(int[] moduleBitCount)
        {
            var bitCountSum    = PDF417Common.getBitCountSum(moduleBitCount);
            var bitCountRatios = new double[PDF417Common.BARS_IN_MODULE];

            for (int i = 0; i < bitCountRatios.Length; i++)
            {
                bitCountRatios[i] = moduleBitCount[i] / (double)bitCountSum;
            }
            var result = RATIOS_TREE.NearestNeighbors(bitCountRatios, 1);

            result.MoveNext();
            return(result.Current);
        }
        /// <summary>
        /// Samples the bit counts.
        /// </summary>
        /// <returns>The bit counts.</returns>
        /// <param name="moduleBitCount">Module bit count.</param>
        private static int[] sampleBitCounts(int[] moduleBitCount)
        {
            float bitCountSum = PDF417Common.getBitCountSum(moduleBitCount);

            int[] result          = new int[PDF417Common.BARS_IN_MODULE];
            int   bitCountIndex   = 0;
            int   sumPreviousBits = 0;

            for (int i = 0; i < PDF417Common.MODULES_IN_CODEWORD; i++)
            {
                float sampleIndex =
                    bitCountSum / (2 * PDF417Common.MODULES_IN_CODEWORD) +
                    (i * bitCountSum) / PDF417Common.MODULES_IN_CODEWORD;
                if (sumPreviousBits + moduleBitCount[bitCountIndex] <= sampleIndex)
                {
                    sumPreviousBits += moduleBitCount[bitCountIndex];
                    bitCountIndex++;
                }
                result[bitCountIndex]++;
            }
            return(result);
        }
Esempio n. 4
0
        /// <summary>
        /// Gets the decoded codeword value.
        /// </summary>
        /// <returns>The decoded codeword value.</returns>
        /// <param name="moduleBitCount">Module bit count.</param>
        private static int getDecodedCodewordValue(int[] moduleBitCount)
        {
            int decodedValue = getBitValue(moduleBitCount);

            return(PDF417Common.getCodeword(decodedValue) == PDF417Common.INVALID_CODEWORD ? PDF417Common.INVALID_CODEWORD : decodedValue);
        }
Esempio n. 5
0
        /// <summary>
        /// Detects the codeword.
        /// </summary>
        /// <returns>The codeword.</returns>
        /// <param name="image">Image.</param>
        /// <param name="minColumn">Minimum column.</param>
        /// <param name="maxColumn">Max column.</param>
        /// <param name="leftToRight">If set to <c>true</c> left to right.</param>
        /// <param name="startColumn">Start column.</param>
        /// <param name="imageRow">Image row.</param>
        /// <param name="minCodewordWidth">Minimum codeword width.</param>
        /// <param name="maxCodewordWidth">Max codeword width.</param>
        private static Codeword detectCodeword(BitMatrix image,
                                               int minColumn,
                                               int maxColumn,
                                               bool leftToRight,
                                               int startColumn,
                                               int imageRow,
                                               int minCodewordWidth,
                                               int maxCodewordWidth)
        {
            startColumn = 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
            int[] moduleBitCount = getModuleBitCount(image, minColumn, maxColumn, leftToRight, startColumn, imageRow);
            if (moduleBitCount == null)
            {
                return(null);
            }
            int endColumn;
            int codewordBitCount = ZXing.Common.Detector.MathUtils.sum(moduleBitCount);

            if (leftToRight)
            {
                endColumn = startColumn + codewordBitCount;
            }
            else
            {
                for (int i = 0; i < (moduleBitCount.Length >> 1); i++)
                {
                    int 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 blackbars 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 (int i = 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 (!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);
            }

            int decodedValue = PDF417CodewordDecoder.getDecodedValue(moduleBitCount);
            int codeword     = PDF417Common.getCodeword(decodedValue);

            if (codeword == -1)
            {
                return(null);
            }
            return(new Codeword(startColumn, endColumn, getCodewordBucketNumber(decodedValue), codeword));
        }