Java BitMatrix.set方法代码示例

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * Get BitMatrix
 *
 * @param matrix BitMatrix
 * @param margin margin
 * @return BitMatrix
 */
public static BitMatrix updateBit(BitMatrix matrix, int margin) {
    int tempM = margin * 2;
    int[] rec = matrix.getEnclosingRectangle();   //Gets the properties of the two-dimensional code pattern
    int resWidth = rec[2] + tempM;
    int resHeight = rec[3] + tempM;
    BitMatrix resMatrix = new BitMatrix(resWidth, resHeight); //Generates a new BitMatrix according to the custom borders
    resMatrix.clear();
    for (int i = margin; i < resWidth - margin; i++) {   //Loop to draw the 2D code pattern into the new bitMatrix
        for (int j = margin; j < resHeight - margin; j++) {
            if (matrix.get(i - margin + rec[0], j - margin + rec[1])) {
                resMatrix.set(i, j);
            }
        }
    }
    return resMatrix;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static void drawBullsEye(BitMatrix matrix, int center, int size) {
  for (int i = 0; i < size; i += 2) {
    for (int j = center - i; j <= center + i; j++) {
      matrix.set(j, center - i);
      matrix.set(j, center + i);
      matrix.set(center - i, j);
      matrix.set(center + i, j);
    }
  }
  matrix.set(center - size, center - size);
  matrix.set(center - size + 1, center - size);
  matrix.set(center - size, center - size + 1);
  matrix.set(center + size, center - size);
  matrix.set(center + size, center - size + 1);
  matrix.set(center + size, center + size - 1);
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * Convert the ByteMatrix to BitMatrix.
 *
 * @param matrix The input matrix.
 * @return The output matrix.
 */
private static BitMatrix convertByteMatrixToBitMatrix(ByteMatrix matrix) {
  int matrixWidgth = matrix.getWidth();
  int matrixHeight = matrix.getHeight();

  BitMatrix output = new BitMatrix(matrixWidgth, matrixHeight);
  output.clear();
  for (int i = 0; i < matrixWidgth; i++) {
    for (int j = 0; j < matrixHeight; j++) {
      // Zero is white in the bytematrix
      if (matrix.get(i, j) == 1) {
        output.set(i, j);
      }
    }
  }

  return output;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * This method detects a code in a "pure" image -- that is, pure monochrome image
 * which contains only an unrotated, unskewed, image of a code, with some white border
 * around it. This is a specialized method that works exceptionally fast in this special
 * case.
 *
 * @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
 * @see com.google.zxing.qrcode.QRCodeReader#extractPureBits(BitMatrix)
 */
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {
  
  int[] enclosingRectangle = image.getEnclosingRectangle();
  if (enclosingRectangle == null) {
    throw NotFoundException.getNotFoundInstance();
  }
  
  int left = enclosingRectangle[0];
  int top = enclosingRectangle[1];
  int width = enclosingRectangle[2];
  int height = enclosingRectangle[3];

  // Now just read off the bits
  BitMatrix bits = new BitMatrix(MATRIX_WIDTH, MATRIX_HEIGHT);
  for (int y = 0; y < MATRIX_HEIGHT; y++) {
    int iy = top + (y * height + height / 2) / MATRIX_HEIGHT;
    for (int x = 0; x < MATRIX_WIDTH; x++) {
      int ix = left + (x * width + width / 2 + (y & 0x01) *  width / 2) / MATRIX_WIDTH;
      if (image.get(ix, iy)) {
        bits.set(x, y);
      }
    }
  }
  return bits;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static BitMatrix bitMatrixFrombitArray(byte[][] input) {
    BitMatrix output = new BitMatrix(input[0].length + 60, input.length + 60);
    output.clear();
    int y = 0;
    int yOutput = output.getHeight() - 30;
    while (y < input.length) {
        for (int x = 0; x < input[0].length; x++) {
            if (input[y][x] == (byte) 1) {
                output.set(x + 30, yOutput);
            }
        }
        y++;
        yOutput--;
    }
    return output;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static BitMatrix bitMatrixFrombitArray(byte[][] input, int margin) {
    BitMatrix output = new BitMatrix(input[0].length + (margin * 2), input.length + (margin *
            2));
    output.clear();
    int y = 0;
    int yOutput = (output.getHeight() - margin) - 1;
    while (y < input.length) {
        for (int x = 0; x < input[0].length; x++) {
            if (input[y][x] == (byte) 1) {
                output.set(x + margin, yOutput);
            }
        }
        y++;
        yOutput--;
    }
    return output;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {
    int[] enclosingRectangle = image.getEnclosingRectangle();
    if (enclosingRectangle == null) {
        throw NotFoundException.getNotFoundInstance();
    }
    int left = enclosingRectangle[0];
    int top = enclosingRectangle[1];
    int width = enclosingRectangle[2];
    int height = enclosingRectangle[3];
    BitMatrix bits = new BitMatrix(30, 33);
    for (int y = 0; y < 33; y++) {
        int iy = top + (((y * height) + (height / 2)) / 33);
        for (int x = 0; x < 30; x++) {
            if (image.get(left + ((((x * width) + (width / 2)) + (((y & 1) * width) / 2)) /
                    30), iy)) {
                bits.set(x, y);
            }
        }
    }
    return bits;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * This takes an array holding the values of the PDF 417
 *
 * @param input a byte array of information with 0 is black, and 1 is white
 * @param margin border around the barcode
 * @return BitMatrix of the input
 */
private static BitMatrix bitMatrixFrombitArray(byte[][] input, int margin) {
  // Creates the bitmatrix with extra space for whitespace
  BitMatrix output = new BitMatrix(input[0].length + 2 * margin, input.length + 2 * margin);
  output.clear();
  for (int y = 0, yOutput = output.getHeight() - margin - 1; y < input.length; y++, yOutput--) {
    for (int x = 0; x < input[0].length; x++) {
      // Zero is white in the bytematrix
      if (input[y][x] == 1) {
        output.set(x + margin, yOutput);
      }
    }
  }
  return output;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * <p>Convenience method that can decode a QR Code represented as a 2D array of booleans.
 * "true" is taken to mean a black module.</p>
 *
 * @param image booleans representing white/black QR Code modules
 * @param hints decoding hints that should be used to influence decoding
 * @return text and bytes encoded within the QR Code
 * @throws FormatException if the QR Code cannot be decoded
 * @throws ChecksumException if error correction fails
 */
public DecoderResult decode(boolean[][] image, Map<DecodeHintType,?> hints)
    throws ChecksumException, FormatException {
  int dimension = image.length;
  BitMatrix bits = new BitMatrix(dimension);
  for (int i = 0; i < dimension; i++) {
    for (int j = 0; j < dimension; j++) {
      if (image[i][j]) {
        bits.set(j, i);
      }
    }
  }
  return decode(bits, hints);
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * <p>Extracts the data region from a {@link BitMatrix} that contains
 * alignment patterns.</p>
 * 
 * @param bitMatrix Original {@link BitMatrix} with alignment patterns
 * @return BitMatrix that has the alignment patterns removed
 */
BitMatrix extractDataRegion(BitMatrix bitMatrix) {
  int symbolSizeRows = version.getSymbolSizeRows();
  int symbolSizeColumns = version.getSymbolSizeColumns();
  
  if (bitMatrix.getHeight() != symbolSizeRows) {
    throw new IllegalArgumentException("Dimension of bitMarix must match the version size");
  }
  
  int dataRegionSizeRows = version.getDataRegionSizeRows();
  int dataRegionSizeColumns = version.getDataRegionSizeColumns();
  
  int numDataRegionsRow = symbolSizeRows / dataRegionSizeRows;
  int numDataRegionsColumn = symbolSizeColumns / dataRegionSizeColumns;
  
  int sizeDataRegionRow = numDataRegionsRow * dataRegionSizeRows;
  int sizeDataRegionColumn = numDataRegionsColumn * dataRegionSizeColumns;
  
  BitMatrix bitMatrixWithoutAlignment = new BitMatrix(sizeDataRegionColumn, sizeDataRegionRow);
  for (int dataRegionRow = 0; dataRegionRow < numDataRegionsRow; ++dataRegionRow) {
    int dataRegionRowOffset = dataRegionRow * dataRegionSizeRows;
    for (int dataRegionColumn = 0; dataRegionColumn < numDataRegionsColumn; ++dataRegionColumn) {
      int dataRegionColumnOffset = dataRegionColumn * dataRegionSizeColumns;
      for (int i = 0; i < dataRegionSizeRows; ++i) {
        int readRowOffset = dataRegionRow * (dataRegionSizeRows + 2) + 1 + i;
        int writeRowOffset = dataRegionRowOffset + i;
        for (int j = 0; j < dataRegionSizeColumns; ++j) {
          int readColumnOffset = dataRegionColumn * (dataRegionSizeColumns + 2) + 1 + j;
          if (bitMatrix.get(readColumnOffset, readRowOffset)) {
            int writeColumnOffset = dataRegionColumnOffset + j;
            bitMatrixWithoutAlignment.set(writeColumnOffset, writeRowOffset);
          }
        }
      }
    }
  }
  return bitMatrixWithoutAlignment;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
/**
 * <p>Convenience method that can decode a Data Matrix Code represented as a 2D array of booleans.
 * "true" is taken to mean a black module.</p>
 *
 * @param image booleans representing white/black Data Matrix Code modules
 * @return text and bytes encoded within the Data Matrix Code
 * @throws FormatException if the Data Matrix Code cannot be decoded
 * @throws ChecksumException if error correction fails
 */
public DecoderResult decode(boolean[][] image) throws FormatException, ChecksumException {
  int dimension = image.length;
  BitMatrix bits = new BitMatrix(dimension);
  for (int i = 0; i < dimension; i++) {
    for (int j = 0; j < dimension; j++) {
      if (image[i][j]) {
        bits.set(j, i);
      }
    }
  }
  return decode(bits);
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
public static BitMatrix deleteWhite(BitMatrix matrix){
	int[] rec = matrix.getEnclosingRectangle();
	int resWidth = rec[2] + 1;
	int resHeight = rec[3] + 1;

	BitMatrix resMatrix = new BitMatrix(resWidth, resHeight);
	resMatrix.clear();
	for (int i = 0; i < resWidth; i++) {
		for (int j = 0; j < resHeight; j++) {
			if (matrix.get(i + rec[0], j + rec[1]))
				resMatrix.set(i, j);
		}
	}
	return resMatrix;
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
public DecoderResult decode(boolean[][] image, Map<DecodeHintType, ?> hints) throws
        ChecksumException, FormatException {
    int dimension = image.length;
    BitMatrix bits = new BitMatrix(dimension);
    for (int i = 0; i < dimension; i++) {
        for (int j = 0; j < dimension; j++) {
            if (image[i][j]) {
                bits.set(j, i);
            }
        }
    }
    return decode(bits, (Map) hints);
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static void drawModeMessage(BitMatrix matrix, boolean compact, int matrixSize,
                                    BitArray modeMessage) {
    int center = matrixSize / 2;
    int i;
    int offset;
    if (compact) {
        for (i = 0; i < 7; i++) {
            offset = (center - 3) + i;
            if (modeMessage.get(i)) {
                matrix.set(offset, center - 5);
            }
            if (modeMessage.get(i + 7)) {
                matrix.set(center + 5, offset);
            }
            if (modeMessage.get(20 - i)) {
                matrix.set(offset, center + 5);
            }
            if (modeMessage.get(27 - i)) {
                matrix.set(center - 5, offset);
            }
        }
        return;
    }
    for (i = 0; i < 10; i++) {
        offset = ((center - 5) + i) + (i / 5);
        if (modeMessage.get(i)) {
            matrix.set(offset, center - 7);
        }
        if (modeMessage.get(i + 10)) {
            matrix.set(center + 7, offset);
        }
        if (modeMessage.get(29 - i)) {
            matrix.set(offset, center + 7);
        }
        if (modeMessage.get(39 - i)) {
            matrix.set(center - 7, offset);
        }
    }
}
 

import com.google.zxing.common.BitMatrix; //导入方法依赖的package包/类
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {
    int[] leftTopBlack = image.getTopLeftOnBit();
    int[] rightBottomBlack = image.getBottomRightOnBit();
    if (leftTopBlack == null || rightBottomBlack == null) {
        throw NotFoundException.getNotFoundInstance();
    }
    int moduleSize = moduleSize(leftTopBlack, image);
    int top = leftTopBlack[1];
    int bottom = rightBottomBlack[1];
    int left = leftTopBlack[0];
    int matrixWidth = ((rightBottomBlack[0] - left) + 1) / moduleSize;
    int matrixHeight = ((bottom - top) + 1) / moduleSize;
    if (matrixWidth <= 0 || matrixHeight <= 0) {
        throw NotFoundException.getNotFoundInstance();
    }
    int nudge = moduleSize / 2;
    top += nudge;
    left += nudge;
    BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight);
    for (int y = 0; y < matrixHeight; y++) {
        int iOffset = top + (y * moduleSize);
        for (int x = 0; x < matrixWidth; x++) {
            if (image.get((x * moduleSize) + left, iOffset)) {
                bits.set(x, y);
            }
        }
    }
    return bits;
}