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

cleanup point transform code

Browse Source
This commit is contained in:
Henry Schimke
2023-03-08 12:46:52 -06:00
parent 2b7d053646
commit 717b74fd99
10 changed files with 190 additions and 158 deletions
Download Patch File Download Diff File Expand all files Collapse all files

37
src/common/PerspectiveTransformTestCase.rs
View File

@@ -27,11 +27,16 @@ use crate::point;
// public final class PerspectiveTransformTestCase extends Assert {
use super::{PerspectiveTransform, Quadrilateral};
static EPSILON: f32 = 1.0E-4f32;
static EPSILON: f32 = 1.0E-4_f32;
#[test]
fn test_square_to_quadrilateral() {
let square = Quadrilateral::new(point(2.0, 3.0), point(10.0, 3.0), point(16.0, 15.0), point(4.0,9.0));
let square = Quadrilateral::new(
point(2.0, 3.0),
point(10.0, 3.0),
point(16.0, 15.0),
point(4.0, 9.0),
);
let pt = PerspectiveTransform::squareToQuadrilateral(square);
assert_point_equals(2.0, 3.0, 0.0, 0.0, &pt);
assert_point_equals(10.0, 4.0, 1.0, 0.0, &pt);
@@ -43,10 +48,20 @@ fn test_square_to_quadrilateral() {
#[test]
fn test_quadrilateral_to_quadrilateral() {
let quad1 = Quadrilateral::new(point(2.0, 3.0), point(10.0, 4.0), point(16.0, 15.0), point(4.0, 9.0));
let quad2 = Quadrilateral::new(point(103.0, 110.0), point(300.0, 120.0), point(290.0, 270.0), point(150.0,280.0));
let pt = PerspectiveTransform::quadrilateralToQuadrilateral(quad1, quad2);
let quad1 = Quadrilateral::new(
point(2.0, 3.0),
point(10.0, 4.0),
point(16.0, 15.0),
point(4.0, 9.0),
);
let quad2 = Quadrilateral::new(
point(103.0, 110.0),
point(300.0, 120.0),
point(290.0, 270.0),
point(150.0, 280.0),
);
let pt = PerspectiveTransform::quadrilateralToQuadrilateral(quad1, quad2).expect("transform");
assert_point_equals(103.0, 110.0, 2.0, 3.0, &pt);
assert_point_equals(300.0, 120.0, 10.0, 4.0, &pt);
assert_point_equals(290.0, 270.0, 16.0, 15.0, &pt);
@@ -62,19 +77,19 @@ fn assert_point_equals(
source_y: f32,
pt: &PerspectiveTransform,
) {
let mut points = [source_x, source_y];
let mut points = [point(source_x, source_y)];
pt.transform_points_single(&mut points);
assert!(
(expected_x - points[0] < EPSILON || points[0] - expected_x < EPSILON),
(expected_x - points[0].x < EPSILON || points[0].x - expected_x < EPSILON),
"{} - {}",
expected_x,
points[0]
points[0].x
);
assert!(
(expected_y - points[1] < EPSILON || points[1] - expected_y < EPSILON),
(expected_y - points[0].y < EPSILON || points[0].y - expected_y < EPSILON),
"{} - {}",
expected_y,
points[1]
points[0].y
);
// assert_eq!( expectedX, points[0]);

39
src/common/default_grid_sampler.rs
View File

@@ -18,8 +18,8 @@
// import com.google.zxing.NotFoundException;
use crate::{common::Result};
use crate::Exceptions;
use crate::common::Result;
use crate::{Exceptions, Point};
use super::{BitMatrix, GridSampler, PerspectiveTransform, Quadrilateral, SamplerControl};
@@ -36,13 +36,16 @@ impl GridSampler for DefaultGridSampler {
dimensionX: u32,
dimensionY: u32,
dst: Quadrilateral,
src:Quadrilateral
src: Quadrilateral,
) -> Result<BitMatrix> {
let transform = PerspectiveTransform::quadrilateralToQuadrilateral(
dst, src,
);
let transform = PerspectiveTransform::quadrilateralToQuadrilateral(dst, src)?;
self.sample_grid(image, dimensionX, dimensionY, &[SamplerControl::new(dimensionX, dimensionY, transform)])
self.sample_grid(
image,
dimensionX,
dimensionY,
&[SamplerControl::new(dimensionX, dimensionY, transform)],
)
}
fn sample_grid(
@@ -50,13 +53,13 @@ impl GridSampler for DefaultGridSampler {
image: &BitMatrix,
dimensionX: u32,
dimensionY: u32,
controls: &[SamplerControl]
controls: &[SamplerControl],
) -> Result<BitMatrix> {
if dimensionX == 0 || dimensionY == 0 {
return Err(Exceptions::NOT_FOUND);
}
let mut bits = BitMatrix::new(dimensionX, dimensionY)?;
let mut points = vec![0.0; 2 * dimensionX as usize];
let mut points = vec![Point::default(); dimensionX as usize];
for y in 0..dimensionY {
// for (int y = 0; y < dimensionY; y++) {
let max = points.len();
@@ -64,11 +67,15 @@ impl GridSampler for DefaultGridSampler {
let mut x = 0;
while x < max {
// for (int x = 0; x < max; x += 2) {
points[x] = (x as f32 / 2.0) + 0.5;
points[x + 1] = i_value;
x += 2;
points[x].x = (x as f32) + 0.5;
points[x].y = i_value;
x += 1;
}
controls.first().unwrap().transform.transform_points_single(&mut points);
controls
.first()
.unwrap()
.transform
.transform_points_single(&mut points);
// Quick check to see if points transformed to something inside the image;
// sufficient to check the endpoints
self.checkAndNudgePoints(image, &mut points)?;
@@ -83,15 +90,15 @@ impl GridSampler for DefaultGridSampler {
// ));
// }
if image
.try_get(points[x] as u32, points[x + 1] as u32)
.try_get(points[x].x as u32, points[x].y as u32)
.ok_or(Exceptions::not_found_with(
"index out of bounds, see documentation in file for explanation",
))?
{
// Black(-ish) pixel
bits.set(x as u32 / 2, y);
bits.set(x as u32, y);
}
x += 2;
x += 1;
}
// } catch (ArrayIndexOutOfBoundsException aioobe) {
// // This feels wrong, but, sometimes if the finder patterns are misidentified, the resulting

50
src/common/grid_sampler.rs
View File

@@ -19,7 +19,7 @@
// import com.google.zxing.NotFoundException;
use crate::{common::Result, Point};
use crate::{Exceptions, point};
use crate::{point, Exceptions};
use super::{BitMatrix, PerspectiveTransform, Quadrilateral};
@@ -94,7 +94,7 @@ pub trait GridSampler {
dimensionX: u32,
dimensionY: u32,
dst: Quadrilateral,
src:Quadrilateral
src: Quadrilateral,
) -> Result<BitMatrix>;
fn sample_grid(
@@ -102,7 +102,7 @@ pub trait GridSampler {
image: &BitMatrix,
dimensionX: u32,
dimensionY: u32,
controls: &[SamplerControl]
controls: &[SamplerControl],
) -> Result<BitMatrix>;
/**
@@ -120,7 +120,7 @@ pub trait GridSampler {
* @param points actual points in x1,y1,...,xn,yn form
* @throws NotFoundException if an endpoint is lies outside the image boundaries
*/
fn checkAndNudgePoints(&self, image: &BitMatrix, points: &mut [f32]) -> Result<()> {
fn checkAndNudgePoints(&self, image: &BitMatrix, points: &mut [Point]) -> Result<()> {
let width = image.getWidth();
let height = image.getHeight();
// Check and nudge points from start until we see some that are OK:
@@ -129,54 +129,54 @@ pub trait GridSampler {
let mut offset = 0;
while offset < max_offset && nudged {
// for (int offset = 0; offset < maxOffset && nudged; offset += 2) {
let x = points[offset] as i32;
let y = points[offset + 1] as i32;
let x = points[offset].x as i32;
let y = points[offset].y as i32;
if x < -1 || x > width as i32 || y < -1 || y > height as i32 {
return Err(Exceptions::NOT_FOUND);
}
nudged = false;
if x == -1 {
points[offset] = 0.0;
points[offset].x = 0.0;
nudged = true;
} else if x == width as i32 {
points[offset] = width as f32 - 1.0;
points[offset].x = width as f32 - 1.0;
nudged = true;
}
if y == -1 {
points[offset + 1] = 0.0;
points[offset].y = 0.0;
nudged = true;
} else if y == height as i32 {
points[offset + 1] = height as f32 - 1.0;
points[offset].y = height as f32 - 1.0;
nudged = true;
}
offset += 2;
offset += 1;
}
// Check and nudge points from end:
nudged = true;
let mut offset = points.len() as isize - 2;
let mut offset = points.len() as isize - 1;
while offset >= 0 && nudged {
// for (int offset = points.length - 2; offset >= 0 && nudged; offset -= 2) {
let x = points[offset as usize] as i32;
let y = points[offset as usize + 1] as i32;
let x = points[offset as usize].x as i32;
let y = points[offset as usize].y as i32;
if x < -1 || x > width as i32 || y < -1 || y > height as i32 {
return Err(Exceptions::NOT_FOUND);
}
nudged = false;
if x == -1 {
points[offset as usize] = 0.0;
points[offset as usize].x = 0.0;
nudged = true;
} else if x == width as i32 {
points[offset as usize] = width as f32 - 1.0;
points[offset as usize].x = width as f32 - 1.0;
nudged = true;
}
if y == -1 {
points[offset as usize + 1] = 0.0;
points[offset as usize].y = 0.0;
nudged = true;
} else if y == height as i32 {
points[offset as usize + 1] = height as f32 - 1.0;
points[offset as usize].y = height as f32 - 1.0;
nudged = true;
}
offset += -2;
offset += -1;
}
Ok(())
}
@@ -185,11 +185,15 @@ pub trait GridSampler {
pub struct SamplerControl {
pub p0: Point,
pub p1: Point,
pub transform: PerspectiveTransform
pub transform: PerspectiveTransform,
}
impl SamplerControl {
pub fn new( width: u32, height: u32, transform: PerspectiveTransform ) -> Self {
Self{ p0: point(0.0, 0.0), p1: point(width as f32, height as f32), transform }
pub fn new(width: u32, height: u32, transform: PerspectiveTransform) -> Self {
Self {
p0: point(0.0, 0.0),
p1: point(width as f32, height as f32),
transform,
}
}
}
}

83
src/common/perspective_transform.rs
View File

@@ -18,7 +18,7 @@
use std::ops::Mul;
use crate::point;
use crate::{common::Result, point, Exceptions, Point};
use super::Quadrilateral;
@@ -68,41 +68,27 @@ impl PerspectiveTransform {
}
#[allow(clippy::too_many_arguments)]
pub fn quadrilateralToQuadrilateral(
dst: Quadrilateral,
src: Quadrilateral
) -> Self {
pub fn quadrilateralToQuadrilateral(dst: Quadrilateral, src: Quadrilateral) -> Result<Self> {
if !src.is_convex() || !dst.is_convex() {
return Err(Exceptions::ILLEGAL_STATE);
}
// let q_to_s = PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
// let s_to_q =
// PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
let q_to_s = PerspectiveTransform::quadrilateralToSquare(dst);
let s_to_q =
PerspectiveTransform::squareToQuadrilateral(src);
s_to_q * q_to_s
let s_to_q = PerspectiveTransform::squareToQuadrilateral(src);
Ok(s_to_q * q_to_s)
}
pub fn transform_points_single(&self, points: &mut [f32]) {
let a11 = self.a11;
let a12 = self.a12;
let a13 = self.a13;
let a21 = self.a21;
let a22 = self.a22;
let a23 = self.a23;
let a31 = self.a31;
let a32 = self.a32;
let a33 = self.a33;
let maxI = points.len() - 1; // points.length must be even
let mut i = 0;
while i < maxI {
pub fn transform_points_single(&self, points: &mut [Point]) {
for point in points.iter_mut() {
// for (int i = 0; i < maxI; i += 2) {
let x = points[i];
let y = points[i + 1];
let denominator = a13 * x + a23 * y + a33;
points[i] = (a11 * x + a21 * y + a31) / denominator;
points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
i += 2;
let x = point.x;
let y = point.y;
let denominator = self.a13 * x + self.a23 * y + self.a33;
point.x = (self.a11 * x + self.a21 * y + self.a31) / denominator;
point.y = (self.a12 * x + self.a22 * y + self.a32) / denominator;
}
}
@@ -118,23 +104,30 @@ impl PerspectiveTransform {
}
#[allow(clippy::too_many_arguments)]
pub fn squareToQuadrilateral(
square: Quadrilateral
) -> Self {
let [p0, p1, p2, p3 ] = square.0;
let d3 = p0 - p1 + p2 - p3;
if d3 == point(0.0,0.0) {
// Affine
PerspectiveTransform::new(p1.x - p0.x, p2.x - p1.x, p0.x, p1.y - p0.y, p2.y - p1.y, p0.y, 0.0, 0.0, 1.0)
} else {
pub fn squareToQuadrilateral(square: Quadrilateral) -> Self {
let [p0, p1, p2, p3] = square.0;
let d1 = p1 - p2;
let d2 = p3 - p2;
let d3 = p0 - p1 + p2 - p3;
if d3 == point(0.0, 0.0) {
// Affine
PerspectiveTransform::new(
p1.x - p0.x,
p2.x - p1.x,
p0.x,
p1.y - p0.y,
p2.y - p1.y,
p0.y,
0.0,
0.0,
1.0,
)
} else {
let d1 = p1 - p2;
let d2 = p3 - p2;
let denominator = d1.cross(d2);
let a13 = (d3.x * d2.y - d2.x * d3.y) / denominator;
let a23 = (d1.x * d3.y - d3.x * d1.y) / denominator;
let a13 = d3.cross(d2) / denominator;
let a23 = d1.cross(d3) / denominator;
PerspectiveTransform::new(
p1.x - p0.x + a13 * p1.x,
p3.x - p0.x + a23 * p3.x,
@@ -150,9 +143,7 @@ let d2 = p3 - p2;
}
#[allow(clippy::too_many_arguments)]
pub fn quadrilateralToSquare(
quad: Quadrilateral
) -> Self {
pub fn quadrilateralToSquare(quad: Quadrilateral) -> Self {
// Here, the adjoint serves as the inverse
PerspectiveTransform::squareToQuadrilateral(quad).buildAdjoint()
}
@@ -189,4 +180,4 @@ impl Mul for PerspectiveTransform {
self.a13 * rhs.a31 + self.a23 * rhs.a32 + self.a33 * rhs.a33,
)
}
}
}

14
src/common/quad.rs
View File

@@ -10,8 +10,8 @@ impl Quadrilateral {
// using Point = T;
#[allow(dead_code)]
pub fn new(tl:Point, tr: Point, br: Point, bl: Point) -> Self {
Self([tl,tr,br,bl])
pub fn new(tl: Point, tr: Point, br: Point, bl: Point) -> Self {
Self([tl, tr, br, bl])
}
// pub fn with_f32( tl:f32, tr:f32, br:f32, bl:f32) -> Self {
// Self([tl, tr,br, bl ])
@@ -124,11 +124,11 @@ impl Quadrilateral {
let d2 = self.0[i] - self.0[(i + 1) % N];
let cp = d1.cross(d2);
m = if m.abs() > cp { cp } else { m.abs() };
// m = if m.abs() > cp { cp } else { m.abs() };
M = if M.abs() > cp { M.abs() } else { cp };
// m = std::cmp::min((m).abs(), cp);
// M = std::cmp::max((M).abs(), cp);
// M = if M.abs() > cp { M.abs() } else { cp };
m = f32::min((m).abs(), cp);
M = f32::max((M).abs(), cp);
if i == 0 {
sign = cp > 0.0;
@@ -214,4 +214,4 @@ impl Default for Quadrilateral {
fn default() -> Self {
Self([Point { x: 0.0, y: 0.0 }; 4])
}
}
}