From 6b7099a03b264a5d8f52c2e87d261216faf5b27c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Vuka=C5=A1in=20Stepanovi=C4=87?= Date: Wed, 15 Feb 2023 14:42:07 +0000 Subject: [PATCH] remove indirection for RxingResultPoint Previously, the struct was passed around everywhere as a reference. It only holds two floats, so there's no real need for indirection. Now it's being passed as a value. --- src/aztec/detector.rs | 38 +++--- src/common/bit_matrix.rs | 4 +- .../detector/white_rectangle_detector.rs | 10 +- .../detector/datamatrix_detector.rs | 68 +++++----- .../zxing_cpp_detector/bitmatrix_cursor.rs | 32 ++--- .../zxing_cpp_detector/cpp_new_detector.rs | 46 +++---- .../zxing_cpp_detector/dm_regression_line.rs | 44 ++++--- .../zxing_cpp_detector/edge_tracer.rs | 90 ++++++------- .../detector/zxing_cpp_detector/quad.rs | 6 +- .../zxing_cpp_detector/regression_line.rs | 28 ++-- .../decoder/pdf_417_scanning_decoder.rs | 6 +- src/rxing_result_point.rs | 124 ++++++------------ 12 files changed, 229 insertions(+), 267 deletions(-) diff --git a/src/aztec/detector.rs b/src/aztec/detector.rs index 007ea5d..6807cc4 100644 --- a/src/aztec/detector.rs +++ b/src/aztec/detector.rs @@ -94,10 +94,10 @@ impl<'a> Detector<'_> { // 4. Sample the grid let bits = self.sample_grid( self.image, - &bulls_eye_corners[self.shift as usize % 4], - &bulls_eye_corners[(self.shift as usize + 1) % 4], - &bulls_eye_corners[(self.shift as usize + 2) % 4], - &bulls_eye_corners[(self.shift as usize + 3) % 4], + bulls_eye_corners[self.shift as usize % 4], + bulls_eye_corners[(self.shift as usize + 1) % 4], + bulls_eye_corners[(self.shift as usize + 2) % 4], + bulls_eye_corners[(self.shift as usize + 3) % 4], )?; // 5. Get the corners of the matrix. @@ -122,10 +122,10 @@ impl<'a> Detector<'_> { &mut self, bulls_eye_corners: &[RXingResultPoint], ) -> Result<(), Exceptions> { - if !self.is_valid(&bulls_eye_corners[0]) - || !self.is_valid(&bulls_eye_corners[1]) - || !self.is_valid(&bulls_eye_corners[2]) - || !self.is_valid(&bulls_eye_corners[3]) + if !self.is_valid(bulls_eye_corners[0]) + || !self.is_valid(bulls_eye_corners[1]) + || !self.is_valid(bulls_eye_corners[2]) + || !self.is_valid(bulls_eye_corners[3]) { return Err(Exceptions::NotFoundException(Some( "no valid points".to_owned(), @@ -134,10 +134,10 @@ impl<'a> Detector<'_> { let length = 2 * self.nb_center_layers; // Get the bits around the bull's eye let sides = [ - self.sample_line(&bulls_eye_corners[0], &bulls_eye_corners[1], length), // Right side - self.sample_line(&bulls_eye_corners[1], &bulls_eye_corners[2], length), // Bottom - self.sample_line(&bulls_eye_corners[2], &bulls_eye_corners[3], length), // Left side - self.sample_line(&bulls_eye_corners[3], &bulls_eye_corners[0], length), // Top + self.sample_line(bulls_eye_corners[0], bulls_eye_corners[1], length), // Right side + self.sample_line(bulls_eye_corners[1], bulls_eye_corners[2], length), // Bottom + self.sample_line(bulls_eye_corners[2], bulls_eye_corners[3], length), // Left side + self.sample_line(bulls_eye_corners[3], bulls_eye_corners[0], length), // Top ]; // bullsEyeCorners[shift] is the corner of the bulls'eye that has three @@ -500,10 +500,10 @@ impl<'a> Detector<'_> { fn sample_grid( &self, image: &BitMatrix, - top_left: &RXingResultPoint, - top_right: &RXingResultPoint, - bottom_right: &RXingResultPoint, - bottom_left: &RXingResultPoint, + top_left: RXingResultPoint, + top_right: RXingResultPoint, + bottom_right: RXingResultPoint, + bottom_left: RXingResultPoint, ) -> Result { let sampler = DefaultGridSampler::default(); let dimension = self.get_dimension(); @@ -542,7 +542,7 @@ impl<'a> Detector<'_> { * @param size number of bits * @return the array of bits as an int (first bit is high-order bit of result) */ - fn sample_line(&self, p1: &RXingResultPoint, p2: &RXingResultPoint, size: u32) -> u32 { + fn sample_line(&self, p1: RXingResultPoint, p2: RXingResultPoint, size: u32) -> u32 { let mut result = 0; let d = Self::distance(p1, p2); @@ -724,7 +724,7 @@ impl<'a> Detector<'_> { x >= 0 && x < self.image.getWidth() as i32 && y >= 0 && y < self.image.getHeight() as i32 } - fn is_valid(&self, point: &RXingResultPoint) -> bool { + fn is_valid(&self, point: RXingResultPoint) -> bool { let x = MathUtils::round(point.getX()); let y = MathUtils::round(point.getY()); self.is_valid_points(x, y) @@ -734,7 +734,7 @@ impl<'a> Detector<'_> { MathUtils::distance(a.get_x(), a.get_y(), b.get_x(), b.get_y()) } - fn distance(a: &RXingResultPoint, b: &RXingResultPoint) -> f32 { + fn distance(a: RXingResultPoint, b: RXingResultPoint) -> f32 { MathUtils::distance(a.getX(), a.getY(), b.getX(), b.getY()) } diff --git a/src/common/bit_matrix.rs b/src/common/bit_matrix.rs index 5bda954..960ba8c 100644 --- a/src/common/bit_matrix.rs +++ b/src/common/bit_matrix.rs @@ -212,7 +212,7 @@ impl BitMatrix { ((self.bits[offset] >> (x & 0x1f)) & 1) != 0 } - pub fn get_point(&self, point: &RXingResultPoint) -> bool { + pub fn get_point(&self, point: RXingResultPoint) -> bool { self.get(point.x as u32, point.y as u32) // let offset = self.get_offset(point.y as u32, point.x as u32); // ((self.bits[offset] >> (x & 0x1f)) & 1) != 0 @@ -700,7 +700,7 @@ impl BitMatrix { new_bm } - pub fn isIn(&self, p: &RXingResultPoint, b: i32) -> bool { + pub fn isIn(&self, p: RXingResultPoint, b: i32) -> bool { b as f32 <= p.x && p.x < self.getWidth() as f32 - b as f32 && b as f32 <= p.y diff --git a/src/common/detector/white_rectangle_detector.rs b/src/common/detector/white_rectangle_detector.rs index eaef17a..d18c762 100644 --- a/src/common/detector/white_rectangle_detector.rs +++ b/src/common/detector/white_rectangle_detector.rs @@ -280,7 +280,7 @@ impl<'a> WhiteRectangleDetector<'_> { return Err(Exceptions::NotFoundException(None)); } - Ok(self.center_edges(&y.unwrap(), &z.unwrap(), &x.unwrap(), &t.unwrap())) + Ok(self.center_edges(y.unwrap(), z.unwrap(), x.unwrap(), t.unwrap())) } else { Err(Exceptions::NotFoundException(None)) } @@ -322,10 +322,10 @@ impl<'a> WhiteRectangleDetector<'_> { */ fn center_edges( &self, - y: &RXingResultPoint, - z: &RXingResultPoint, - x: &RXingResultPoint, - t: &RXingResultPoint, + y: RXingResultPoint, + z: RXingResultPoint, + x: RXingResultPoint, + t: RXingResultPoint, ) -> [RXingResultPoint; 4] { // // t t diff --git a/src/datamatrix/detector/datamatrix_detector.rs b/src/datamatrix/detector/datamatrix_detector.rs index 89e1f39..ff8ee0e 100644 --- a/src/datamatrix/detector/datamatrix_detector.rs +++ b/src/datamatrix/detector/datamatrix_detector.rs @@ -68,8 +68,8 @@ impl<'a> Detector<'_> { let bottomRight = points[2]; let topRight = points[3]; - let mut dimensionTop = self.transitionsBetween(&topLeft, &topRight) + 1; - let mut dimensionRight = self.transitionsBetween(&bottomRight, &topRight) + 1; + let mut dimensionTop = self.transitionsBetween(topLeft, topRight) + 1; + let mut dimensionRight = self.transitionsBetween(bottomRight, topRight) + 1; if (dimensionTop & 0x01) == 1 { dimensionTop += 1; } @@ -85,10 +85,10 @@ impl<'a> Detector<'_> { let bits = Self::sampleGrid( self.image, - &topLeft, - &bottomLeft, - &bottomRight, - &topRight, + topLeft, + bottomLeft, + bottomRight, + topRight, dimensionTop, dimensionRight, )?; @@ -135,10 +135,10 @@ impl<'a> Detector<'_> { let pointC = cornerPoints[3]; let pointD = cornerPoints[2]; - let trAB = self.transitionsBetween(&pointA, &pointB); - let trBC = self.transitionsBetween(&pointB, &pointC); - let trCD = self.transitionsBetween(&pointC, &pointD); - let trDA = self.transitionsBetween(&pointD, &pointA); + let trAB = self.transitionsBetween(pointA, pointB); + let trBC = self.transitionsBetween(pointB, pointC); + let trCD = self.transitionsBetween(pointC, pointD); + let trDA = self.transitionsBetween(pointD, pointA); // 0..3 // : : @@ -183,11 +183,11 @@ impl<'a> Detector<'_> { // Transition detection on the edge is not stable. // To safely detect, shift the points to the module center. - let tr = self.transitionsBetween(&pointA, &pointD); + let tr = self.transitionsBetween(pointA, pointD); let pointBs = Self::shiftPoint(pointB, pointC, (tr + 1) * 4); let pointCs = Self::shiftPoint(pointC, pointB, (tr + 1) * 4); - let trBA = self.transitionsBetween(&pointBs, &pointA); - let trCD = self.transitionsBetween(&pointCs, &pointD); + let trBA = self.transitionsBetween(pointBs, pointA); + let trCD = self.transitionsBetween(pointCs, pointD); // 0..3 // | : @@ -222,13 +222,13 @@ impl<'a> Detector<'_> { let pointD = points[3]; // shift points for safe transition detection. - let mut trTop = self.transitionsBetween(&pointA, &pointD); - let mut trRight = self.transitionsBetween(&pointB, &pointD); + let mut trTop = self.transitionsBetween(pointA, pointD); + let mut trRight = self.transitionsBetween(pointB, pointD); let pointAs = Self::shiftPoint(pointA, pointB, (trRight + 1) * 4); let pointCs = Self::shiftPoint(pointC, pointB, (trTop + 1) * 4); - trTop = self.transitionsBetween(&pointAs, &pointD); - trRight = self.transitionsBetween(&pointCs, &pointD); + trTop = self.transitionsBetween(pointAs, pointD); + trRight = self.transitionsBetween(pointCs, pointD); let candidate1 = RXingResultPoint::new( pointD.getX() + (pointC.getX() - pointB.getX()) / (trTop as f32 + 1.0), @@ -239,20 +239,20 @@ impl<'a> Detector<'_> { pointD.getY() + (pointA.getY() - pointB.getY()) / (trRight as f32 + 1.0), ); - if !self.isValid(&candidate1) { - if self.isValid(&candidate2) { + if !self.isValid(candidate1) { + if self.isValid(candidate2) { return Some(candidate2); } return None; } - if !self.isValid(&candidate2) { + if !self.isValid(candidate2) { return Some(candidate1); } - let sumc1 = self.transitionsBetween(&pointAs, &candidate1) - + self.transitionsBetween(&pointCs, &candidate1); - let sumc2 = self.transitionsBetween(&pointAs, &candidate2) - + self.transitionsBetween(&pointCs, &candidate2); + let sumc1 = self.transitionsBetween(pointAs, candidate1) + + self.transitionsBetween(pointCs, candidate1); + let sumc2 = self.transitionsBetween(pointAs, candidate2) + + self.transitionsBetween(pointCs, candidate2); if sumc1 > sumc2 { Some(candidate1) @@ -274,16 +274,16 @@ impl<'a> Detector<'_> { let mut pointD = points[3]; // calculate pseudo dimensions - let mut dimH = self.transitionsBetween(&pointA, &pointD) + 1; - let mut dimV = self.transitionsBetween(&pointC, &pointD) + 1; + let mut dimH = self.transitionsBetween(pointA, pointD) + 1; + let mut dimV = self.transitionsBetween(pointC, pointD) + 1; // shift points for safe dimension detection let mut pointAs = Self::shiftPoint(pointA, pointB, dimV * 4); let mut pointCs = Self::shiftPoint(pointC, pointB, dimH * 4); // calculate more precise dimensions - dimH = self.transitionsBetween(&pointAs, &pointD) + 1; - dimV = self.transitionsBetween(&pointCs, &pointD) + 1; + dimH = self.transitionsBetween(pointAs, pointD) + 1; + dimV = self.transitionsBetween(pointCs, pointD) + 1; if (dimH & 0x01) == 1 { dimH += 1; } @@ -316,7 +316,7 @@ impl<'a> Detector<'_> { [pointAs, pointBs, pointCs, pointDs] } - fn isValid(&self, p: &RXingResultPoint) -> bool { + fn isValid(&self, p: RXingResultPoint) -> bool { p.getX() >= 0.0 && p.getX() <= self.image.getWidth() as f32 - 1.0 && p.getY() > 0.0 @@ -325,10 +325,10 @@ impl<'a> Detector<'_> { fn sampleGrid( image: &BitMatrix, - topLeft: &RXingResultPoint, - bottomLeft: &RXingResultPoint, - bottomRight: &RXingResultPoint, - topRight: &RXingResultPoint, + topLeft: RXingResultPoint, + bottomLeft: RXingResultPoint, + bottomRight: RXingResultPoint, + topRight: RXingResultPoint, dimensionX: u32, dimensionY: u32, ) -> Result { @@ -360,7 +360,7 @@ impl<'a> Detector<'_> { /** * Counts the number of black/white transitions between two points, using something like Bresenham's algorithm. */ - fn transitionsBetween(&self, from: &RXingResultPoint, to: &RXingResultPoint) -> u32 { + fn transitionsBetween(&self, from: RXingResultPoint, to: RXingResultPoint) -> u32 { // See QR Code Detector, sizeOfBlackWhiteBlackRun() let mut fromX = from.getX().floor() as i32; let mut fromY = from.getY().floor() as i32; diff --git a/src/datamatrix/detector/zxing_cpp_detector/bitmatrix_cursor.rs b/src/datamatrix/detector/zxing_cpp_detector/bitmatrix_cursor.rs index 4c062d9..74db446 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/bitmatrix_cursor.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/bitmatrix_cursor.rs @@ -16,19 +16,19 @@ pub trait BitMatrixCursor { // BitMatrixCursor(const BitMatrix& image, POINT p, POINT d) : img(&image), p(p) { setDirection(d); } - fn testAt(&self, p: &RXingResultPoint) -> Value; //const - // { - // return img->isIn(p) ? Value{img->get(p)} : Value{}; - // } + fn testAt(&self, p: RXingResultPoint) -> Value; //const + // { + // return img->isIn(p) ? Value{img->get(p)} : Value{}; + // } - fn blackAt(&self, pos: &RXingResultPoint) -> bool { + fn blackAt(&self, pos: RXingResultPoint) -> bool { self.testAt(pos).isBlack() } - fn whiteAt(&self, pos: &RXingResultPoint) -> bool { + fn whiteAt(&self, pos: RXingResultPoint) -> bool { self.testAt(pos).isWhite() } - fn isIn(&self, p: &RXingResultPoint) -> bool; // { return img->isIn(p); } + fn isIn(&self, p: RXingResultPoint) -> bool; // { return img->isIn(p); } fn isInSelf(&self) -> bool; // { return self.isIn(p); } fn isBlack(&self) -> bool; // { return blackAt(p); } fn isWhite(&self) -> bool; // { return whiteAt(p); } @@ -46,30 +46,30 @@ pub trait BitMatrixCursor { fn turnRight(&mut self); //noexcept { d = right(); } fn turn(&mut self, dir: Direction); //noexcept { d = direction(dir); } - fn edgeAt_point(&self, d: &RXingResultPoint) -> Value; + fn edgeAt_point(&self, d: RXingResultPoint) -> Value; // { // Value v = testAt(p); // return testAt(p + d) != v ? v : Value(); // } fn edgeAtFront(&self) -> Value { - return self.edgeAt_point(self.front()); + return self.edgeAt_point(*self.front()); } fn edgeAtBack(&self) -> Value { - self.edgeAt_point(&self.back()) + self.edgeAt_point(self.back()) } fn edgeAtLeft(&self) -> Value { - self.edgeAt_point(&self.left()) + self.edgeAt_point(self.left()) } fn edgeAtRight(&self) -> Value { - self.edgeAt_point(&self.right()) + self.edgeAt_point(self.right()) } fn edgeAt_direction(&self, dir: Direction) -> Value { - self.edgeAt_point(&self.direction(dir)) + self.edgeAt_point(self.direction(dir)) } - fn setDirection(&mut self, dir: &RXingResultPoint); // { d = bresenhamDirection(dir); } - // fn setDirection(&self, dir:&RXingResultPoint);// { d = dir; } + fn setDirection(&mut self, dir: RXingResultPoint); // { d = bresenhamDirection(dir); } + // fn setDirection(&self, dir: RXingResultPoint);// { d = dir; } fn step(&mut self, s: Option) -> bool; // DEF to 1 // { @@ -77,7 +77,7 @@ pub trait BitMatrixCursor { // return isIn(p); // } - fn movedBy(self, d: &RXingResultPoint) -> Self; + fn movedBy(self, d: RXingResultPoint) -> Self; // { // auto res = *this; // res.p += d; diff --git a/src/datamatrix/detector/zxing_cpp_detector/cpp_new_detector.rs b/src/datamatrix/detector/zxing_cpp_detector/cpp_new_detector.rs index a5d188d..458d287 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/cpp_new_detector.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/cpp_new_detector.rs @@ -76,7 +76,7 @@ fn Scan( // follow left leg upwards t.turnRight(); t.state = 1; - CHECK!(t.traceLine(&t.right(), lineL)?); + CHECK!(t.traceLine(t.right(), lineL)?); CHECK!(t.traceCorner(&mut t.right(), &mut tl)?); lineL.reverse(); let mut tlTracer = t; @@ -84,19 +84,19 @@ fn Scan( // follow left leg downwards t = startTracer.clone(); t.state = 1; - t.setDirection(&tlTracer.right()); - CHECK!(t.traceLine(&t.left(), lineL)?); + t.setDirection(tlTracer.right()); + CHECK!(t.traceLine(t.left(), lineL)?); if !lineL.isValid() { - t.updateDirectionFromOrigin(&tl); + t.updateDirectionFromOrigin(tl); } let up = t.back(); CHECK!(t.traceCorner(&mut t.left(), &mut bl)?); // follow bottom leg right t.state = 2; - CHECK!(t.traceLine(&t.left(), lineB)?); + CHECK!(t.traceLine(t.left(), lineB)?); if !lineB.isValid() { - t.updateDirectionFromOrigin(&bl); + t.updateDirectionFromOrigin(bl); } let right = *t.front(); CHECK!(t.traceCorner(&mut t.left(), &mut br)?); @@ -109,9 +109,9 @@ fn Scan( // at this point we found a plausible L-shape and are now looking for the b/w pattern at the top and right: // follow top row right 'half way' (4 gaps), see traceGaps break condition with 'invalid' line - tlTracer.setDirection(&right); + tlTracer.setDirection(right); CHECK!(tlTracer.traceGaps( - &tlTracer.right(), + tlTracer.right(), lineT, maxStepSize, &mut DMRegressionLine::default() @@ -124,9 +124,9 @@ fn Scan( maxStepSize = std::cmp::min(lineT.length() as i32 / 3, (lenL / 5.0) as i32) * 2; // follow up until we reach the top line - t.setDirection(&up); + t.setDirection(up); t.state = 3; - CHECK!(t.traceGaps(&t.left(), lineR, maxStepSize, lineT)?); + CHECK!(t.traceGaps(t.left(), lineR, maxStepSize, lineT)?); CHECK!(t.traceCorner(&mut t.left(), &mut tr)?); let lenT = distance(&tl, &tr) - 1.0; @@ -140,7 +140,7 @@ fn Scan( ); // continue top row right until we cross the right line - CHECK!(tlTracer.traceGaps(&tlTracer.right(), lineT, maxStepSize, lineR)?); + CHECK!(tlTracer.traceGaps(tlTracer.right(), lineT, maxStepSize, lineR)?); // #ifdef PRINT_DEBUG // printf("L: %.1f, %.1f ^ %.1f, %.1f > %.1f, %.1f (%d : %d : %d : %d)\n", bl.x, bl.y, @@ -173,8 +173,8 @@ fn Scan( f64::INFINITY }; }; - splitDouble(lineT.modules(&tl, &tr)?, &mut dimT, &mut fracT); - splitDouble(lineR.modules(&br, &tr)?, &mut dimR, &mut fracR); + splitDouble(lineT.modules(tl, tr)?, &mut dimT, &mut fracT); + splitDouble(lineR.modules(br, tr)?, &mut dimR, &mut fracR); // #ifdef PRINT_DEBUG // printf("L: %.1f, %.1f ^ %.1f, %.1f > %.1f, %.1f ^> %.1f, %.1f\n", bl.x, bl.y, @@ -197,24 +197,24 @@ fn Scan( CHECK!((10..=144).contains(&dimT) && (8..=144).contains(&dimR)); - let movedTowardsBy = |a: &RXingResultPoint, - b1: &RXingResultPoint, - b2: &RXingResultPoint, + let movedTowardsBy = |a: RXingResultPoint, + b1: RXingResultPoint, + b2: RXingResultPoint, d: f32| -> RXingResultPoint { - *a + d * RXingResultPoint::normalized( - RXingResultPoint::normalized(*b1 - *a) + RXingResultPoint::normalized(*b2 - *a), + a + d * RXingResultPoint::normalized( + RXingResultPoint::normalized(b1 - a) + RXingResultPoint::normalized(b2 - a), ) }; // shrink shape by half a pixel to go from center of white pixel outside of code to the edge between white and black let sourcePoints = Quadrilateral::with_points( - movedTowardsBy(&tl, &tr, &bl, 0.5), + movedTowardsBy(tl, tr, bl, 0.5), // move the tr point a little less because the jagged top and right line tend to be statistically slightly // inclined toward the center anyway. - movedTowardsBy(&tr, &br, &tl, 0.3), - movedTowardsBy(&br, &bl, &tr, 0.5), - movedTowardsBy(&bl, &tl, &br, 0.5), + movedTowardsBy(tr, br, tl, 0.3), + movedTowardsBy(br, bl, tr, 0.5), + movedTowardsBy(bl, tl, br, 0.5), ); let grid_sampler = DefaultGridSampler::default(); @@ -303,7 +303,7 @@ pub fn detect( y: (image.getHeight() / 2) as f32, }; //PointF(image.width() / 2, image.height() / 2); let startPos = - RXingResultPoint::centered(&(center - center * dir + MIN_SYMBOL_SIZE as i32 / 2 * dir)); + RXingResultPoint::centered(center - center * dir + MIN_SYMBOL_SIZE as i32 / 2 * dir); if let Some(history) = &mut history { history.borrow_mut().clear(0); diff --git a/src/datamatrix/detector/zxing_cpp_detector/dm_regression_line.rs b/src/datamatrix/detector/zxing_cpp_detector/dm_regression_line.rs index 4a9976b..2e5ee5c 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/dm_regression_line.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/dm_regression_line.rs @@ -58,11 +58,11 @@ impl RegressionLine for DMRegressionLine { } } - fn signedDistance(&self, p: &RXingResultPoint) -> f32 { - RXingResultPoint::dot(self.normal(), *p) - self.c + fn signedDistance(&self, p: RXingResultPoint) -> f32 { + RXingResultPoint::dot(self.normal(), p) - self.c } - fn distance_single(&self, p: &RXingResultPoint) -> f32 { + fn distance_single(&self, p: RXingResultPoint) -> f32 { (self.signedDistance(p)).abs() } @@ -74,13 +74,13 @@ impl RegressionLine for DMRegressionLine { self.c = f32::NAN; } - fn add(&mut self, p: &RXingResultPoint) -> Result<(), Exceptions> { + fn add(&mut self, p: RXingResultPoint) -> Result<(), Exceptions> { if self.direction_inward == RXingResultPoint::default() { return Err(Exceptions::IllegalStateException(None)); } - self.points.push(*p); + self.points.push(p); if self.points.len() == 1 { - self.c = RXingResultPoint::dot(self.normal(), *p); + self.c = RXingResultPoint::dot(self.normal(), p); } Ok(()) } @@ -89,8 +89,8 @@ impl RegressionLine for DMRegressionLine { self.points.pop(); } - fn setDirectionInward(&mut self, d: &RXingResultPoint) { - self.direction_inward = RXingResultPoint::normalized(*d); + fn setDirectionInward(&mut self, d: RXingResultPoint) { + self.direction_inward = RXingResultPoint::normalized(d); } fn evaluate_max_distance( @@ -112,7 +112,7 @@ impl RegressionLine for DMRegressionLine { // return sd > maxSignedDist || sd < -2 * maxSignedDist; // }); // points.erase(end, points.end()); - points.retain(|p| { + points.retain(|&p| { let sd = self.signedDistance(p) as f64; !(sd > maxSignedDist || sd < -2.0 * maxSignedDist) }); @@ -142,8 +142,8 @@ impl RegressionLine for DMRegressionLine { max.y = float_max(max.y, p.y); } let diff = max - min; - let len = RXingResultPoint::maxAbsComponent(&diff); - let steps = float_min((diff.x).abs(), (diff.y).abs()); + let len = diff.maxAbsComponent(); + let steps = float_min(diff.x.abs(), diff.y.abs()); // due to aliasing we get bad extrapolations if the line is short and too close to vertical/horizontal steps > 2.0 || len > 50.0 } @@ -237,8 +237,8 @@ impl DMRegressionLine { pub fn modules( &mut self, - beg: &RXingResultPoint, - end: &RXingResultPoint, + beg: RXingResultPoint, + end: RXingResultPoint, ) -> Result { if self.points.len() <= 3 { return Err(Exceptions::IllegalStateException(None)); @@ -257,26 +257,27 @@ impl DMRegressionLine { for i in 1..self.points.len() { // for (size_t i = 1; i < _points.size(); ++i) gapSizes.push(self.distance( - &self.project(&self.points[i]), - &self.project(&self.points[i - 1]), + self.project(self.points[i]), + self.project(self.points[i - 1]), ) as f64); } // calculate the (expected average) distance of two adjacent pixels let unitPixelDist = RXingResultPoint::length(RXingResultPoint::bresenhamDirection( - &(*self - .points + self.points .last() + .copied() .ok_or(Exceptions::IndexOutOfBoundsException(None))? - - *self + - self .points .first() - .ok_or(Exceptions::IndexOutOfBoundsException(None))?), + .copied() + .ok_or(Exceptions::IndexOutOfBoundsException(None))?, )) as f64; // calculate the width of 2 modules (first black pixel to first black pixel) let mut sumFront: f64 = - self.distance(beg, &self.project(&self.points[0])) as f64 - unitPixelDist; + self.distance(beg, self.project(self.points[0])) as f64 - unitPixelDist; let mut sumBack: f64 = 0.0; // (last black pixel to last black pixel) for dist in gapSizes { // for (auto dist : gapSizes) { @@ -294,9 +295,10 @@ impl DMRegressionLine { sumFront + self.distance( end, - &self.project( + self.project( self.points .last() + .copied() .ok_or(Exceptions::IndexOutOfBoundsException(None))?, ), ) as f64, diff --git a/src/datamatrix/detector/zxing_cpp_detector/edge_tracer.rs b/src/datamatrix/detector/zxing_cpp_detector/edge_tracer.rs index d547e93..3237cb1 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/edge_tracer.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/edge_tracer.rs @@ -31,7 +31,7 @@ pub struct EdgeTracer<'a> { // } impl BitMatrixCursor for EdgeTracer<'_> { - fn testAt(&self, p: &RXingResultPoint) -> Value { + fn testAt(&self, p: RXingResultPoint) -> Value { if self.img.isIn(p, 0) { Value::from(self.img.get_point(p)) } else { @@ -39,20 +39,20 @@ impl BitMatrixCursor for EdgeTracer<'_> { } } - fn isIn(&self, p: &RXingResultPoint) -> bool { + fn isIn(&self, p: RXingResultPoint) -> bool { self.img.isIn(p, 0) } fn isInSelf(&self) -> bool { - self.isIn(&self.p) + self.isIn(self.p) } fn isBlack(&self) -> bool { - self.blackAt(&self.p) + self.blackAt(self.p) } fn isWhite(&self) -> bool { - self.whiteAt(&self.p) + self.whiteAt(self.p) } fn front(&self) -> &RXingResultPoint { @@ -96,28 +96,28 @@ impl BitMatrixCursor for EdgeTracer<'_> { self.d = self.direction(dir) } - fn edgeAt_point(&self, d: &RXingResultPoint) -> Value { - let v = self.testAt(&self.p); - if self.testAt(&(self.p + *d)) != v { + fn edgeAt_point(&self, d: RXingResultPoint) -> Value { + let v = self.testAt(self.p); + if self.testAt(self.p + d) != v { v } else { Value::Invalid } } - fn setDirection(&mut self, dir: &RXingResultPoint) { - self.d = RXingResultPoint::bresenhamDirection(dir) + fn setDirection(&mut self, dir: RXingResultPoint) { + self.d = dir.bresenhamDirection(); } fn step(&mut self, s: Option) -> bool { let s = if let Some(s) = s { s } else { 1.0 }; self.p += self.d * s; - self.isIn(&self.p) + self.isIn(self.p) } - fn movedBy(self, d: &RXingResultPoint) -> Self { + fn movedBy(self, d: RXingResultPoint) -> Self { let mut res = self; - res.p += *d; + res.p += d; res } @@ -135,11 +135,11 @@ impl BitMatrixCursor for EdgeTracer<'_> { let backup = if let Some(b) = backup { b } else { false }; // TODO: provide an alternative and faster out-of-bounds check than isIn() inside testAt() let mut steps = 0; - let mut lv = self.testAt(&self.p); + let mut lv = self.testAt(self.p); while nth > 0 && (range <= 0 || steps < range) && lv.isValid() { steps += 1; - let v = self.testAt(&(self.p + steps * self.d)); + let v = self.testAt(self.p + steps * self.d); if lv != v { lv = v; nth -= 1; @@ -167,11 +167,11 @@ impl<'a> EdgeTracer<'_> { fn traceStep( &mut self, - dEdge: &RXingResultPoint, + dEdge: RXingResultPoint, maxStepSize: i32, goodDirection: bool, ) -> Result { - let dEdge = RXingResultPoint::mainDirection(*dEdge); + let dEdge = RXingResultPoint::mainDirection(dEdge); for breadth in 1..=(if maxStepSize == 1 { 2 } else if goodDirection { @@ -189,19 +189,19 @@ impl<'a> EdgeTracer<'_> { + (if i & 1 > 0 { (i + 1) / 2 } else { -i / 2 }) * dEdge; // dbg!(pEdge); - if !self.blackAt(&(pEdge + dEdge)) { + if !self.blackAt(pEdge + dEdge) { continue; } // found black pixel -> go 'outward' until we hit the b/w border for _j in 0..(std::cmp::max(maxStepSize, 3)) { // for (int j = 0; j < std::max(maxStepSize, 3) && isIn(pEdge); ++j) { - if self.whiteAt(&pEdge) { + if self.whiteAt(pEdge) { // if we are not making any progress, we still have another endless loop bug - if self.p == RXingResultPoint::centered(&pEdge) { + if self.p == pEdge.centered() { return Err(Exceptions::IllegalStateException(None)); } - self.p = RXingResultPoint::centered(&pEdge); + self.p = pEdge.centered(); // if (self.history && maxStepSize == 1) { if let Some(history) = &self.history { @@ -222,12 +222,12 @@ impl<'a> EdgeTracer<'_> { return Ok(StepResult::Found); } pEdge = pEdge - dEdge; - if self.blackAt(&(pEdge - self.d)) { + if self.blackAt(pEdge - self.d) { pEdge = pEdge - self.d; } // dbg!(pEdge); - if !self.isIn(&pEdge) { + if !self.isIn(pEdge) { break; } } @@ -239,9 +239,9 @@ impl<'a> EdgeTracer<'_> { Ok(StepResult::OpenEnd) } - pub fn updateDirectionFromOrigin(&mut self, origin: &RXingResultPoint) -> bool { + pub fn updateDirectionFromOrigin(&mut self, origin: RXingResultPoint) -> bool { let old_d = self.d; - self.setDirection(&(self.p - origin)); + self.setDirection(self.p - origin); // if the new direction is pointing "backward", i.e. angle(new, old) > 90 deg -> break if RXingResultPoint::dot(self.d, old_d) < 0.0 { return false; @@ -260,24 +260,24 @@ impl<'a> EdgeTracer<'_> { pub fn traceLine( &mut self, - dEdge: &RXingResultPoint, + dEdge: RXingResultPoint, line: &mut T, ) -> Result { line.setDirectionInward(dEdge); loop { // log(self.p); - line.add(&self.p)?; + line.add(self.p)?; if line.points().len() % 50 == 10 { if !line.evaluate_max_distance(None, None) { return Ok(false); } if !self.updateDirectionFromOrigin( - &(self.p - line.project(&self.p) + self.p - line.project(self.p) + **line .points() .first() .as_ref() - .ok_or(Exceptions::IndexOutOfBoundsException(None))?), + .ok_or(Exceptions::IndexOutOfBoundsException(None))?, ) { return Ok(false); } @@ -291,7 +291,7 @@ impl<'a> EdgeTracer<'_> { pub fn traceGaps( &mut self, - dEdge: &RXingResultPoint, + dEdge: RXingResultPoint, line: &mut T, maxStepSize: i32, finishLine: &mut T, @@ -325,14 +325,14 @@ impl<'a> EdgeTracer<'_> { // if we drifted too far outside of the code, break if line.isValid() - && line.signedDistance(&self.p) < -5.0 - && (!line.evaluate_max_distance(None, None) || line.signedDistance(&self.p) < -5.0) + && line.signedDistance(self.p) < -5.0 + && (!line.evaluate_max_distance(None, None) || line.signedDistance(self.p) < -5.0) { return Ok(false); } // if we are drifting towards the inside of the code, pull the current position back out onto the line - if line.isValid() && line.signedDistance(&self.p) > 3.0 { + if line.isValid() && line.signedDistance(self.p) > 3.0 { // The current direction d and the line we are tracing are supposed to be roughly parallel. // In case the 'go outward' step in traceStep lead us astray, we might end up with a line // that is almost perpendicular to d. Then the back-projection below can result in an @@ -350,7 +350,7 @@ impl<'a> EdgeTracer<'_> { return Ok(false); } - let mut np = line.project(&self.p); + let mut np = line.project(self.p); // make sure we are making progress even when back-projecting: // consider a 90deg corner, rotated 45deg. we step away perpendicular from the line and get // back projected where we left off the line. @@ -362,14 +362,14 @@ impl<'a> EdgeTracer<'_> { line.project( line.points() .last() - .as_ref() + .copied() .ok_or(Exceptions::IndexOutOfBoundsException(None))?, ), ) < 1.0 { np += self.d; } - self.p = RXingResultPoint::centered(&np); + self.p = RXingResultPoint::centered(np); } else { let stepLengthInMainDir = if line.points().is_empty() { 0.0 @@ -380,10 +380,11 @@ impl<'a> EdgeTracer<'_> { - line .points() .last() + .copied() .ok_or(Exceptions::IndexOutOfBoundsException(None))?, ) }; - line.add(&self.p)?; + line.add(self.p)?; if stepLengthInMainDir > 1.0 { gaps += 1; @@ -392,11 +393,12 @@ impl<'a> EdgeTracer<'_> { return Ok(false); } if !self.updateDirectionFromOrigin( - &(self.p - line.project(&self.p) - + *line + self.p - line.project(self.p) + + line .points() .first() - .ok_or(Exceptions::IndexOutOfBoundsException(None))?), + .copied() + .ok_or(Exceptions::IndexOutOfBoundsException(None))?, ) { return Ok(false); } @@ -418,7 +420,7 @@ impl<'a> EdgeTracer<'_> { if finishLine.isValid() { maxStepSize = - std::cmp::min(maxStepSize, (finishLine.signedDistance(&self.p)) as i32); + std::cmp::min(maxStepSize, (finishLine.signedDistance(self.p)) as i32); } let stepResult = self.traceStep(dEdge, maxStepSize, line.isValid())?; @@ -428,7 +430,7 @@ impl<'a> EdgeTracer<'_> { { return Ok(stepResult == StepResult::OpenEnd && finishLine.isValid() - && (finishLine.signedDistance(&self.p)) as i32 <= maxStepSize + 1); + && (finishLine.signedDistance(self.p)) as i32 <= maxStepSize + 1); } } //while (true); } @@ -442,10 +444,10 @@ impl<'a> EdgeTracer<'_> { // log(p); *corner = self.p; std::mem::swap(&mut self.d, dir); - self.traceStep(&(-1.0 * dir), 2, false)?; + self.traceStep(-1.0 * (*dir), 2, false)?; // #ifdef PRINT_DEBUG // printf("turn: %.0f x %.0f -> %.2f, %.2f\n", p.x, p.y, d.x, d.y); // #endif - Ok(self.isIn(corner) && self.isIn(&self.p)) + Ok(self.isIn(*corner) && self.isIn(self.p)) } } diff --git a/src/datamatrix/detector/zxing_cpp_detector/quad.rs b/src/datamatrix/detector/zxing_cpp_detector/quad.rs index 99dcc2e..672d9d5 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/quad.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/quad.rs @@ -126,7 +126,7 @@ pub fn IsConvex(poly: &Quadrilateral) -> bool { { let d1 = poly.0[(i + 2) % N] - poly.0[(i + 1) % N]; let d2 = poly.0[i] - poly.0[(i + 1) % N]; - let cp = RXingResultPoint::cross(&d1, &d2); + let cp = d1.cross(d2); m = if m.abs() > cp { cp } else { m.abs() }; @@ -186,14 +186,14 @@ pub fn RotatedCorners(q: &Quadrilateral, n: Option, mirror: Option) - } #[allow(dead_code)] -pub fn IsInside(p: &RXingResultPoint, q: &Quadrilateral) -> bool { +pub fn IsInside(p: RXingResultPoint, q: &Quadrilateral) -> bool { // Test if p is on the same side (right or left) of all polygon segments let mut pos = 0; let mut neg = 0; for i in 0..q.0.len() // for (int i = 0; i < Size(q); ++i) { - if RXingResultPoint::cross(&(*p - q.0[i]), &(q.0[(i + 1) % q.0.len()] - q.0[i])) < 0.0 { + if RXingResultPoint::cross(p - q.0[i], q.0[(i + 1) % q.0.len()] - q.0[i]) < 0.0 { neg += 1; } else { pos += 1; diff --git a/src/datamatrix/detector/zxing_cpp_detector/regression_line.rs b/src/datamatrix/detector/zxing_cpp_detector/regression_line.rs index aa73470..a353c53 100644 --- a/src/datamatrix/detector/zxing_cpp_detector/regression_line.rs +++ b/src/datamatrix/detector/zxing_cpp_detector/regression_line.rs @@ -13,7 +13,7 @@ pub trait RegressionLine { // fn intersect(&self, l1: &T, l2: &T2) // -> RXingResultPoint; - // fn evaluate_begin_end(&self, begin:&RXingResultPoint, end:&RXingResultPoint) -> bool;// { + // fn evaluate_begin_end(&self, begin: RXingResultPoint, end: RXingResultPoint) -> bool;// { // { // let mean = std::accumulate(begin, end, PointF()) / std::distance(begin, end); // PointF::value_t sumXX = 0, sumYY = 0, sumXY = 0; @@ -43,8 +43,8 @@ pub trait RegressionLine { fn evaluate(&mut self, points: &[RXingResultPoint]) -> bool; // { return self.evaluate_begin_end(&points.front(), &points.back() + 1); } fn evaluateSelf(&mut self) -> bool; - fn distance(&self, a: &RXingResultPoint, b: &RXingResultPoint) -> f32 { - crate::result_point_utils::distance(a, b) + fn distance(&self, a: RXingResultPoint, b: RXingResultPoint) -> f32 { + crate::result_point_utils::distance(&a, &b) } // RegressionLine() { _points.reserve(16); } // arbitrary but plausible start size (tiny performance improvement) @@ -63,10 +63,10 @@ pub trait RegressionLine { fn length(&self) -> u32; //const { return _points.size() >= 2 ? int(distance(_points.front(), _points.back())) : 0; } fn isValid(&self) -> bool; //const { return !std::isnan(a); } fn normal(&self) -> RXingResultPoint; //const { return isValid() ? PointF(a, b) : _directionInward; } - fn signedDistance(&self, p: &RXingResultPoint) -> f32; //const { return dot(normal(), p) - c; } - fn distance_single(&self, p: &RXingResultPoint) -> f32; //const { return std::abs(signedDistance(PointF(p))); } - fn project(&self, p: &RXingResultPoint) -> RXingResultPoint { - *p - self.normal() * self.signedDistance(p) + fn signedDistance(&self, p: RXingResultPoint) -> f32; //const { return dot(normal(), p) - c; } + fn distance_single(&self, p: RXingResultPoint) -> f32; //const { return std::abs(signedDistance(PointF(p))); } + fn project(&self, p: RXingResultPoint) -> RXingResultPoint { + p - self.normal() * self.signedDistance(p) } fn reset(&mut self); @@ -76,16 +76,16 @@ pub trait RegressionLine { // a = b = c = NAN; // } - fn add(&mut self, p: &RXingResultPoint) -> Result<(), Exceptions>; //{ - // assert(_directionInward != PointF()); - // _points.push_back(p); - // if (_points.size() == 1) - // c = dot(normal(), p); - // } + fn add(&mut self, p: RXingResultPoint) -> Result<(), Exceptions>; //{ + // assert(_directionInward != PointF()); + // _points.push_back(p); + // if (_points.size() == 1) + // c = dot(normal(), p); + // } fn pop_back(&mut self); // { _points.pop_back(); } - fn setDirectionInward(&mut self, d: &RXingResultPoint); //{ _directionInward = normalized(d); } + fn setDirectionInward(&mut self, d: RXingResultPoint); //{ _directionInward = normalized(d); } // fn evaluate(&self, double maxSignedDist = -1, bool updatePoints = false) -> bool fn evaluate_max_distance( diff --git a/src/pdf417/decoder/pdf_417_scanning_decoder.rs b/src/pdf417/decoder/pdf_417_scanning_decoder.rs index a5c49fd..581a72b 100644 --- a/src/pdf417/decoder/pdf_417_scanning_decoder.rs +++ b/src/pdf417/decoder/pdf_417_scanning_decoder.rs @@ -68,7 +68,7 @@ pub fn decode( leftRowIndicatorColumn = Some(getRowIndicatorColumn( image, boundingBox.clone(), - imageTopLeft.as_ref().unwrap(), + imageTopLeft.unwrap(), true, minCodewordWidth, maxCodewordWidth, @@ -78,7 +78,7 @@ pub fn decode( rightRowIndicatorColumn = Some(getRowIndicatorColumn( image, boundingBox.clone(), - imageTopRight.as_ref().unwrap(), + imageTopRight.unwrap(), false, minCodewordWidth, maxCodewordWidth, @@ -358,7 +358,7 @@ fn getBarcodeMetadata( fn getRowIndicatorColumn<'a>( image: &BitMatrix, boundingBox: Rc, - startPoint: &RXingResultPoint, + startPoint: RXingResultPoint, leftToRight: bool, minCodewordWidth: u32, maxCodewordWidth: u32, diff --git a/src/rxing_result_point.rs b/src/rxing_result_point.rs index fb3128f..cb0f776 100644 --- a/src/rxing_result_point.rs +++ b/src/rxing_result_point.rs @@ -18,22 +18,26 @@ pub struct RXingResultPoint { pub(crate) x: f32, pub(crate) y: f32, } + impl Hash for RXingResultPoint { fn hash(&self, state: &mut H) { self.x.to_string().hash(state); self.y.to_string().hash(state); } } + impl PartialEq for RXingResultPoint { fn eq(&self, other: &Self) -> bool { self.x == other.x && self.y == other.y } } impl Eq for RXingResultPoint {} + impl RXingResultPoint { pub const fn new(x: f32, y: f32) -> Self { Self { x, y } } + pub const fn with_single(x: f32) -> Self { Self { x, y: x } } @@ -47,12 +51,8 @@ impl std::ops::AddAssign for RXingResultPoint { } impl<'a> Sum<&'a RXingResultPoint> for RXingResultPoint { - fn sum>(iter: I) -> Self { - let mut add = RXingResultPoint { x: 0.0, y: 0.0 }; - for n in iter { - add += *n; - } - add + fn sum>(iter: I) -> Self { + iter.fold(Self::default(), |acc, &p| acc + p) } } @@ -65,7 +65,7 @@ impl ResultPoint for RXingResultPoint { self.y } - fn into_rxing_result_point(self) -> RXingResultPoint { + fn into_rxing_result_point(self) -> Self { self } } @@ -77,7 +77,7 @@ impl fmt::Display for RXingResultPoint { } impl std::ops::Sub for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; fn sub(self, rhs: Self) -> Self::Output { Self { @@ -87,19 +87,8 @@ impl std::ops::Sub for RXingResultPoint { } } -impl std::ops::Sub<&RXingResultPoint> for RXingResultPoint { - type Output = RXingResultPoint; - - fn sub(self, rhs: &Self) -> Self::Output { - Self { - x: self.x - rhs.x, - y: self.y - rhs.y, - } - } -} - impl std::ops::Neg for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; fn neg(self) -> Self::Output { Self { @@ -110,9 +99,9 @@ impl std::ops::Neg for RXingResultPoint { } impl std::ops::Add for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; - fn add(self, rhs: RXingResultPoint) -> Self::Output { + fn add(self, rhs: Self) -> Self::Output { Self { x: self.x + rhs.x, y: self.y + rhs.y, @@ -121,9 +110,9 @@ impl std::ops::Add for RXingResultPoint { } impl std::ops::Mul for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; - fn mul(self, rhs: RXingResultPoint) -> Self::Output { + fn mul(self, rhs: Self) -> Self::Output { Self { x: self.x * rhs.x, y: self.y * rhs.y, @@ -132,7 +121,7 @@ impl std::ops::Mul for RXingResultPoint { } impl std::ops::Mul for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; fn mul(self, rhs: f32) -> Self::Output { Self { @@ -143,7 +132,7 @@ impl std::ops::Mul for RXingResultPoint { } impl std::ops::Mul for RXingResultPoint { - type Output = RXingResultPoint; + type Output = Self; fn mul(self, rhs: i32) -> Self::Output { Self { @@ -157,7 +146,7 @@ impl std::ops::Mul for i32 { type Output = RXingResultPoint; fn mul(self, rhs: RXingResultPoint) -> Self::Output { - RXingResultPoint { + Self::Output { x: rhs.x * self as f32, y: rhs.y * self as f32, } @@ -168,29 +157,7 @@ impl std::ops::Mul for f32 { type Output = RXingResultPoint; fn mul(self, rhs: RXingResultPoint) -> Self::Output { - RXingResultPoint { - x: rhs.x * self, - y: rhs.y * self, - } - } -} - -impl std::ops::Mul<&RXingResultPoint> for f32 { - type Output = RXingResultPoint; - - fn mul(self, rhs: &RXingResultPoint) -> Self::Output { - RXingResultPoint { - x: rhs.x * self, - y: rhs.y * self, - } - } -} - -impl std::ops::Mul<&mut RXingResultPoint> for f32 { - type Output = RXingResultPoint; - - fn mul(self, rhs: &mut RXingResultPoint) -> Self::Output { - RXingResultPoint { + Self::Output { x: rhs.x * self, y: rhs.y * self, } @@ -209,66 +176,57 @@ impl std::ops::Div for RXingResultPoint { } impl RXingResultPoint { - pub fn dot(a: RXingResultPoint, b: RXingResultPoint) -> f32 { - a.x * b.x + a.y * b.y + pub fn dot(self, p: Self) -> f32 { + self.x * p.x + self.y * p.y } - pub fn cross(a: &RXingResultPoint, b: &RXingResultPoint) -> f32 { - a.x * b.y - b.x * a.y + pub fn cross(self, p: Self) -> f32 { + self.x * p.y - p.x * self.y } /// L1 norm - pub fn sumAbsComponent(p: &RXingResultPoint) -> f32 { - (p.x).abs() + (p.y).abs() + pub fn sumAbsComponent(self) -> f32 { + self.x.abs() + self.y.abs() } /// L2 norm - pub fn length(p: RXingResultPoint) -> f32 { - (Self::dot(p, p)).sqrt() + pub fn length(self) -> f32 { + Self::dot(self, self).sqrt() } /// L-inf norm - pub fn maxAbsComponent(p: &RXingResultPoint) -> f32 { - let a = (p.x).abs(); - let b = (p.y).abs(); - - if a > b { - a - } else { - b - } - - // return std::cmp::max((p.x).abs(), (p.y).abs()); + pub fn maxAbsComponent(self) -> f32 { + f32::max(self.x.abs(), self.y.abs()) } - pub fn distance(a: RXingResultPoint, b: RXingResultPoint) -> f32 { - Self::length(a - b) + pub fn distance(self, p: Self) -> f32 { + Self::length(self - p) } /// Calculate a floating point pixel coordinate representing the 'center' of the pixel. /// This is sort of the inverse operation of the PointI(PointF) conversion constructor. /// See also the documentation of the GridSampler API. #[inline(always)] - pub fn centered(p: &RXingResultPoint) -> RXingResultPoint { - RXingResultPoint { - x: (p.x).floor() + 0.5, - y: (p.y).floor() + 0.5, + pub fn centered(self) -> Self { + Self { + x: self.x.floor() + 0.5, + y: self.y.floor() + 0.5, } } - pub fn normalized(d: RXingResultPoint) -> RXingResultPoint { - d / Self::length(d) + pub fn normalized(self) -> Self { + self / Self::length(self) } - pub fn bresenhamDirection(d: &RXingResultPoint) -> RXingResultPoint { - *d / Self::maxAbsComponent(d) + pub fn bresenhamDirection(self) -> Self { + self / Self::maxAbsComponent(self) } - pub fn mainDirection(d: RXingResultPoint) -> RXingResultPoint { - if (d.x).abs() > (d.y).abs() { - Self::new(d.x, 0.0) + pub fn mainDirection(self) -> Self { + if self.x.abs() > self.y.abs() { + Self::new(self.x, 0.0) } else { - Self::new(0.0, d.y) + Self::new(0.0, self.y) } } }