Java Code Examples for com.google.zxing.common.BitMatrix#set()

private static BitMatrix updateBit(BitMatrix matrix, int margin){
    int tempM = margin*2;
    int[] rec = matrix.getEnclosingRectangle();   //获取二维码图案的属性
    int resWidth = rec[2] + tempM;
    int resHeight = rec[3] + tempM;
    BitMatrix resMatrix = new BitMatrix(resWidth, resHeight); // 按照自定义边框生成新的BitMatrix
    resMatrix.clear();
    for(int i= margin; i < resWidth- margin; i++){   //循环，将二维码图案绘制到新的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;
}
 

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);
}
 

public DecoderResult decode(boolean aflag[][])
{
    int i = aflag.length;
    BitMatrix bitmatrix = new BitMatrix(i);
    for (int j = 0; j < i; j++)
    {
        for (int k = 0; k < i; k++)
        {
            if (aflag[j][k])
            {
                bitmatrix.set(k, j);
            }
        }

    }

    return decode(bitmatrix);
}
 

public DecoderResult decode(boolean aflag[][], Map map)
{
    int i = aflag.length;
    BitMatrix bitmatrix = new BitMatrix(i);
    for (int j = 0; j < i; j++)
    {
        for (int k = 0; k < i; k++)
        {
            if (aflag[j][k])
            {
                bitmatrix.set(k, j);
            }
        }

    }

    return decode(bitmatrix, map);
}
 

public DecoderResult decode(boolean aflag[][])
{
    int i = aflag.length;
    BitMatrix bitmatrix = new BitMatrix(i);
    for (int j = 0; j < i; j++)
    {
        for (int k = 0; k < i; k++)
        {
            if (aflag[k][j])
            {
                bitmatrix.set(k, j);
            }
        }

    }

    return decode(bitmatrix);
}
 

private static BitMatrix a(byte abyte0[][])
{
    BitMatrix bitmatrix = new BitMatrix(60 + abyte0.length, 60 + abyte0[0].length);
    bitmatrix.clear();
    for (int i = 0; i < abyte0.length; i++)
    {
        for (int j = 0; j < abyte0[0].length; j++)
        {
            if (abyte0[i][j] == 1)
            {
                bitmatrix.set(i + 30, j + 30);
            }
        }

    }

    return bitmatrix;
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

/**
 * 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;
}
 

private static BitMatrix a(BitMatrix bitmatrix)
{
    int ai[] = bitmatrix.getTopLeftOnBit();
    int ai1[] = bitmatrix.getBottomRightOnBit();
    if (ai == null || ai1 == null)
    {
        throw NotFoundException.getNotFoundInstance();
    }
    int i = a(ai, bitmatrix);
    int j = ai[1];
    int k = ai1[1];
    int l = a(ai[0], j, bitmatrix);
    int i1 = (1 + (b(ai[0], j, bitmatrix) - l)) / i;
    int j1 = (1 + (k - j)) / i;
    if (i1 <= 0 || j1 <= 0)
    {
        throw NotFoundException.getNotFoundInstance();
    }
    int k1 = i >> 1;
    int l1 = j + k1;
    int i2 = l + k1;
    BitMatrix bitmatrix1 = new BitMatrix(i1, j1);
    for (int j2 = 0; j2 < j1; j2++)
    {
        int k2 = l1 + j2 * i;
        for (int l2 = 0; l2 < i1; l2++)
        {
            if (bitmatrix.get(i2 + l2 * i, k2))
            {
                bitmatrix1.set(l2, j2);
            }
        }

    }

    return bitmatrix1;
}
 

/**
 * 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;
}
 

/**
 * <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);
}
 

/**
 * Transforms an Aztec code matrix by removing the control dashed lines
 */
private static BitMatrix removeDashedLines(BitMatrix matrix) {
  int nbDashed = 1 + 2 * ((matrix.getWidth() - 1) / 2 / 16);
  BitMatrix newMatrix = new BitMatrix(matrix.getWidth() - nbDashed, matrix.getHeight() - nbDashed);

  int nx = 0;

  for (int x = 0; x < matrix.getWidth(); x++) {

    if ((matrix.getWidth() / 2 - x) % 16 == 0) {
      continue;
    }

    int ny = 0;
    for (int y = 0; y < matrix.getHeight(); y++) {

      if ((matrix.getWidth() / 2 - y) % 16 == 0) {
        continue;
      }

      if (matrix.get(x, y)) {
        newMatrix.set(nx, ny);
      }
      ny++;
    }
    nx++;
  }

  return newMatrix;
}
 

/**
 * <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;
}
 

/**
 * 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.
 */
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {

  int[] leftTopBlack = image.getTopLeftOnBit();
  int[] rightBottomBlack = image.getBottomRightOnBit();
  if (leftTopBlack == null || rightBottomBlack == null) {
    throw NotFoundException.getNotFoundInstance();
  }

  float moduleSize = moduleSize(leftTopBlack, image);

  int top = leftTopBlack[1];
  int bottom = rightBottomBlack[1];
  int left = leftTopBlack[0];
  int right = rightBottomBlack[0];

  // Sanity check!
  if (left >= right || top >= bottom) {
    throw NotFoundException.getNotFoundInstance();
  }

  if (bottom - top != right - left) {
    // Special case, where bottom-right module wasn't black so we found something else in the last row
    // Assume it's a square, so use height as the width
    right = left + (bottom - top);
    if (right >= image.getWidth()) {
      // Abort if that would not make sense -- off image
      throw NotFoundException.getNotFoundInstance();
    }
  }

  int matrixWidth = Math.round((right - left + 1) / moduleSize);
  int matrixHeight = Math.round((bottom - top + 1) / moduleSize);
  if (matrixWidth <= 0 || matrixHeight <= 0) {
    throw NotFoundException.getNotFoundInstance();
  }
  if (matrixHeight != matrixWidth) {
    // Only possibly decode square regions
    throw NotFoundException.getNotFoundInstance();
  }

  // Push in the "border" by half the module width so that we start
  // sampling in the middle of the module. Just in case the image is a
  // little off, this will help recover.
  int nudge = (int) (moduleSize / 2.0f);
  top += nudge;
  left += nudge;

  // But careful that this does not sample off the edge
  // "right" is the farthest-right valid pixel location -- right+1 is not necessarily
  // This is positive by how much the inner x loop below would be too large
  int nudgedTooFarRight = left + (int) ((matrixWidth - 1) * moduleSize) - right;
  if (nudgedTooFarRight > 0) {
    if (nudgedTooFarRight > nudge) {
      // Neither way fits; abort
      throw NotFoundException.getNotFoundInstance();
    }
    left -= nudgedTooFarRight;
  }
  // See logic above
  int nudgedTooFarDown = top + (int) ((matrixHeight - 1) * moduleSize) - bottom;
  if (nudgedTooFarDown > 0) {
    if (nudgedTooFarDown > nudge) {
      // Neither way fits; abort
      throw NotFoundException.getNotFoundInstance();
    }
    top -= nudgedTooFarDown;
  }

  // Now just read off the bits
  BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight, 1);
  for (int y = 0; y < matrixHeight; y++) {
    int iOffset = top + (int) (y * moduleSize);
    for (int x = 0; x < matrixWidth; x++) {
      if (image.get(left + (int) (x * moduleSize), iOffset)) {
        bits.set(x, y);
      }
    }
  }
  return bits;
}
 

/**
 * 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.pdf417.PDF417Reader#extractPureBits(BitMatrix)
 * @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
 */
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 right = rightBottomBlack[0];

    if (bottom - top != right - left) {
        // Special case, where bottom-right module wasn't black so we found
        // something else in
        // the last row
        // Assume it's a square, so use height as the width
        right = left + (bottom - top);
    }

    int matrixWidth = (right - left + 1) / moduleSize;
    int matrixHeight = (bottom - top + 1) / moduleSize;
    if (matrixWidth <= 0 || matrixHeight <= 0) {
        throw NotFoundException.getNotFoundInstance();
    }
    if (matrixHeight != matrixWidth) {
        // Only possibly decode square regions
        throw NotFoundException.getNotFoundInstance();
    }

    // Push in the "border" by half the module width so that we start
    // sampling in the middle of the module. Just in case the image is a
    // little off, this will help recover.
    int nudge = moduleSize >> 1;
    top += nudge;
    left += nudge;

    // Now just read off the bits
    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(left + x * moduleSize, iOffset)) {
                bits.set(x, y);
            }
        }
    }
    return bits;
}
 

/**
 * 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.pdf417.PDF417Reader#extractPureBits(BitMatrix)
 * @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
 */
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {

  int[] leftTopBlack = image.getTopLeftOnBit();
  int[] rightBottomBlack = image.getBottomRightOnBit();
  if (leftTopBlack == null || rightBottomBlack == null) {
    throw NotFoundException.getNotFoundInstance();
  }

  float moduleSize = moduleSize(leftTopBlack, image);

  int top = leftTopBlack[1];
  int bottom = rightBottomBlack[1];
  int left = leftTopBlack[0];
  int right = rightBottomBlack[0];

  if (bottom - top != right - left) {
    // Special case, where bottom-right module wasn't black so we found something else in the last row
    // Assume it's a square, so use height as the width
    right = left + (bottom - top);
  }

  int matrixWidth = Math.round((right - left + 1) / moduleSize);
  int matrixHeight = Math.round((bottom - top + 1) / moduleSize);
  if (matrixWidth <= 0 || matrixHeight <= 0) {
    throw NotFoundException.getNotFoundInstance();
  }
  if (matrixHeight != matrixWidth) {
    // Only possibly decode square regions
    throw NotFoundException.getNotFoundInstance();
  }

  // Push in the "border" by half the module width so that we start
  // sampling in the middle of the module. Just in case the image is a
  // little off, this will help recover.
  int nudge = (int) (moduleSize / 2.0f);
  top += nudge;
  left += nudge;

  // Now just read off the bits
  BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight);
  for (int y = 0; y < matrixHeight; y++) {
    int iOffset = top + (int) (y * moduleSize);
    for (int x = 0; x < matrixWidth; x++) {
      if (image.get(left + (int) (x * moduleSize), iOffset)) {
        bits.set(x, y);
      }
    }
  }
  return bits;
}
 

/**
 * 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)
 */
private static BitMatrix extractPureBits(BitMatrix image) throws NotFoundException {

  int[] leftTopBlack = image.getTopLeftOnBit();
  int[] rightBottomBlack = image.getBottomRightOnBit();
  if (leftTopBlack == null || rightBottomBlack == null) {
    throw NotFoundException.getNotFoundInstance();
  }

  float moduleSize = moduleSize(leftTopBlack, image);

  int top = leftTopBlack[1];
  int bottom = rightBottomBlack[1];
  int left = leftTopBlack[0];
  int right = rightBottomBlack[0];
  
  // Sanity check!
  if (left >= right || top >= bottom) {
    throw NotFoundException.getNotFoundInstance();
  }

  if (bottom - top != right - left) {
    // Special case, where bottom-right module wasn't black so we found something else in the last row
    // Assume it's a square, so use height as the width
    right = left + (bottom - top);
    if (right >= image.getWidth()) {
      // Abort if that would not make sense -- off image
      throw NotFoundException.getNotFoundInstance();
    }
  }

  int matrixWidth = Math.round((right - left + 1) / moduleSize);
  int matrixHeight = Math.round((bottom - top + 1) / moduleSize);
  if (matrixWidth <= 0 || matrixHeight <= 0) {
    throw NotFoundException.getNotFoundInstance();
  }
  if (matrixHeight != matrixWidth) {
    // Only possibly decode square regions
    throw NotFoundException.getNotFoundInstance();
  }

  // Push in the "border" by half the module width so that we start
  // sampling in the middle of the module. Just in case the image is a
  // little off, this will help recover.
  int nudge = (int) (moduleSize / 2.0f);
  top += nudge;
  left += nudge;
  
  // But careful that this does not sample off the edge
  // "right" is the farthest-right valid pixel location -- right+1 is not necessarily
  // This is positive by how much the inner x loop below would be too large
  int nudgedTooFarRight = left + (int) ((matrixWidth - 1) * moduleSize) - right;
  if (nudgedTooFarRight > 0) {
    if (nudgedTooFarRight > nudge) {
      // Neither way fits; abort
      throw NotFoundException.getNotFoundInstance();
    }
    left -= nudgedTooFarRight;
  }
  // See logic above
  int nudgedTooFarDown = top + (int) ((matrixHeight - 1) * moduleSize) - bottom;
  if (nudgedTooFarDown > 0) {
    if (nudgedTooFarDown > nudge) {
      // Neither way fits; abort
      throw NotFoundException.getNotFoundInstance();
    }
    top -= nudgedTooFarDown;
  }

  // Now just read off the bits
  BitMatrix bits = new BitMatrix(matrixWidth, matrixHeight);
  for (int y = 0; y < matrixHeight; y++) {
    int iOffset = top + (int) (y * moduleSize);
    for (int x = 0; x < matrixWidth; x++) {
      if (image.get(left + (int) (x * moduleSize), iOffset)) {
        bits.set(x, y);
      }
    }
  }
  return bits;
}
 

/**
 * 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.qrcode.QRCodeReader#extractPureBits(BitMatrix)
 * @see com.google.zxing.datamatrix.DataMatrixReader#extractPureBits(BitMatrix)
 */
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 = findPatternStart(leftTopBlack[0], top, image);
  int right = findPatternEnd(leftTopBlack[0], top, image);

  int matrixWidth = (right - left + 1) / moduleSize;
  int matrixHeight = (bottom - top + 1) / moduleSize;
  if (matrixWidth <= 0 || matrixHeight <= 0) {
    throw NotFoundException.getNotFoundInstance();
  }

  // Push in the "border" by half the module width so that we start
  // sampling in the middle of the module. Just in case the image is a
  // little off, this will help recover.
  int nudge = moduleSize >> 1;
  top += nudge;
  left += nudge;

  // Now just read off the bits
  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(left + x * moduleSize, iOffset)) {
        bits.set(x, y);
      }
    }
  }
  return bits;
}
 

/**
 * <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
 * @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);
}