Examples with BitArray com.google.zxing.common.BitArray used on opensource projects

Example 1 with BitArray

use of com.google.zxing.common.BitArray in project weex-example by KalicyZhou.

the class Encoder method generateCheckWords.

private static BitArray generateCheckWords(BitArray bitArray, int totalBits, int wordSize) {
    // bitArray is guaranteed to be a multiple of the wordSize, so no padding needed
    int messageSizeInWords = bitArray.getSize() / wordSize;
    ReedSolomonEncoder rs = new ReedSolomonEncoder(getGF(wordSize));
    int totalWords = totalBits / wordSize;
    int[] messageWords = bitsToWords(bitArray, wordSize, totalWords);
    rs.encode(messageWords, totalWords - messageSizeInWords);
    int startPad = totalBits % wordSize;
    BitArray messageBits = new BitArray();
    messageBits.appendBits(0, startPad);
    for (int messageWord : messageWords) {
        messageBits.appendBits(messageWord, wordSize);
    }
    return messageBits;
}

Example 2 with BitArray

use of com.google.zxing.common.BitArray in project weex-example by KalicyZhou.

the class Encoder method stuffBits.

static BitArray stuffBits(BitArray bits, int wordSize) {
    BitArray out = new BitArray();
    int n = bits.getSize();
    int mask = (1 << wordSize) - 2;
    for (int i = 0; i < n; i += wordSize) {
        int word = 0;
        for (int j = 0; j < wordSize; j++) {
            if (i + j >= n || bits.get(i + j)) {
                word |= 1 << (wordSize - 1 - j);
            }
        }
        if ((word & mask) == mask) {
            out.appendBits(word & mask, wordSize);
            i--;
        } else if ((word & mask) == 0) {
            out.appendBits(word | 1, wordSize);
            i--;
        } else {
            out.appendBits(word, wordSize);
        }
    }
    return out;
}

Example 3 with BitArray

use of com.google.zxing.common.BitArray in project weex-example by KalicyZhou.

the class Encoder method encode.

/**
   * Encodes the given binary content as an Aztec symbol
   * 
   * @param data input data string
   * @param minECCPercent minimal percentage of error check words (According to ISO/IEC 24778:2008,
   *                      a minimum of 23% + 3 words is recommended)
   * @param userSpecifiedLayers if non-zero, a user-specified value for the number of layers
   * @return Aztec symbol matrix with metadata
   */
public static AztecCode encode(byte[] data, int minECCPercent, int userSpecifiedLayers) {
    // High-level encode
    BitArray bits = new HighLevelEncoder(data).encode();
    // stuff bits and choose symbol size
    int eccBits = bits.getSize() * minECCPercent / 100 + 11;
    int totalSizeBits = bits.getSize() + eccBits;
    boolean compact;
    int layers;
    int totalBitsInLayer;
    int wordSize;
    BitArray stuffedBits;
    if (userSpecifiedLayers != DEFAULT_AZTEC_LAYERS) {
        compact = userSpecifiedLayers < 0;
        layers = Math.abs(userSpecifiedLayers);
        if (layers > (compact ? MAX_NB_BITS_COMPACT : MAX_NB_BITS)) {
            throw new IllegalArgumentException(String.format("Illegal value %s for layers", userSpecifiedLayers));
        }
        totalBitsInLayer = totalBitsInLayer(layers, compact);
        wordSize = WORD_SIZE[layers];
        int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
        stuffedBits = stuffBits(bits, wordSize);
        if (stuffedBits.getSize() + eccBits > usableBitsInLayers) {
            throw new IllegalArgumentException("Data to large for user specified layer");
        }
        if (compact && stuffedBits.getSize() > wordSize * 64) {
            // Compact format only allows 64 data words, though C4 can hold more words than that
            throw new IllegalArgumentException("Data to large for user specified layer");
        }
    } else {
        wordSize = 0;
        stuffedBits = null;
        // is the same size, but has more data.
        for (int i = 0; ; i++) {
            if (i > MAX_NB_BITS) {
                throw new IllegalArgumentException("Data too large for an Aztec code");
            }
            compact = i <= 3;
            layers = compact ? i + 1 : i;
            totalBitsInLayer = totalBitsInLayer(layers, compact);
            if (totalSizeBits > totalBitsInLayer) {
                continue;
            }
            // wordSize has changed
            if (wordSize != WORD_SIZE[layers]) {
                wordSize = WORD_SIZE[layers];
                stuffedBits = stuffBits(bits, wordSize);
            }
            int usableBitsInLayers = totalBitsInLayer - (totalBitsInLayer % wordSize);
            if (compact && stuffedBits.getSize() > wordSize * 64) {
                // Compact format only allows 64 data words, though C4 can hold more words than that
                continue;
            }
            if (stuffedBits.getSize() + eccBits <= usableBitsInLayers) {
                break;
            }
        }
    }
    BitArray messageBits = generateCheckWords(stuffedBits, totalBitsInLayer, wordSize);
    // generate mode message
    int messageSizeInWords = stuffedBits.getSize() / wordSize;
    BitArray modeMessage = generateModeMessage(compact, layers, messageSizeInWords);
    // allocate symbol
    // not including alignment lines
    int baseMatrixSize = compact ? 11 + layers * 4 : 14 + layers * 4;
    int[] alignmentMap = new int[baseMatrixSize];
    int matrixSize;
    if (compact) {
        // no alignment marks in compact mode, alignmentMap is a no-op
        matrixSize = baseMatrixSize;
        for (int i = 0; i < alignmentMap.length; i++) {
            alignmentMap[i] = i;
        }
    } else {
        matrixSize = baseMatrixSize + 1 + 2 * ((baseMatrixSize / 2 - 1) / 15);
        int origCenter = baseMatrixSize / 2;
        int center = matrixSize / 2;
        for (int i = 0; i < origCenter; i++) {
            int newOffset = i + i / 15;
            alignmentMap[origCenter - i - 1] = center - newOffset - 1;
            alignmentMap[origCenter + i] = center + newOffset + 1;
        }
    }
    BitMatrix matrix = new BitMatrix(matrixSize);
    // draw data bits
    for (int i = 0, rowOffset = 0; i < layers; i++) {
        int rowSize = compact ? (layers - i) * 4 + 9 : (layers - i) * 4 + 12;
        for (int j = 0; j < rowSize; j++) {
            int columnOffset = j * 2;
            for (int k = 0; k < 2; k++) {
                if (messageBits.get(rowOffset + columnOffset + k)) {
                    matrix.set(alignmentMap[i * 2 + k], alignmentMap[i * 2 + j]);
                }
                if (messageBits.get(rowOffset + rowSize * 2 + columnOffset + k)) {
                    matrix.set(alignmentMap[i * 2 + j], alignmentMap[baseMatrixSize - 1 - i * 2 - k]);
                }
                if (messageBits.get(rowOffset + rowSize * 4 + columnOffset + k)) {
                    matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - k], alignmentMap[baseMatrixSize - 1 - i * 2 - j]);
                }
                if (messageBits.get(rowOffset + rowSize * 6 + columnOffset + k)) {
                    matrix.set(alignmentMap[baseMatrixSize - 1 - i * 2 - j], alignmentMap[i * 2 + k]);
                }
            }
        }
        rowOffset += rowSize * 8;
    }
    // draw mode message
    drawModeMessage(matrix, compact, matrixSize, modeMessage);
    // draw alignment marks
    if (compact) {
        drawBullsEye(matrix, matrixSize / 2, 5);
    } else {
        drawBullsEye(matrix, matrixSize / 2, 7);
        for (int i = 0, j = 0; i < baseMatrixSize / 2 - 1; i += 15, j += 16) {
            for (int k = (matrixSize / 2) & 1; k < matrixSize; k += 2) {
                matrix.set(matrixSize / 2 - j, k);
                matrix.set(matrixSize / 2 + j, k);
                matrix.set(k, matrixSize / 2 - j);
                matrix.set(k, matrixSize / 2 + j);
            }
        }
    }
    AztecCode aztec = new AztecCode();
    aztec.setCompact(compact);
    aztec.setSize(matrixSize);
    aztec.setLayers(layers);
    aztec.setCodeWords(messageSizeInWords);
    aztec.setMatrix(matrix);
    return aztec;
}

Example 4 with BitArray

use of com.google.zxing.common.BitArray in project weex-example by KalicyZhou.

the class Encoder method generateModeMessage.

static BitArray generateModeMessage(boolean compact, int layers, int messageSizeInWords) {
    BitArray modeMessage = new BitArray();
    if (compact) {
        modeMessage.appendBits(layers - 1, 2);
        modeMessage.appendBits(messageSizeInWords - 1, 6);
        modeMessage = generateCheckWords(modeMessage, 28, 4);
    } else {
        modeMessage.appendBits(layers - 1, 5);
        modeMessage.appendBits(messageSizeInWords - 1, 11);
        modeMessage = generateCheckWords(modeMessage, 40, 4);
    }
    return modeMessage;
}

Example 5 with BitArray

use of com.google.zxing.common.BitArray in project weex-example by KalicyZhou.

the class State method toBitArray.

BitArray toBitArray(byte[] text) {
    // Reverse the tokens, so that they are in the order that they should
    // be output
    Deque<Token> symbols = new LinkedList<>();
    for (Token token = endBinaryShift(text.length).token; token != null; token = token.getPrevious()) {
        symbols.addFirst(token);
    }
    BitArray bitArray = new BitArray();
    // Add each token to the result.
    for (Token symbol : symbols) {
        symbol.appendTo(bitArray, text);
    }
    //assert bitArray.getSize() == this.bitCount;
    return bitArray;
}