mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 04:12:34 +00:00
BitMatrix
This commit is contained in:
Henry Schimke
@@ -713,3 +713,602 @@ impl DetectorRXingResult {
|
||||
return self.points;
|
||||
}
|
||||
}
|
||||
|
||||
/*
|
||||
* Copyright 2007 ZXing authors
|
||||
*
|
||||
* Licensed under the Apache License, Version 2.0 (the "License");
|
||||
* you may not use this file except in compliance with the License.
|
||||
* You may obtain a copy of the License at
|
||||
*
|
||||
* http://www.apache.org/licenses/LICENSE-2.0
|
||||
*
|
||||
* Unless required by applicable law or agreed to in writing, software
|
||||
* distributed under the License is distributed on an "AS IS" BASIS,
|
||||
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
||||
* See the License for the specific language governing permissions and
|
||||
* limitations under the License.
|
||||
*/
|
||||
|
||||
// package com.google.zxing.common;
|
||||
|
||||
// import java.util.Arrays;
|
||||
|
||||
/**
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* <p>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.</p>
|
||||
*
|
||||
* @author Sean Owen
|
||||
* @author dswitkin@google.com (Daniel Switkin)
|
||||
*/
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, Hash)]
|
||||
pub struct BitMatrix {
|
||||
width: u32,
|
||||
height: u32,
|
||||
rowSize: usize,
|
||||
bits: Vec<u32>,
|
||||
}
|
||||
|
||||
impl BitMatrix {
|
||||
/**
|
||||
* Creates an empty square {@code BitMatrix}.
|
||||
*
|
||||
* @param dimension height and width
|
||||
*/
|
||||
pub fn with_single_dimension(dimension: u32) -> Self {
|
||||
Self::new(dimension, dimension)
|
||||
}
|
||||
|
||||
/**
|
||||
* Creates an empty {@code BitMatrix}.
|
||||
*
|
||||
* @param width bit matrix width
|
||||
* @param height bit matrix height
|
||||
*/
|
||||
pub fn new(width: u32, height: u32) -> Result<Self, IllegalArgumentException> {
|
||||
if width < 1 || height < 1 {
|
||||
return Err(IllegalArgumentException::new(
|
||||
"Both dimensions must be greater than 0",
|
||||
));
|
||||
}
|
||||
Ok(Self {
|
||||
width,
|
||||
height,
|
||||
rowSize: (width + 31) / 32,
|
||||
bits: vec![0; ((width + 31) / 32) * height],
|
||||
})
|
||||
// this.width = width;
|
||||
// this.height = height;
|
||||
// this.rowSize = (width + 31) / 32;
|
||||
// bits = new int[rowSize * height];
|
||||
}
|
||||
|
||||
fn with_all_data(&self, width: u32, height: u32, rowSize: usize, bits: Vec<u32>) -> Self {
|
||||
Self {
|
||||
width,
|
||||
height,
|
||||
rowSize,
|
||||
bits,
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Interprets a 2D array of booleans as a {@code BitMatrix}, where "true" means an "on" bit.
|
||||
*
|
||||
* @param image bits of the image, as a row-major 2D array. Elements are arrays representing rows
|
||||
* @return {@code BitMatrix} representation of image
|
||||
*/
|
||||
pub fn parse(image: &[[bool]]) -> Self {
|
||||
let height = image.len();
|
||||
let width = image[0].len();
|
||||
let bits = BitMatrix::new(width, height).unwrap();
|
||||
for i in 0..height {
|
||||
//for (int i = 0; i < height; i++) {
|
||||
let imageI = image[i];
|
||||
for j in 0..width {
|
||||
//for (int j = 0; j < width; j++) {
|
||||
if imageI[j] {
|
||||
bits.set(j, i);
|
||||
}
|
||||
}
|
||||
}
|
||||
return bits;
|
||||
}
|
||||
|
||||
pub fn parse(
|
||||
stringRepresentation: &str,
|
||||
setString: &str,
|
||||
unsetString: &str,
|
||||
) -> Result<Self, IllegalArgumentException> {
|
||||
// cannot pass nulls in rust
|
||||
// if (stringRepresentation == null) {
|
||||
// throw new IllegalArgumentException();
|
||||
// }
|
||||
|
||||
let bits = Vec::with_capacity(stringRepresentation.length());
|
||||
let bitsPos = 0;
|
||||
let rowStartPos = 0;
|
||||
let rowLength = -1;
|
||||
let nRows = 0;
|
||||
let pos = 0;
|
||||
while pos < stringRepresentation.length() {
|
||||
if stringRepresentation.charAt(pos) == '\n' || stringRepresentation.charAt(pos) == '\r'
|
||||
{
|
||||
if bitsPos > rowStartPos {
|
||||
if rowLength == -1 {
|
||||
rowLength = bitsPos - rowStartPos;
|
||||
} else if bitsPos - rowStartPos != rowLength {
|
||||
return Err(IllegalArgumentException::new("row lengths do not match"));
|
||||
}
|
||||
rowStartPos = bitsPos;
|
||||
nRows += 1;
|
||||
}
|
||||
pos += 1;
|
||||
} else if stringRepresentation.startsWith(setString, pos) {
|
||||
pos += setString.length();
|
||||
bits[bitsPos] = true;
|
||||
bitsPos += 1;
|
||||
} else if stringRepresentation.startsWith(unsetString, pos) {
|
||||
pos += unsetString.length();
|
||||
bits[bitsPos] = false;
|
||||
bitsPos += 1;
|
||||
} else {
|
||||
return Err(IllegalArgumentException::new(&format!(
|
||||
"illegal character encountered: {}",
|
||||
stringRepresentation.substring(pos)
|
||||
)));
|
||||
}
|
||||
}
|
||||
|
||||
// no EOL at end?
|
||||
if bitsPos > rowStartPos {
|
||||
if rowLength == -1 {
|
||||
rowLength = bitsPos - rowStartPos;
|
||||
} else if bitsPos - rowStartPos != rowLength {
|
||||
return Err(IllegalArgumentException::new("row lengths do not match"));
|
||||
}
|
||||
nRows += 1;
|
||||
}
|
||||
|
||||
let matrix = BitMatrix::new(rowLength, nRows);
|
||||
for i in 0..bitsPos {
|
||||
//for (int i = 0; i < bitsPos; i++) {
|
||||
if bits[i] {
|
||||
matrix.set(i % rowLength, i / rowLength);
|
||||
}
|
||||
}
|
||||
return matrix;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Gets the requested bit, where true means black.</p>
|
||||
*
|
||||
* @param x The horizontal component (i.e. which column)
|
||||
* @param y The vertical component (i.e. which row)
|
||||
* @return value of given bit in matrix
|
||||
*/
|
||||
pub fn get(&self, x: u32, y: u32) -> bool {
|
||||
let offset = y * self.rowSize + (x / 32);
|
||||
return ((self.bits[offset] >> (x & 0x1f)) & 1) != 0;
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Sets the given bit to true.</p>
|
||||
*
|
||||
* @param x The horizontal component (i.e. which column)
|
||||
* @param y The vertical component (i.e. which row)
|
||||
*/
|
||||
pub fn set(&self, x: u32, y: u32) {
|
||||
let offset = y * self.rowSize + (x / 32);
|
||||
self.bits[offset] |= 1 << (x & 0x1f);
|
||||
}
|
||||
|
||||
pub fn unset(&self, x: u32, y: u32) {
|
||||
let offset = y * self.rowSize + (x / 32);
|
||||
self.bits[offset] &= !(1 << (x & 0x1f));
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Flips the given bit.</p>
|
||||
*
|
||||
* @param x The horizontal component (i.e. which column)
|
||||
* @param y The vertical component (i.e. which row)
|
||||
*/
|
||||
pub fn flip(&self, x: u32, y: u32) {
|
||||
let offset = y * self.rowSize + (x / 32);
|
||||
self.bits[offset] ^= 1 << (x & 0x1f);
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Flips every bit in the matrix.</p>
|
||||
*/
|
||||
pub fn flip(&self) {
|
||||
let max = self.bits.len();
|
||||
for i in 0..max {
|
||||
//for (int i = 0; i < max; i++) {
|
||||
self.bits[i] = !self.bits[i];
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Exclusive-or (XOR): Flip the bit in this {@code BitMatrix} if the corresponding
|
||||
* mask bit is set.
|
||||
*
|
||||
* @param mask XOR mask
|
||||
*/
|
||||
pub fn xor(&self, mask: &BitMatrix) -> Result<(), IllegalArgumentException> {
|
||||
if self.width != mask.width || self.height != mask.height || self.rowSize != mask.rowSize {
|
||||
return Err(IllegalArgumentException::new(
|
||||
"input matrix dimensions do not match",
|
||||
));
|
||||
}
|
||||
let rowArray = BitArray::with_size(self.width);
|
||||
for y in 0..self.height {
|
||||
//for (int y = 0; y < height; y++) {
|
||||
let offset = y * self.rowSize;
|
||||
let row = mask.getRow(y, self.rowArray).getBitArray();
|
||||
for x in 0..self.rowSize {
|
||||
//for (int x = 0; x < rowSize; x++) {
|
||||
self.bits[offset + x] ^= row[x];
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/**
|
||||
* Clears all bits (sets to false).
|
||||
*/
|
||||
pub fn clear(&self) {
|
||||
let max = self.bits.len();
|
||||
for i in 0..max {
|
||||
//for (int i = 0; i < max; i++) {
|
||||
self.bits[i] = 0;
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* <p>Sets a square region of the bit matrix to true.</p>
|
||||
*
|
||||
* @param left The horizontal position to begin at (inclusive)
|
||||
* @param top The vertical position to begin at (inclusive)
|
||||
* @param width The width of the region
|
||||
* @param height The height of the region
|
||||
*/
|
||||
pub fn setRegion(
|
||||
&self,
|
||||
left: u32,
|
||||
top: u32,
|
||||
width: u32,
|
||||
height: u32,
|
||||
) -> Result<(), IllegalArgumentException> {
|
||||
if top < 0 || left < 0 {
|
||||
return Err(IllegalArgumentException::new(
|
||||
"Left and top must be nonnegative",
|
||||
));
|
||||
}
|
||||
if height < 1 || width < 1 {
|
||||
return Err(IllegalArgumentException::new(
|
||||
"Height and width must be at least 1",
|
||||
));
|
||||
}
|
||||
let right = left + width;
|
||||
let bottom = top + height;
|
||||
if bottom > self.height || right > self.width {
|
||||
return Err(IllegalArgumentException::new(
|
||||
"The region must fit inside the matrix",
|
||||
));
|
||||
}
|
||||
for y in top..bottom {
|
||||
//for (int y = top; y < bottom; y++) {
|
||||
let offset = y * self.rowSize;
|
||||
for x in left..right {
|
||||
//for (int x = left; x < right; x++) {
|
||||
self.bits[offset + (x / 32)] |= 1 << (x & 0x1f);
|
||||
}
|
||||
}
|
||||
Ok(())
|
||||
}
|
||||
|
||||
/**
|
||||
* A fast method to retrieve one row of data from the matrix as a BitArray.
|
||||
*
|
||||
* @param y The row to retrieve
|
||||
* @param row An optional caller-allocated BitArray, will be allocated if null or too small
|
||||
* @return The resulting BitArray - this reference should always be used even when passing
|
||||
* your own row
|
||||
*/
|
||||
pub fn getRow(&self, y: u32, row: &BitArray) -> BitArray {
|
||||
let rw: BitArray = if row.getSize() < self.width {
|
||||
row = &BitArray::with_size(self.width)
|
||||
} else {
|
||||
row.clear();
|
||||
row
|
||||
};
|
||||
|
||||
let offset = y * self.rowSize;
|
||||
for x in 0..self.rowSize {
|
||||
//for (int x = 0; x < rowSize; x++) {
|
||||
rw.setBulk(x * 32, self.bits[offset + x]);
|
||||
}
|
||||
return rw;
|
||||
}
|
||||
|
||||
/**
|
||||
* @param y row to set
|
||||
* @param row {@link BitArray} to copy from
|
||||
*/
|
||||
pub fn setRow(&self, y: u32, row: &BitArray) {
|
||||
return self.bits[y * self.rowSize..self.rowSize]
|
||||
.clone_from_slice(&row.getBitArray()[0..self.rowSize]);
|
||||
//System.arraycopy(row.getBitArray(), 0, self.bits, y * self.rowSize, self.rowSize);
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies this {@code BitMatrix} to represent the same but rotated the given degrees (0, 90, 180, 270)
|
||||
*
|
||||
* @param degrees number of degrees to rotate through counter-clockwise (0, 90, 180, 270)
|
||||
*/
|
||||
pub fn rotate(&self, degrees: u32) -> Result<(), IllegalArgumentException> {
|
||||
match degrees % 360 {
|
||||
0 => Ok(()),
|
||||
90 => {
|
||||
self.rotate90();
|
||||
Ok(())
|
||||
}
|
||||
180 => {
|
||||
self.rotate180();
|
||||
Ok(())
|
||||
}
|
||||
270 => {
|
||||
self.rotate90();
|
||||
self.rotate180();
|
||||
Ok(())
|
||||
}
|
||||
_ => Err(IllegalArgumentException::new(
|
||||
"degrees must be a multiple of 0, 90, 180, or 270",
|
||||
)),
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies this {@code BitMatrix} to represent the same but rotated 180 degrees
|
||||
*/
|
||||
pub fn rotate180(&self) {
|
||||
let mut topRow = BitArray::with_size(self.width);
|
||||
let mut bottomRow = BitArray::with_size(self.width);
|
||||
let mut maxHeight = (self.height + 1) / 2;
|
||||
for i in 0..maxHeight {
|
||||
//for (int i = 0; i < maxHeight; i++) {
|
||||
topRow = self.getRow(i, &topRow);
|
||||
let bottomRowIndex = self.height - 1 - i;
|
||||
bottomRow = self.getRow(bottomRowIndex, &bottomRow);
|
||||
topRow.reverse();
|
||||
bottomRow.reverse();
|
||||
self.setRow(i, &bottomRow);
|
||||
self.setRow(bottomRowIndex, &topRow);
|
||||
}
|
||||
}
|
||||
|
||||
/**
|
||||
* Modifies this {@code BitMatrix} to represent the same but rotated 90 degrees counterclockwise
|
||||
*/
|
||||
pub fn rotate90(&self) {
|
||||
let mut newWidth = self.height;
|
||||
let mut newHeight = self.width;
|
||||
let mut newRowSize = (newWidth + 31) / 32;
|
||||
let mut newBits = Vec::with_capacity(newRowSize * newHeight);
|
||||
|
||||
for y in 0..self.height {
|
||||
//for (int y = 0; y < height; y++) {
|
||||
for x in 0..self.width {
|
||||
//for (int x = 0; x < width; x++) {
|
||||
let offset = y * self.rowSize + (x / 32);
|
||||
if ((self.bits[offset] >> (x & 0x1f)) & 1) != 0 {
|
||||
let newOffset = (newHeight - 1 - x) * newRowSize + (y / 32);
|
||||
newBits[newOffset] |= 1 << (y & 0x1f);
|
||||
}
|
||||
}
|
||||
}
|
||||
self.width = newWidth;
|
||||
self.height = newHeight;
|
||||
self.rowSize = newRowSize;
|
||||
self.bits = newBits;
|
||||
}
|
||||
|
||||
/**
|
||||
* This is useful in detecting the enclosing rectangle of a 'pure' barcode.
|
||||
*
|
||||
* @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
|
||||
*/
|
||||
pub fn getEnclosingRectangle(&self) -> Option<Vec<u32>> {
|
||||
let left = self.width;
|
||||
let top = self.height;
|
||||
let right = -1;
|
||||
let bottom = -1;
|
||||
|
||||
for y in 0..self.height {
|
||||
//for (int y = 0; y < height; y++) {
|
||||
for x32 in 0..self.rowSize {
|
||||
//for (int x32 = 0; x32 < rowSize; x32++) {
|
||||
let theBits = self.bits[y * self.rowSize + x32];
|
||||
if theBits != 0 {
|
||||
if y < top {
|
||||
top = y;
|
||||
}
|
||||
if y > bottom {
|
||||
bottom = y;
|
||||
}
|
||||
if x32 * 32 < left {
|
||||
let bit = 0;
|
||||
while (theBits << (31 - bit)) == 0 {
|
||||
bit += 1;
|
||||
}
|
||||
if (x32 * 32 + bit) < left {
|
||||
left = x32 * 32 + bit;
|
||||
}
|
||||
}
|
||||
if x32 * 32 + 31 > right {
|
||||
let bit = 31;
|
||||
while (theBits >> bit) == 0 {
|
||||
bit -= 1;
|
||||
}
|
||||
if (x32 * 32 + bit) > right {
|
||||
right = x32 * 32 + bit;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
if right < left || bottom < top {
|
||||
return None;
|
||||
}
|
||||
|
||||
return Some(vec![left, top, right - left + 1, bottom - top + 1]);
|
||||
}
|
||||
|
||||
/**
|
||||
* This is useful in detecting a corner of a 'pure' barcode.
|
||||
*
|
||||
* @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white
|
||||
*/
|
||||
pub fn getTopLeftOnBit(&self) -> Option<Vec<u32>> {
|
||||
let bitsOffset = 0;
|
||||
while bitsOffset < self.bits.length && self.bits[bitsOffset] == 0 {
|
||||
bitsOffset += 1;
|
||||
}
|
||||
if bitsOffset == self.bits.length {
|
||||
return None;
|
||||
}
|
||||
let y = bitsOffset / self.rowSize;
|
||||
let x = (bitsOffset % self.rowSize) * 32;
|
||||
|
||||
let theBits = self.bits[bitsOffset];
|
||||
let bit = 0;
|
||||
while (theBits << (31 - bit)) == 0 {
|
||||
bit += 1;
|
||||
}
|
||||
x += bit;
|
||||
return Some(vec![x, y]);
|
||||
}
|
||||
|
||||
pub fn getBottomRightOnBit(&self) -> Option<Vec<u32>> {
|
||||
let bitsOffset = self.bits.length - 1;
|
||||
while bitsOffset >= 0 && self.bits[bitsOffset] == 0 {
|
||||
bitsOffset -= 1;
|
||||
}
|
||||
if bitsOffset < 0 {
|
||||
return None;
|
||||
}
|
||||
|
||||
let y = bitsOffset / self.rowSize;
|
||||
let x = (bitsOffset % self.rowSize) * 32;
|
||||
|
||||
let theBits = self.bits[bitsOffset];
|
||||
let bit = 31;
|
||||
while (theBits >> bit) == 0 {
|
||||
bit -= 1;
|
||||
}
|
||||
x += bit;
|
||||
|
||||
return Some(vec![x, y]);
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The width of the matrix
|
||||
*/
|
||||
pub fn getWidth(&self) -> u32 {
|
||||
return self.width;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The height of the matrix
|
||||
*/
|
||||
pub fn getHeight(&self) -> u32 {
|
||||
return self.height;
|
||||
}
|
||||
|
||||
/**
|
||||
* @return The row size of the matrix
|
||||
*/
|
||||
pub fn getRowSize(&self) -> usize {
|
||||
return self.rowSize;
|
||||
}
|
||||
|
||||
// @Override
|
||||
// public boolean equals(Object o) {
|
||||
// if (!(o instanceof BitMatrix)) {
|
||||
// return false;
|
||||
// }
|
||||
// BitMatrix other = (BitMatrix) o;
|
||||
// return width == other.width && height == other.height && rowSize == other.rowSize &&
|
||||
// Arrays.equals(bits, other.bits);
|
||||
// }
|
||||
|
||||
// @Override
|
||||
// public int hashCode() {
|
||||
// int hash = width;
|
||||
// hash = 31 * hash + width;
|
||||
// hash = 31 * hash + height;
|
||||
// hash = 31 * hash + rowSize;
|
||||
// hash = 31 * hash + Arrays.hashCode(bits);
|
||||
// return hash;
|
||||
// }
|
||||
|
||||
/**
|
||||
* @param setString representation of a set bit
|
||||
* @param unsetString representation of an unset bit
|
||||
* @return string representation of entire matrix utilizing given strings
|
||||
*/
|
||||
pub fn toString(&self, setString: &str, unsetString: &str) -> String {
|
||||
return self.buildToString(setString, unsetString, "\n");
|
||||
}
|
||||
|
||||
/**
|
||||
* @param setString representation of a set bit
|
||||
* @param unsetString representation of an unset bit
|
||||
* @param lineSeparator newline character in string representation
|
||||
* @return string representation of entire matrix utilizing given strings and line separator
|
||||
* @deprecated call {@link #toString(String,String)} only, which uses \n line separator always
|
||||
*/
|
||||
// @Deprecated
|
||||
// public String toString(String setString, String unsetString, String lineSeparator) {
|
||||
// return buildToString(setString, unsetString, lineSeparator);
|
||||
// }
|
||||
|
||||
fn buildToString(&self, setString: &str, unsetString: &str, lineSeparator: &str) -> String {
|
||||
let result = String::with_capacity(self.height * (self.width + 1));
|
||||
for y in 0..self.height {
|
||||
//for (int y = 0; y < height; y++) {
|
||||
for x in 0..self.width {
|
||||
//for (int x = 0; x < width; x++) {
|
||||
result.push_str(if self.get(x, y) {
|
||||
setString
|
||||
} else {
|
||||
unsetString
|
||||
});
|
||||
}
|
||||
result.push_str(lineSeparator);
|
||||
}
|
||||
return result;
|
||||
}
|
||||
|
||||
// @Override
|
||||
// public BitMatrix clone() {
|
||||
// return new BitMatrix(width, height, rowSize, bits.clone());
|
||||
// }
|
||||
}
|
||||
|
||||
impl fmt::Display for BitMatrix {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
write!(f, "{}", self.toString("X ", " "))
|
||||
}
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user