core/src/com/google/zxing/BinaryBitmap.java

   1 /*
   2  * Copyright 2009 ZXing authors
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.google.zxing;
  18
  19 import com.google.zxing.common.BitArray;
  20 import com.google.zxing.common.BitMatrix;
  21
  22 /**
  23  * This class is the core bitmap class used by ZXing to represent 1 bit data. Reader objects
  24  * accept a BinaryBitmap and attempt to decode it.
  25  *
  26  * @author dswitkin@google.com (Daniel Switkin)
  27  */
  28 public final class BinaryBitmap {
  29
  30   private final Binarizer binarizer;
  31   private BitMatrix matrix;
  32
  33   public BinaryBitmap(Binarizer binarizer) {
  34     if (binarizer == null) {
  35       throw new IllegalArgumentException("Binarizer must be non-null.");
  36     }
  37     this.binarizer = binarizer;
  38     matrix = null;
  39   }
  40
  41   /**
  42    * @return The width of the bitmap.
  43    */
  44   public int getWidth() {
  45     return binarizer.getLuminanceSource().getWidth();
  46   }
  47
  48   /**
  49    * @return The height of the bitmap.
  50    */
  51   public int getHeight() {
  52     return binarizer.getLuminanceSource().getHeight();
  53   }
  54
  55   /**
  56    * Converts one row of luminance data to 1 bit data. May actually do the conversion, or return
  57    * cached data. Callers should assume this method is expensive and call it as seldom as possible.
  58    * This method is intended for decoding 1D barcodes and may choose to apply sharpening.
  59    *
  60    * @param y The row to fetch, 0 <= y < bitmap height.
  61    * @param row An optional preallocated array. If null or too small, it will be ignored.
  62    *            If used, the Binarizer will call BitArray.clear(). Always use the returned object.
  63    * @return The array of bits for this row (true means black).
  64    */
  65   public BitArray getBlackRow(int y, BitArray row) throws NotFoundException {
  66     return binarizer.getBlackRow(y, row);
  67   }
  68
  69   /**
  70    * Converts a 2D array of luminance data to 1 bit. As above, assume this method is expensive
  71    * and do not call it repeatedly. This method is intended for decoding 2D barcodes and may or
  72    * may not apply sharpening. Therefore, a row from this matrix may not be identical to one
  73    * fetched using getBlackRow(), so don't mix and match between them.
  74    *
  75    * @return The 2D array of bits for the image (true means black).
  76    */
  77   public BitMatrix getBlackMatrix() throws NotFoundException {
  78     // The matrix is created on demand the first time it is requested, then cached. There are two
  79     // reasons for this:
  80     // 1. This work will never be done if the caller only installs 1D Reader objects, or if a
  81     //    1D Reader finds a barcode before the 2D Readers run.
  82     // 2. This work will only be done once even if the caller installs multiple 2D Readers.
  83     if (matrix == null) {
  84       matrix = binarizer.getBlackMatrix();
  85     }
  86     return matrix;
  87   }
  88
  89   /**
  90    * @return Whether this bitmap can be cropped.
  91    */
  92   public boolean isCropSupported() {
  93     return binarizer.getLuminanceSource().isCropSupported();
  94   }
  95
  96   /**
  97    * Returns a new object with cropped image data. Implementations may keep a reference to the
  98    * original data rather than a copy. Only callable if isCropSupported() is true.
  99    *
 100    * @param left The left coordinate, 0 <= left < getWidth().
 101    * @param top The top coordinate, 0 <= top <= getHeight().
 102    * @param width The width of the rectangle to crop.
 103    * @param height The height of the rectangle to crop.
 104    * @return A cropped version of this object.
 105    */
 106   public BinaryBitmap crop(int left, int top, int width, int height) {
 107     LuminanceSource newSource = binarizer.getLuminanceSource().crop(left, top, width, height);
 108     return new BinaryBitmap(binarizer.createBinarizer(newSource));
 109   }
 110
 111   /**
 112    * @return Whether this bitmap supports counter-clockwise rotation.
 113    */
 114   public boolean isRotateSupported() {
 115     return binarizer.getLuminanceSource().isRotateSupported();
 116   }
 117
 118   /**
 119    * Returns a new object with rotated image data. Only callable if isRotateSupported() is true.
 120    *
 121    * @return A rotated version of this object.
 122    */
 123   public BinaryBitmap rotateCounterClockwise() {
 124     LuminanceSource newSource = binarizer.getLuminanceSource().rotateCounterClockwise();
 125     return new BinaryBitmap(binarizer.createBinarizer(newSource));
 126   }
 127
 128 }