com.google.zxing.common

## Class BitMatrix

- java.lang.Object
- - com.google.zxing.common.BitMatrix

- All Implemented Interfaces:
    Cloneable

      public final class BitMatrix
      extends Object
      implements Cloneable

  Represents a 2D matrix of bits. In function arguments below, and throughout the common module, x is the column position, and y is the row position. The ordering is always x, y. The origin is at the top-left.

  Internally the bits are represented in a 1-D array of 32-bit ints. However, each row begins with a new int. This is done intentionally so that we can copy out a row into a BitArray very efficiently.

  The ordering of bits is row-major. Within each int, the least significant bits are used first, meaning they represent lower x values. This is compatible with BitArray's implementation.

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `BitMatrix(int dimension)` Creates an empty square `BitMatrix`.
    `BitMatrix(int width, int height)` Creates an empty `BitMatrix`.

  - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `clear()` Clears all bits (sets to false).
    `BitMatrix` | `clone()`
    `boolean` | `equals(Object o)`
    `void` | `flip(int x, int y)` Flips the given bit.
    `boolean` | `get(int x, int y)` Gets the requested bit, where true means black.
    `int[]` | `getBottomRightOnBit()`
    `int[]` | `getEnclosingRectangle()` This is useful in detecting the enclosing rectangle of a 'pure' barcode.
    `int` | `getHeight()`
    `BitArray` | `getRow(int y, BitArray row)` A fast method to retrieve one row of data from the matrix as a BitArray.
    `int` | `getRowSize()`
    `int[]` | `getTopLeftOnBit()` This is useful in detecting a corner of a 'pure' barcode.
    `int` | `getWidth()`
    `int` | `hashCode()`
    `static BitMatrix` | `parse(boolean[][] image)` Interprets a 2D array of booleans as a `BitMatrix`, where "true" means an "on" bit.
    `static BitMatrix` | `parse(String stringRepresentation, String setString, String unsetString)`
    `void` | `rotate180()` Modifies this `BitMatrix` to represent the same but rotated 180 degrees
    `void` | `set(int x, int y)` Sets the given bit to true.
    `void` | `setRegion(int left, int top, int width, int height)` Sets a square region of the bit matrix to true.
    `void` | `setRow(int y, BitArray row)`
    `String` | `toString()`
    `String` | `toString(String setString, String unsetString)`
    `void` | `unset(int x, int y)`
    `void` | `xor(BitMatrix mask)` Exclusive-or (XOR): Flip the bit in this `BitMatrix` if the corresponding mask bit is set.

    - ### Methods inherited from class java.lang.Object

      `finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### BitMatrix

          public BitMatrix(int dimension)

      Creates an empty square `BitMatrix`.
      Parameters:
        `dimension` - height and width

    - #### BitMatrix

          public BitMatrix(int width,
                           int height)

      Creates an empty `BitMatrix`.
      Parameters:
        `width` - bit matrix width
        `height` - bit matrix height

  - ### Method Detail

    - #### clear

          public void clear()

      Clears all bits (sets to false).

    - #### clone

          public BitMatrix clone()

      Overrides:
        `clone` in class `Object`

    - #### equals

          public boolean equals(Object o)

      Overrides:
        `equals` in class `Object`

    - #### flip

          public void flip(int x,
                           int y)

      Flips the given bit.

      Parameters:
        `x` - The horizontal component (i.e. which column)
        `y` - The vertical component (i.e. which row)

    - #### get

          public boolean get(int x,
                             int y)

      Gets the requested bit, where true means black.

      Parameters:
        `x` - The horizontal component (i.e. which column)
        `y` - The vertical component (i.e. which row)
      Returns:
        value of given bit in matrix

    - #### getBottomRightOnBit

          public int[] getBottomRightOnBit()

    - #### getEnclosingRectangle

          public int[] getEnclosingRectangle()

      This is useful in detecting the enclosing rectangle of a 'pure' barcode.
      Returns:
        `left,top,width,height` enclosing rectangle of all 1 bits, or null if it is all white

    - #### getHeight

          public int getHeight()

      Returns:
        The height of the matrix

    - #### getRow

          public BitArray getRow(int y,
                                 BitArray row)

      A fast method to retrieve one row of data from the matrix as a BitArray.
      Parameters:
        `y` - The row to retrieve
        `row` - An optional caller-allocated BitArray, will be allocated if null or too small
      Returns:
        The resulting BitArray - this reference should always be used even when passing your own row

    - #### getRowSize

          public int getRowSize()

      Returns:
        The row size of the matrix

    - #### getTopLeftOnBit

          public int[] getTopLeftOnBit()

      This is useful in detecting a corner of a 'pure' barcode.
      Returns:
        `x,y` coordinate of top-left-most 1 bit, or null if it is all white

    - #### getWidth

          public int getWidth()

      Returns:
        The width of the matrix

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Object`

    - #### parse

          public static BitMatrix parse(boolean[][] image)

      Interprets a 2D array of booleans as a `BitMatrix`, where "true" means an "on" bit.
      Parameters:
        `image` - bits of the image, as a row-major 2D array. Elements are arrays representing rows
      Returns:
        `BitMatrix` representation of image

    - #### parse

          public static BitMatrix parse(String stringRepresentation,
                                        String setString,
                                        String unsetString)

    - #### rotate180

          public void rotate180()

      Modifies this `BitMatrix` to represent the same but rotated 180 degrees

    - #### set

          public void set(int x,
                          int y)

      Sets the given bit to true.

      Parameters:
        `x` - The horizontal component (i.e. which column)
        `y` - The vertical component (i.e. which row)

    - #### setRegion

          public void setRegion(int left,
                                int top,
                                int width,
                                int height)

      Sets a square region of the bit matrix to true.

      Parameters:
        `left` - The horizontal position to begin at (inclusive)
        `top` - The vertical position to begin at (inclusive)
        `width` - The width of the region
        `height` - The height of the region

    - #### setRow

          public void setRow(int y,
                             BitArray row)

      Parameters:
        `y` - row to set
        `row` - `BitArray` to copy from

    - #### toString

          public String toString()

      Overrides:
        `toString` in class `Object`
      Returns:
        string representation using "X" for set and " " for unset bits

    - #### toString

          public String toString(String setString,
                                 String unsetString)

      Parameters:
        `setString` - representation of a set bit
        `unsetString` - representation of an unset bit
      Returns:
        string representation of entire matrix utilizing given strings

    - #### unset

          public void unset(int x,
                            int y)

    - #### xor

          public void xor(BitMatrix mask)

      Exclusive-or (XOR): Flip the bit in this `BitMatrix` if the corresponding mask bit is set.
      Parameters:
        `mask` - XOR mask