示例#1
0
        /**
         * Revert the mask removal done while reading the code words. The bit matrix should revert to its original state.
         */
        internal void remask()
        {
            if (parsedFormatInfo == null)
            {
                return; // We have no format information, and have no data mask
            }
            int      dimension = bitMatrix.Height;
            DataMask dataMask  = DataMask.forReference((int)parsedFormatInfo.DataMask);

            dataMask.unmaskBitMatrix(bitMatrix, dimension);
        }
示例#2
0
        /// <summary> <p>Reads the bits in the {@link BitMatrix} representing the finder pattern in the
        /// correct order in order to reconstruct the codewords bytes contained within the
        /// QR Code.</p>
        ///
        /// </summary>
        /// <returns> bytes encoded within the QR Code
        /// </returns>
        /// <throws>  ReaderException if the exact number of bytes expected is not read </throws>
        internal byte[] readCodewords()
        {
            FormatInformation formatInfo = readFormatInformation();

            if (formatInfo == null)
            {
                return(null);
            }
            Version version = readVersion();

            if (version == null)
            {
                return(null);
            }

            // Get the data mask for the format used in this QR Code. This will exclude
            // some bits from reading as we wind through the bit matrix.
            int      dimension = bitMatrix.Height;
            DataMask dataMask  = DataMask.forReference((int)formatInfo.DataMask);

            dataMask.unmaskBitMatrix(bitMatrix, dimension);

            BitMatrix functionPattern = version.buildFunctionPattern();

            bool readingUp = true;

            byte[] result       = new byte[version.TotalCodewords];
            int    resultOffset = 0;
            int    currentByte  = 0;
            int    bitsRead     = 0;

            //D3 in a Version M1 symbol, D11 in a Version M3-L symbol and D9
            //in a Version M3-M symbol is a 2 ¡Á 2 square 4-module block.
            int  numVersion    = version.VersionNumber;
            int  ecl           = formatInfo.ErrorCorrectionLevel.ordinal();
            bool has4mblock    = numVersion == 1 || numVersion == 3;
            int  _4mblockIndex = numVersion == 1 ? 3 : ecl == 1 ? 11 : 9;


            // Read columns in pairs, from right to left
            for (int j = dimension - 1; j > 0; j -= 2)
            {
                // Read alternatingly from bottom to top then top to bottom
                for (int count = 1; count < dimension; count++)
                {
                    int i = readingUp ? dimension - count : count;
                    for (int col = 0; col < 2; col++)
                    {
                        // Ignore bits covered by the function pattern
                        if (!functionPattern[j - col, i])
                        {
                            // Read a bit
                            bitsRead++;
                            currentByte <<= 1;
                            if (bitMatrix[j - col, i])
                            {
                                currentByte |= 1;
                            }
                            // If we've made a whole byte, save it off
                            if (bitsRead == 8 || (bitsRead == 4 && has4mblock && (_4mblockIndex - 1) == resultOffset))
                            {
                                result[resultOffset++] = (byte)currentByte;
                                bitsRead    = 0;
                                currentByte = 0;
                            }
                        }
                    }
                }
                readingUp ^= true; // readingUp = !readingUp; // switch directions
            }
            if (resultOffset != version.TotalCodewords)
            {
                return(null);
            }
            return(result);
        }