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

private static BitMatrix renderResult(AztecCode code, int width, int height) {
  BitMatrix input = code.getMatrix();
  if (input == null) {
    throw new IllegalStateException();
  }
  int inputWidth = input.getWidth();
  int inputHeight = input.getHeight();
  int outputWidth = Math.max(width, inputWidth);
  int outputHeight = Math.max(height, inputHeight);

  int multiple = Math.min(outputWidth / inputWidth, outputHeight / inputHeight);
  int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
  int topPadding = (outputHeight - (inputHeight * multiple)) / 2;

  BitMatrix output = new BitMatrix(outputWidth, outputHeight);

  for (int inputY = 0, outputY = topPadding; inputY < inputHeight; inputY++, outputY += multiple) {
    // Write the contents of this row of the barcode
    for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
      if (input.get(inputX, inputY)) {
        output.setRegion(outputX, outputY, multiple, multiple);
      }
    }
  }
  return output;
}
 

private static float moduleSize(int[] leftTopBlack, BitMatrix image) throws NotFoundException {
  int height = image.getHeight();
  int width = image.getWidth();
  int x = leftTopBlack[0];
  int y = leftTopBlack[1];
  boolean inBlack = true;
  int transitions = 0;
  while (x < width && y < height) {
    if (inBlack != image.get(x, y)) {
      if (++transitions == 5) {
        break;
      }
      inBlack = !inBlack;
    }
    x++;
    y++;
  }
  if (x == width || y == height) {
    throw NotFoundException.getNotFoundInstance();
  }
  return (x - leftTopBlack[0]) / 7.0f;
}
 

private static BitMatrix renderResult(AztecCode code, int width, int height) {
  BitMatrix input = code.getMatrix();
  if (input == null) {
    throw new IllegalStateException();
  }
  int inputWidth = input.getWidth();
  int inputHeight = input.getHeight();
  int outputWidth = Math.max(width, inputWidth);
  int outputHeight = Math.max(height, inputHeight);

  int multiple = Math.min(outputWidth / inputWidth, outputHeight / inputHeight);
  int leftPadding = (outputWidth - (inputWidth * multiple)) / 2;
  int topPadding = (outputHeight - (inputHeight * multiple)) / 2;

  BitMatrix output = new BitMatrix(outputWidth, outputHeight);

  for (int inputY = 0, outputY = topPadding; inputY < inputHeight; inputY++, outputY += multiple) {
    // Write the contents of this row of the barcode
    for (int inputX = 0, outputX = leftPadding; inputX < inputWidth; inputX++, outputX += multiple) {
      if (input.get(inputX, inputY)) {
        output.setRegion(outputX, outputY, multiple, multiple);
      }
    }
  }
  return output;
}
 

private Bitmap bitMatrix2Bitmap(BitMatrix matrix,int colorBg) {
    int w = matrix.getWidth();
    int h = matrix.getHeight();
    int[] rawData = new int[w * h];
    for (int i = 0; i < w; i++) {
        for (int j = 0; j < h; j++) {
            int color = colorBg;
            if (matrix.get(i, j)) {
                color = Color.BLACK;
            }
            rawData[i + (j * w)] = color;
        }
    }

    Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565);
    bitmap.setPixels(rawData, 0, w, 0, 0, w, h);
    return bitmap;
}
 

public BufferedImage getImage(BitMatrix matrix, Color onColor) 
{
	int width = matrix.getWidth();
	int height = matrix.getHeight();
	BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_ARGB);
	int onArgb = JRColorUtil.getOpaqueArgb(onColor, Color.BLACK);//not actually opaque
	for (int x = 0; x < width; x++) 
	{
		for (int y = 0; y < height; y++) 
		{
			if (matrix.get(x, y))
			{
				image.setRGB(x, y, onArgb);
			}
		}
	}
	return image;
}
 

public static Bitmap createQRCode(String str, int widthAndHeight) throws WriterException {
	Hashtable<EncodeHintType, String> hints = new Hashtable<EncodeHintType, String>();
       hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
	BitMatrix matrix = new MultiFormatWriter().encode(str,
			BarcodeFormat.QR_CODE, widthAndHeight, widthAndHeight);
	int width = matrix.getWidth();
	int height = matrix.getHeight();
	int[] pixels = new int[width * height];
	
	for (int y = 0; y < height; y++) {
		for (int x = 0; x < width; x++) {
			if (matrix.get(x, y)) {
				pixels[y * width + x] = BLACK;
			}
		}
	}
	Bitmap bitmap = Bitmap.createBitmap(width, height,
			Bitmap.Config.ARGB_8888);
	bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
	return bitmap;
}
 

public WhiteRectangleDetector(BitMatrix bitmatrix, int j, int k, int l)
{
    c = bitmatrix;
    d = bitmatrix.getHeight();
    e = bitmatrix.getWidth();
    int i1 = j >> 1;
    f = k - i1;
    g = k + i1;
    i = l - i1;
    h = i1 + l;
    if (i < 0 || f < 0 || h >= d || g >= e)
    {
        throw NotFoundException.getNotFoundInstance();
    } else
    {
        return;
    }
}
 

private static Bitmap bitMatrix2Bitmap(BitMatrix matrix) {
    int w = matrix.getWidth();
    int h = matrix.getHeight();
    int[] rawData = new int[w * h];
    for (int i = 0; i < w; i++) {
        for (int j = 0; j < h; j++) {
            int color = Color.WHITE;
            if (matrix.get(i, j)) {
                color = Color.BLACK;
            }
            rawData[i + (j * w)] = color;
        }
    }
    Bitmap bitmap = Bitmap.createBitmap(w, h, Bitmap.Config.RGB_565);
    bitmap.setPixels(rawData, 0, w, 0, 0, w, h);
    return bitmap;
}
 

private static BufferedImage toBufferedImage(BitMatrix matrix) {
    int width = matrix.getWidth();
    int height = matrix.getHeight();
    BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
    for (int x = 0; x < width; x++) {
        for (int y = 0; y < height; y++) {
            image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
        }
    }
    return image;
}
 

/**
 * As {@link #toBufferedImage(BitMatrix)}, but allows customization of the output.
 *
 * @param matrix {@link BitMatrix} to write
 * @param config output configuration
 * @return {@link BufferedImage} representation of the input
 */
public static BufferedImage toBufferedImage(BitMatrix matrix, MatrixToImageConfig config) {
  int width = matrix.getWidth();
  int height = matrix.getHeight();
  BufferedImage image = new BufferedImage(width, height, config.getBufferedImageColorModel());
  int onColor = config.getPixelOnColor();
  int offColor = config.getPixelOffColor();
  for (int x = 0; x < width; x++) {
    for (int y = 0; y < height; y++) {
      image.setRGB(x, y, matrix.get(x, y) ? onColor : offColor);
    }
  }
  return image;
}
 

private static BufferedImage toBufferedImage(BitMatrix matrix) {
	int width = matrix.getWidth();
	int height = matrix.getHeight();
	BufferedImage image = new BufferedImage(width, height, BufferedImage.TYPE_INT_RGB);
	for (int x = 0; x < width; x++) {
		for (int y = 0; y < height; y++) {
			image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
		}
	}
	return image;
}
 

/**
 * @param bitMatrix {@link BitMatrix} to parse
 * @throws FormatException if dimension is not >= 21 and 1 mod 4
 */
BitMatrixParser(BitMatrix bitMatrix) throws FormatException {
  int dimension = bitMatrix.getHeight();
  if (dimension < 21 || (dimension & 0x03) != 1) {
    throw FormatException.getFormatInstance();
  }
  this.bitMatrix = bitMatrix;
}
 

Bitmap encodeAsBitmap() throws WriterException {
  String contentsToEncode = contents;
  if (contentsToEncode == null) {
    return null;
  }
  Map<EncodeHintType,Object> hints = null;
  String encoding = guessAppropriateEncoding(contentsToEncode);
  if (encoding != null) {
    hints = new EnumMap<>(EncodeHintType.class);
    hints.put(EncodeHintType.CHARACTER_SET, encoding);
  }
  BitMatrix result;
  try {
    result = new MultiFormatWriter().encode(contentsToEncode, format, dimension, dimension, hints);
  } catch (IllegalArgumentException iae) {
    // Unsupported format
    return null;
  }
  int width = result.getWidth();
  int height = result.getHeight();
  int[] pixels = new int[width * height];
  for (int y = 0; y < height; y++) {
    int offset = y * width;
    for (int x = 0; x < width; x++) {
      pixels[offset + x] = result.get(x, y) ? BLACK : WHITE;
    }
  }

  Bitmap bitmap = Bitmap.createBitmap(width, height, Bitmap.Config.ARGB_8888);
  bitmap.setPixels(pixels, 0, width, 0, 0, width, height);
  return bitmap;
}
 

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

private Image buildImage(BarcodeFormat format,String data,int w,int h){
       try{
       	Map<EncodeHintType, Object> hints = new Hashtable<EncodeHintType, Object>();  
           hints.put(EncodeHintType.CHARACTER_SET, "utf-8");
           hints.put(EncodeHintType.MARGIN,0);
           if(format.equals(BarcodeFormat.QR_CODE)){
           	hints.put(EncodeHintType.ERROR_CORRECTION, ErrorCorrectionLevel.H);            	
           }
           BitMatrix matrix = new MultiFormatWriter().encode(data,format, w, h,hints);
           int width = matrix.getWidth();  
           int height = matrix.getHeight();
           BufferedImage image = new BufferedImage(width, height,BufferedImage.TYPE_INT_ARGB);
           for (int x = 0; x < width; x++) {
           	for (int y = 0; y < height; y++) {
           		image.setRGB(x, y, matrix.get(x, y) ? BLACK : WHITE);
           	}
           }
           ByteArrayOutputStream outputStream = new ByteArrayOutputStream();
           ImageIO.write(image, "png", outputStream);
           byte[] bytes=outputStream.toByteArray();
           String base64Data=Base64Utils.encodeToString(bytes);
           IOUtils.closeQuietly(outputStream);
           return new Image(base64Data,w,h);
       }catch(Exception ex){
       	throw new ReportComputeException(ex);
       }
}
 

/**
 * <p>After a horizontal scan finds a potential alignment pattern, this method
 * "cross-checks" by scanning down vertically through the center of the possible
 * alignment pattern to see if the same proportion is detected.</p>
 *
 * @param startI row where an alignment pattern was detected
 * @param centerJ center of the section that appears to cross an alignment pattern
 * @param maxCount maximum reasonable number of modules that should be
 * observed in any reading state, based on the results of the horizontal scan
 * @return vertical center of alignment pattern, or {@link Float#NaN} if not found
 */
private float crossCheckVertical(int startI, int centerJ, int maxCount,
    int originalStateCountTotal) {
  BitMatrix image = this.image;

  int maxI = image.getHeight();
  int[] stateCount = crossCheckStateCount;
  stateCount[0] = 0;
  stateCount[1] = 0;
  stateCount[2] = 0;

  // Start counting up from center
  int i = startI;
  while (i >= 0 && image.get(centerJ, i) && stateCount[1] <= maxCount) {
    stateCount[1]++;
    i--;
  }
  // If already too many modules in this state or ran off the edge:
  if (i < 0 || stateCount[1] > maxCount) {
    return Float.NaN;
  }
  while (i >= 0 && !image.get(centerJ, i) && stateCount[0] <= maxCount) {
    stateCount[0]++;
    i--;
  }
  if (stateCount[0] > maxCount) {
    return Float.NaN;
  }

  // Now also count down from center
  i = startI + 1;
  while (i < maxI && image.get(centerJ, i) && stateCount[1] <= maxCount) {
    stateCount[1]++;
    i++;
  }
  if (i == maxI || stateCount[1] > maxCount) {
    return Float.NaN;
  }
  while (i < maxI && !image.get(centerJ, i) && stateCount[2] <= maxCount) {
    stateCount[2]++;
    i++;
  }
  if (stateCount[2] > maxCount) {
    return Float.NaN;
  }

  int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2];
  if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
    return Float.NaN;
  }

  return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : Float.NaN;
}
 

public WhiteRectangleDetector(BitMatrix image) throws NotFoundException {
	this(image, INIT_SIZE, image.getWidth() / 2, image.getHeight() / 2);
}
 

/**
 * <p>After a horizontal scan finds a potential finder pattern, this method
 * "cross-checks" by scanning down vertically through the center of the possible
 * finder pattern to see if the same proportion is detected.</p>
 *
 * @param startI row where a finder pattern was detected
 * @param centerJ center of the section that appears to cross a finder pattern
 * @param maxCount maximum reasonable number of modules that should be
 * observed in any reading state, based on the results of the horizontal scan
 * @return vertical center of finder pattern, or {@link Float#NaN} if not found
 */
private float crossCheckVertical(int startI, int centerJ, int maxCount,
    int originalStateCountTotal) {
  BitMatrix image = this.image;

  int maxI = image.getHeight();
  int[] stateCount = getCrossCheckStateCount();

  // Start counting up from center
  int i = startI;
  while (i >= 0 && image.get(centerJ, i)) {
    stateCount[2]++;
    i--;
  }
  if (i < 0) {
    return Float.NaN;
  }
  while (i >= 0 && !image.get(centerJ, i) && stateCount[1] <= maxCount) {
    stateCount[1]++;
    i--;
  }
  // If already too many modules in this state or ran off the edge:
  if (i < 0 || stateCount[1] > maxCount) {
    return Float.NaN;
  }
  while (i >= 0 && image.get(centerJ, i) && stateCount[0] <= maxCount) {
    stateCount[0]++;
    i--;
  }
  if (stateCount[0] > maxCount) {
    return Float.NaN;
  }

  // Now also count down from center
  i = startI + 1;
  while (i < maxI && image.get(centerJ, i)) {
    stateCount[2]++;
    i++;
  }
  if (i == maxI) {
    return Float.NaN;
  }
  while (i < maxI && !image.get(centerJ, i) && stateCount[3] < maxCount) {
    stateCount[3]++;
    i++;
  }
  if (i == maxI || stateCount[3] >= maxCount) {
    return Float.NaN;
  }
  while (i < maxI && image.get(centerJ, i) && stateCount[4] < maxCount) {
    stateCount[4]++;
    i++;
  }
  if (stateCount[4] >= maxCount) {
    return Float.NaN;
  }

  // If we found a finder-pattern-like section, but its size is more than 40% different than
  // the original, assume it's a false positive
  int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +
      stateCount[4];
  if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
    return Float.NaN;
  }

  return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : Float.NaN;
}
 

/**
 * <p>After a horizontal scan finds a potential finder pattern, this method
 * "cross-checks" by scanning down vertically through the center of the possible
 * finder pattern to see if the same proportion is detected.</p>
 *
 * @param startI row where a finder pattern was detected
 * @param centerJ center of the section that appears to cross a finder pattern
 * @param maxCount maximum reasonable number of modules that should be
 * observed in any reading state, based on the results of the horizontal scan
 * @return vertical center of finder pattern, or {@link Float#NaN} if not found
 */
private float crossCheckVertical(int startI, int centerJ, int maxCount,
    int originalStateCountTotal) {
  BitMatrix image = this.image;

  int maxI = image.getHeight();
  int[] stateCount = getCrossCheckStateCount();

  // Start counting up from center
  int i = startI;
  while (i >= 0 && image.get(centerJ, i)) {
    stateCount[2]++;
    i--;
  }
  if (i < 0) {
    return Float.NaN;
  }
  while (i >= 0 && !image.get(centerJ, i) && stateCount[1] <= maxCount) {
    stateCount[1]++;
    i--;
  }
  // If already too many modules in this state or ran off the edge:
  if (i < 0 || stateCount[1] > maxCount) {
    return Float.NaN;
  }
  while (i >= 0 && image.get(centerJ, i) && stateCount[0] <= maxCount) {
    stateCount[0]++;
    i--;
  }
  if (stateCount[0] > maxCount) {
    return Float.NaN;
  }

  // Now also count down from center
  i = startI + 1;
  while (i < maxI && image.get(centerJ, i)) {
    stateCount[2]++;
    i++;
  }
  if (i == maxI) {
    return Float.NaN;
  }
  while (i < maxI && !image.get(centerJ, i) && stateCount[3] < maxCount) {
    stateCount[3]++;
    i++;
  }
  if (i == maxI || stateCount[3] >= maxCount) {
    return Float.NaN;
  }
  while (i < maxI && image.get(centerJ, i) && stateCount[4] < maxCount) {
    stateCount[4]++;
    i++;
  }
  if (stateCount[4] >= maxCount) {
    return Float.NaN;
  }

  // If we found a finder-pattern-like section, but its size is more than 40% different than
  // the original, assume it's a false positive
  int stateCountTotal = stateCount[0] + stateCount[1] + stateCount[2] + stateCount[3] +
      stateCount[4];
  if (5 * Math.abs(stateCountTotal - originalStateCountTotal) >= 2 * originalStateCountTotal) {
    return Float.NaN;
  }

  return foundPatternCross(stateCount) ? centerFromEnd(stateCount, i) : Float.NaN;
}
 

/**
 * <p>
 * Creates the version object based on the dimension of the original bit
 * matrix from the datamatrix code.
 * </p>
 * 
 * <p>
 * See ISO 16022:2006 Table 7 - ECC 200 symbol attributes
 * </p>
 * 
 * @param bitMatrix
 *            Original {@link BitMatrix} including alignment patterns
 * @return {@link Version} encapsulating the Data Matrix Code's "version"
 * @throws FormatException
 *             if the dimensions of the mapping matrix are not valid Data
 *             Matrix dimensions.
 */
private static Version readVersion(BitMatrix bitMatrix) throws FormatException {
	int numRows = bitMatrix.getHeight();
	int numColumns = bitMatrix.getWidth();
	return Version.getVersionForDimensions(numRows, numColumns);
}