ak/rxing
1
0
Fork 0
mirror of https://github.com/starovoid/rxing.git synced 2026-07-26 12:22:34 +00:00
Code Issues Packages Projects Releases Wiki Activity

detector passes

Browse Source
This commit is contained in:
Henry Schimke
2022-09-28 16:46:22 -05:00
parent ad9ef3fee9
commit b4c59deb01
4 changed files with 220 additions and 183 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/aztec/DetectorTest.rs
View File

@@ -71,10 +71,11 @@ fn test_error_in_parameter_locator_not_compact() {
fn test_error_in_parameter_locator(data: &str) {
let aztec = encoder::encoder::encode(data, 25, encoder::encoder::DEFAULT_AZTEC_LAYERS)
.expect("encode should create");
// dbg!(aztec.getMatrix().to_string());
let mut random = rand::thread_rng(); //Random(aztec.getMatrix().hashCode()); // pseudo-random, but deterministic
let layers = aztec.getLayers();
let compact = aztec.isCompact();
let orientation_points = getOrientationPoints(&aztec);
let orientation_points = get_orientation_points(&aztec);
for isMirror in [false, true] {
// for (boolean isMirror : new boolean[] { false, true }) {
for matrix in get_rotations(aztec.getMatrix()) {
@@ -90,16 +91,18 @@ fn test_error_in_parameter_locator(data: &str) {
clone(&matrix)
};
copy.flip_coords(
orientation_points.get(error1).unwrap().get_x() as u32,
orientation_points.get(error1).unwrap().get_y() as u32,
orientation_points.get(error1).unwrap().get_x().abs() as u32,
orientation_points.get(error1).unwrap().get_y().abs() as u32,
);
if error2 > error1 {
// if error2 == error1, we only test a single error
copy.flip_coords(
orientation_points.get(error2).unwrap().get_x() as u32,
orientation_points.get(error2).unwrap().get_y() as u32,
orientation_points.get(error2).unwrap().get_x().abs() as u32,
orientation_points.get(error2).unwrap().get_y().abs() as u32,
);
}
// dbg!(copy.to_string());
// dbg!(make_larger(&copy, 3).to_string());
// The detector doesn't seem to work when matrix bits are only 1x1. So magnify.
let r = Detector::new(make_larger(&copy, 3)).detect(isMirror);
assert!(r.is_ok());
@@ -117,7 +120,7 @@ fn test_error_in_parameter_locator(data: &str) {
let mut errors = Vec::new();
while errors.len() < 3 {
// Quick and dirty way of getting three distinct integers between 1 and n.
errors.push(random.gen_range(0..=orientation_points.len()));
errors.push(random.gen_range(0..orientation_points.len()));
}
for error in errors {
// for (int error : errors) {
@@ -125,22 +128,28 @@ fn test_error_in_parameter_locator(data: &str) {
orientation_points.get(error).unwrap().get_x() as u32,
orientation_points.get(error).unwrap().get_y() as u32,
);
// copy.flip_coords(
// orientation_points.get(error).unwrap().get_x().abs() as u32,
// orientation_points.get(error).unwrap().get_y().abs() as u32,
// );
}
// try {
if let Err(res) = detector::Detector::new(make_larger(&copy, 3)).detect(false) {
if let Exceptions::NotFoundException(_msg) = res {
// all ok
} else {
panic!("Should not reach here");
panic!("Only Exceptions::NotFoundException allowed, got {}", res);
}
} else {
panic!("Should not reach here");
let r = Detector::new(make_larger(&copy, 3)).detect(false);
assert!(r.is_ok());
let r = r.expect("result already tested as ok");
assert_eq!(r.getNbLayers(), layers);
assert_eq!(r.isCompact(), compact);
let res = decoder::decode(&r).expect("decode should be ok");
assert_eq!(data, res.getText());
//panic!("Should be unable to detect given value.");
}
// // new Detector(makeLarger(copy, 3)).detect(false);
// fail("Should not reach here");
// } catch (NotFoundException expected) {
// // continue
// }
}
}
}
@@ -155,7 +164,9 @@ fn make_larger(input: &BitMatrix, factor: u32) -> BitMatrix {
for inputX in 0..width {
// for (int inputX = 0; inputX < width; inputX++) {
if input.get(inputX, inputY) {
output.setRegion(inputX * factor, inputY * factor, factor, factor).expect("region set should be ok");
output
.setRegion(inputX * factor, inputY * factor, factor, factor)
.expect("region set should be ok");
}
}
}
@@ -168,6 +179,11 @@ fn get_rotations(matrix0: &BitMatrix) -> Vec<BitMatrix> {
let matrix180 = rotate_right(&matrix90);
let matrix270 = rotate_right(&matrix180);
vec![matrix0.clone(), matrix90, matrix180, matrix270]
// vec![matrix0.clone()]
// vec![matrix90]
// vec![matrix180]
// vec![matrix270]
// vec![matrix0.clone(), matrix90, matrix270, matrix180 ]
}
// Rotates a square BitMatrix to the right by 90 degrees
@@ -178,7 +194,7 @@ fn rotate_right(input: &BitMatrix) -> BitMatrix {
// for (int x = 0; x < width; x++) {
for y in 0..width {
// for (int y = 0; y < width; y++) {
if (input.get(x, y)) {
if input.get(x, y) {
result.set(y, width - x - 1);
}
}
@@ -195,7 +211,7 @@ fn transpose(input: &BitMatrix) -> BitMatrix {
// for (int x = 0; x < width; x++) {
for y in 0..width {
// for (int y = 0; y < width; y++) {
if (input.get(x, y)) {
if input.get(x, y) {
result.set(y, x);
}
}
@@ -218,7 +234,7 @@ fn clone(input: &BitMatrix) -> BitMatrix {
result
}
fn getOrientationPoints(code: &AztecCode) -> Vec<Point> {
fn get_orientation_points(code: &AztecCode) -> Vec<Point> {
let center = code.getMatrix().getWidth() as i32 / 2;
let offset = if code.isCompact() { 5 } else { 7 };
let mut result = Vec::new();

81
src/aztec/detector.rs
View File

@@ -14,7 +14,6 @@
* limitations under the License.
*/
use std::fmt;
use crate::{
@@ -91,7 +90,7 @@ impl Detector {
}
// 3. Get the size of the matrix and other parameters from the bull's eye
self.extractParameters(&bulls_eye_corners).expect("paramater extraction must succeed");
self.extractParameters(&bulls_eye_corners)?;
// 4. Sample the grid
let bits = self.sample_grid(
@@ -221,7 +220,7 @@ impl Detector {
* @throws NotFoundException if the array contains too many errors
*/
fn get_corrected_parameter_data(parameterData: u64, compact: bool) -> Result<u32, Exceptions> {
let mut parameterData = parameterData;
let mut parameter_data = parameterData;
let num_codewords: i32;
let num_data_codewords: i32;
@@ -236,10 +235,10 @@ impl Detector {
let num_eccodewords = num_codewords - num_data_codewords;
let mut parameterWords = vec![0i32; num_codewords as usize];
for i in (0..num_codewords - 1).rev() {
for i in (0..num_codewords).rev() {
// for (int i = numCodewords - 1; i >= 0; --i) {
parameterWords[i as usize] = (parameterData & 0xF) as i32;
parameterData >>= 4;
parameterWords[i as usize] = (parameter_data & 0xF) as i32;
parameter_data >>= 4;
}
//try {
let field =
@@ -267,7 +266,10 @@ impl Detector {
* @return The corners of the bull-eye
* @throws NotFoundException If no valid bull-eye can be found
*/
fn get_bulls_eye_corners(&mut self, pCenter: Point) -> Result<Vec<RXingResultPoint>, Exceptions> {
fn get_bulls_eye_corners(
&mut self,
pCenter: Point,
) -> Result<Vec<RXingResultPoint>, Exceptions> {
let mut pina = pCenter;
let mut pinb = pCenter;
let mut pinc = pCenter;
@@ -275,7 +277,10 @@ impl Detector {
let mut color = true;
for nbCenterLayers in 1..9 {
self.nb_center_layers = 1;
while self.nb_center_layers < 9 {
// for nbCenterLayers in 1..9 {
// for (nbCenterLayers = 1; nbCenterLayers < 9; nbCenterLayers++) {
let pouta = self.get_first_different(&pina, color, 1, -1);
let poutb = self.get_first_different(&pinb, color, 1, 1);
@@ -286,12 +291,18 @@ impl Detector {
//
//c b
if nbCenterLayers > 2 {
let q: f32 =
Self::distance(&poutd.to_rxing_result_point(), &pouta.to_rxing_result_point())
* nbCenterLayers as f32
/ (Self::distance(&pind.to_rxing_result_point(), &pina.to_rxing_result_point())
* (nbCenterLayers + 2) as f32);
if self.nb_center_layers > 2 {
let q: f32 = Self::distance_points(&poutd, &pouta) * self.nb_center_layers as f32
/ (Self::distance_points(&pind, &pina) * (self.nb_center_layers + 2) as f32);
// let q: f32 = Self::distance(
// &poutd.to_rxing_result_point(),
// &pouta.to_rxing_result_point(),
// ) * nbCenterLayers as f32
// / (Self::distance(
// &pind.to_rxing_result_point(),
// &pina.to_rxing_result_point(),
// ) * (nbCenterLayers + 2) as f32);
if q < 0.75
|| q > 1.25
|| !self.is_white_or_black_rectangle(&pouta, &poutb, &poutc, &poutd)
@@ -306,6 +317,8 @@ impl Detector {
pind = poutd;
color = !color;
self.nb_center_layers+=1;
}
if self.nb_center_layers != 5 && self.nb_center_layers != 7 {
@@ -316,10 +329,14 @@ impl Detector {
// Expand the square by .5 pixel in each direction so that we're on the border
// between the white square and the black square
let pinax = RXingResultPoint::new(pina.get_x() as f32 + 0.5f32, pina.get_y() as f32 - 0.5f32);
let pinbx = RXingResultPoint::new(pinb.get_x() as f32 + 0.5f32, pinb.get_y() as f32 + 0.5f32);
let pincx = RXingResultPoint::new(pinc.get_x() as f32 - 0.5f32, pinc.get_y() as f32 + 0.5f32);
let pindx = RXingResultPoint::new(pind.get_x() as f32 - 0.5f32, pind.get_y() as f32 - 0.5f32);
let pinax =
RXingResultPoint::new(pina.get_x() as f32 + 0.5f32, pina.get_y() as f32 - 0.5f32);
let pinbx =
RXingResultPoint::new(pinb.get_x() as f32 + 0.5f32, pinb.get_y() as f32 + 0.5f32);
let pincx =
RXingResultPoint::new(pinc.get_x() as f32 - 0.5f32, pinc.get_y() as f32 + 0.5f32);
let pindx =
RXingResultPoint::new(pind.get_x() as f32 - 0.5f32, pind.get_y() as f32 - 0.5f32);
// Expand the square so that its corners are the centers of the points
// just outside the bull's eye.
@@ -462,7 +479,10 @@ impl Detector {
* @param bullsEyeCorners the array of bull's eye corners
* @return the array of aztec code corners
*/
fn get_matrix_corner_points(&self, bulls_eye_corners: &[RXingResultPoint]) -> Vec<RXingResultPoint> {
fn get_matrix_corner_points(
&self,
bulls_eye_corners: &[RXingResultPoint],
) -> Vec<RXingResultPoint> {
Self::expand_square(
bulls_eye_corners,
2 * self.nb_center_layers,
@@ -562,33 +582,33 @@ impl Detector {
// let p3 = Point::new(Math.min(image.getWidth() - 1, p3.getX() + corr),
// Math.max(0, Math.min(image.getHeight() - 1, p3.getY() - corr)));
let p4 = Point::new(
self.image.getWidth() as i32 - 1.min(p4.get_x() + corr),
(self.image.getWidth() as i32 - 1).min(p4.get_x() + corr),
(self.image.getHeight() as i32 - 1).min(p4.get_y() + corr),
);
// let p4 = Point::new(Math.min(image.getWidth() - 1, p4.getX() + corr),
// Math.min(image.getHeight() - 1, p4.getY() + corr));
let cInit = self.get_color(&p4, &p1);
let c_init = self.get_color(&p4, &p1);
if cInit == 0 {
if c_init == 0 {
return false;
}
let c = self.get_color(&p1, &p2);
if c != cInit {
if c != c_init {
return false;
}
let c = self.get_color(&p2, &p3);
if c != cInit {
if c != c_init {
return false;
}
let c = self.get_color(&p3, &p4);
return c == cInit;
return c == c_init;
}
/**
@@ -605,19 +625,20 @@ impl Detector {
let dy = (p2.get_y() - p1.get_y()) as f32 / d;
let mut error = 0;
let mut px = p1.get_x();
let mut py = p1.get_y();
let mut px = p1.get_x() as f32;
let mut py = p1.get_y() as f32;
let color_model = self.image.get(p1.get_x() as u32, p1.get_y() as u32);
let i_max = d.floor() as u32; //(int) Math.floor(d);
for _i in 0..i_max {
// for (int i = 0; i < iMax; i++) {
if self.image.get(px as u32, py as u32) != color_model {
if self.image.get(MathUtils::round(px) as u32, MathUtils::round(py) as u32) != color_model {
error += 1;
}
px += dx.floor() as i32;
py += dy.floor() as i32;
px += dx;
py += dy;
}
let err_ratio = error as f32 / d;