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

common module and submodules no red

Browse Source
This commit is contained in:
Henry Schimke
2022-08-17 14:51:34 -05:00
parent fc8cdf5f9e
commit 87f98db943
5 changed files with 148 additions and 132 deletions
Download Patch File Download Diff File Expand all files Collapse all files

8
src/aztec.rs
View File

@@ -19,13 +19,13 @@ use crate::aztec::encoder::{AztecCode,Encoder};
* @author Sean Owen * @author Sean Owen
*/ */
pub struct AztecDetectorResult { pub struct AztecDetectorResult {
super: DetectorResult; //super: DetectorResult;
let compact: bool; compact: bool,
let nb_datablocks: i32; nb_datablocks: i32,
let nb_layers: i32; nb_layers: i32
} }
impl DetectorResult for AztecDetectorResult { impl DetectorResult for AztecDetectorResult {

113
src/common.rs
View File

@@ -1,3 +1,6 @@
pub mod detector;
pub mod readsolomon;
use std::collections::HashMap; use std::collections::HashMap;
use crate::{Binarizer,LuminanceSource,NotFoundException,FormatException,NotFoundException,Binarizer,ResultPoint}; use crate::{Binarizer,LuminanceSource,NotFoundException,FormatException,NotFoundException,Binarizer,ResultPoint};
@@ -172,7 +175,7 @@ impl GridSampler {
*/ */
pub fn sample_grid(&self, image: &BitMatrix, dimension_x: i32, dimension_y: i32, p1_to_x: f32, p1_to_y: f32, p2_to_x: f32, p2_to_y: f32, p3_to_x: f32, p3_to_y: f32, p4_to_x: f32, p4_to_y: f32, p1_from_x: f32, p1_from_y: f32, p2_from_x: f32, p2_from_y: f32, p3_from_x: f32, p3_from_y: f32, p4_from_x: f32, p4_from_y: f32) -> Result<BitMatrix, NotFoundException> ; pub fn sample_grid(&self, image: &BitMatrix, dimension_x: i32, dimension_y: i32, p1_to_x: f32, p1_to_y: f32, p2_to_x: f32, p2_to_y: f32, p3_to_x: f32, p3_to_y: f32, p4_to_x: f32, p4_to_y: f32, p1_from_x: f32, p1_from_y: f32, p2_from_x: f32, p2_from_y: f32, p3_from_x: f32, p3_from_y: f32, p4_from_x: f32, p4_from_y: f32) -> Result<BitMatrix, NotFoundException> ;
pub fn sample_grid(&self, image: &BitMatrix, dimension_x: i32, dimension_y: i32, transform: &PerspectiveTransform) -> /* throws NotFoundException */Result<BitMatrix, Rc<Exception>> ; pub fn sample_grid(&self, image: &BitMatrix, dimension_x: i32, dimension_y: i32, transform: &PerspectiveTransform) -> Result<BitMatrix, NotFoundException> ;
/** /**
* <p>Checks a set of points that have been transformed to sample points on an image against * <p>Checks a set of points that have been transformed to sample points on an image against
@@ -207,14 +210,14 @@ impl GridSampler {
} }
nudged = false; nudged = false;
if x == -1 { if x == -1 {
points[offset] = 0.0f; points[offset] = 0.0f32;
nudged = true; nudged = true;
} else if x == width { } else if x == width {
points[offset] = width - 1.0; points[offset] = width - 1.0;
nudged = true; nudged = true;
} }
if y == -1 { if y == -1 {
points[offset + 1] = 0.0f; points[offset + 1] = 0.0f32;
nudged = true; nudged = true;
} else if y == height { } else if y == height {
points[offset + 1] = height - 1.0; points[offset + 1] = height - 1.0;
@@ -238,14 +241,14 @@ impl GridSampler {
} }
nudged = false; nudged = false;
if x == -1 { if x == -1 {
points[offset] = 0.0f; points[offset] = 0.0f32;
nudged = true; nudged = true;
} else if x == width { } else if x == width {
points[offset] = width - 1.0; points[offset] = width - 1.0;
nudged = true; nudged = true;
} }
if y == -1 { if y == -1 {
points[offset + 1] = 0.0f; points[offset + 1] = 0.0f32;
nudged = true; nudged = true;
} else if y == height { } else if y == height {
points[offset + 1] = height - 1.0; points[offset + 1] = height - 1.0;
@@ -524,7 +527,7 @@ impl GlobalHistogramBinarizer {
*/ */
const EMPTY_BITS : Vec<i32> = Vec!([]); const EMPTY_BITS : Vec<i32> = Vec!([]);
const LOAD_FACTOR: f32 = 0.75f; const LOAD_FACTOR: f32 = 0.75f32;
#[derive(Cloneable, Eq, Hash)] #[derive(Cloneable, Eq, Hash)]
pub struct BitArray { pub struct BitArray {
@@ -1362,7 +1365,7 @@ Ok(())
* *
* @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white * @return {@code left,top,width,height} enclosing rectangle of all 1 bits, or null if it is all white
*/ */
pub fn get_enclosing_rectangle(&self) -> Vec<i32> { pub fn get_enclosing_rectangle(&self) -> Option<Vec<i32>> {
let mut left: i32 = self.width; let mut left: i32 = self.width;
let mut top: i32 = self.height; let mut top: i32 = self.height;
let mut right: i32 = -1; let mut right: i32 = -1;
@@ -1415,7 +1418,7 @@ Ok(())
if right < left || bottom < top { if right < left || bottom < top {
return null; return null;
} }
return vec![left, top, right - left + 1, bottom - top + 1, ] return Some(vec![left, top, right - left + 1, bottom - top + 1, ])
; ;
} }
@@ -1424,7 +1427,7 @@ Ok(())
* *
* @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white * @return {@code x,y} coordinate of top-left-most 1 bit, or null if it is all white
*/ */
pub fn get_top_left_on_bit(&self) -> Vec<i32> { pub fn get_top_left_on_bit(&self) -> Option<Vec<i32>> {
let bits_offset: i32 = 0; let bits_offset: i32 = 0;
while bits_offset < self.bits.len() && self.bits[bits_offset] == 0 { while bits_offset < self.bits.len() && self.bits[bits_offset] == 0 {
bits_offset += 1; bits_offset += 1;
@@ -1440,7 +1443,7 @@ Ok(())
bit += 1; bit += 1;
} }
x += bit; x += bit;
return vec![x, y, ] return Some(vec![x, y, ])
; ;
} }
@@ -1735,7 +1738,7 @@ impl CharacterSetECI {
* @return CharacterSetECI representing ECI for character encoding, or null if it is legal * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
* but unsupported * but unsupported
*/ */
pub fn get_character_set_e_c_i( charset: &str) -> Result<CharacterSetECI,&'static str> { pub fn get_character_set_e_c_i( charset: &str) -> Result<Option<CharacterSetECI>,&'static str> {
//return NAME_TO_ECI::get(&charset.name()); //return NAME_TO_ECI::get(&charset.name());
let eci = match charset { let eci = match charset {
"Cp437" => Self::Cp437, "Cp437" => Self::Cp437,
@@ -1762,7 +1765,7 @@ impl CharacterSetECI {
"EUC-KR" => Self::EUC_KR, "EUC-KR" => Self::EUC_KR,
_ => return Err("Invalid charset") _ => return Err("Invalid charset")
}; };
Ok(eci) Ok(Some(eci))
} }
/** /**
@@ -1771,7 +1774,7 @@ _ => return Err("Invalid charset")
* unsupported * unsupported
* @throws FormatException if ECI value is invalid * @throws FormatException if ECI value is invalid
*/ */
pub fn get_character_set_e_c_i_by_value( value: i32) -> Result<CharacterSetECI, FormatException> { pub fn get_character_set_e_c_i_by_value( value: i32) -> Result<Option<CharacterSetECI>, FormatException> {
if value < 0 || value >= 900 { if value < 0 || value >= 900 {
return Err( FormatException::get_format_instance()); return Err( FormatException::get_format_instance());
} }
@@ -1801,7 +1804,7 @@ _ => return Err("Invalid charset")
_ => return Err( FormatException::get_format_instance()) _ => return Err( FormatException::get_format_instance())
}; };
return Ok(eci); return Ok(Some(eci));
} }
pub fn get_value(v: Self) -> i32 { pub fn get_value(v: Self) -> i32 {
@@ -1831,7 +1834,7 @@ _ => return Err( FormatException::get_format_instance())
} }
} }
/** /*
* @param name character set ECI encoding name * @param name character set ECI encoding name
* @return CharacterSetECI representing ECI for character encoding, or null if it is legal * @return CharacterSetECI representing ECI for character encoding, or null if it is legal
* but unsupported * but unsupported
@@ -1899,8 +1902,8 @@ impl DecoderResult {
/** /**
* @return raw bytes representing the result, or {@code null} if not applicable * @return raw bytes representing the result, or {@code null} if not applicable
*/ */
pub fn get_raw_bytes(&self) -> Vec<i8> { pub fn get_raw_bytes(&self) -> Option<Vec<i8>> {
return self.raw_bytes; return Some(self.raw_bytes);
} }
/** /**
@@ -1929,21 +1932,21 @@ impl DecoderResult {
/** /**
* @return list of byte segments in the result, or {@code null} if not applicable * @return list of byte segments in the result, or {@code null} if not applicable
*/ */
pub fn get_byte_segments(&self) -> List<Vec<i8>> { pub fn get_byte_segments(&self) -> Option<Vector<Vec<i8>>> {
return self.byte_segments; return self.byte_segments;
} }
/** /**
* @return name of error correction level used, or {@code null} if not applicable * @return name of error correction level used, or {@code null} if not applicable
*/ */
pub fn get_e_c_level(&self) -> String { pub fn get_e_c_level(&self) -> Option<String> {
return self.ec_level; return Some(self.ec_level);
} }
/** /**
* @return number of errors corrected, or {@code null} if not applicable * @return number of errors corrected, or {@code null} if not applicable
*/ */
pub fn get_errors_corrected(&self) -> Integer { pub fn get_errors_corrected(&self) -> Option<Integer> {
return self.errors_corrected; return self.errors_corrected;
} }
@@ -1954,7 +1957,7 @@ impl DecoderResult {
/** /**
* @return number of erasures corrected, or {@code null} if not applicable * @return number of erasures corrected, or {@code null} if not applicable
*/ */
pub fn get_erasures(&self) -> Integer { pub fn get_erasures(&self) -> Option<Integer> {
return self.erasures; return self.erasures;
} }
@@ -2017,12 +2020,12 @@ impl GridSampler for DefaultGridSampler {
while y < dimension_y { while y < dimension_y {
{ {
let max: i32 = points.len(); let max: i32 = points.len();
let i_value: f32 = y + 0.5f; let i_value: f32 = y + 0.5f32;
{ {
let mut x: i32 = 0; let mut x: i32 = 0;
while x < max { while x < max {
{ {
points[x] = (x / 2.0) as f32 + 0.5f; points[x] = (x / 2.0) as f32 + 0.5f32;
points[x + 1] = i_value; points[x + 1] = i_value;
} }
x += 2; x += 2;
@@ -3086,43 +3089,43 @@ impl MinimalECIInput {
return ints; return ints;
} }
struct InputEdge { }
c: char, struct InputEdge {
//the encoding of this edge c: char,
encoder_index: i32,
previous: InputEdge, //the encoding of this edge
encoder_index: i32,
cached_total_size: i32 previous: InputEdge,
}
impl InputEdge { cached_total_size: i32
}
fn new( c: char, encoder_set: &ECIEncoderSet, encoder_index: i32, previous: &InputEdge, fnc1: i32) -> Self { impl InputEdge {
let mut new_ie : Self;
new_ie .c = if c == fnc1 { 1000 } else { c };
new_ie .encoderIndex = encoder_index;
new_ie .previous = previous;
let mut size: i32 = if new_ie .c == 1000 { 1 } else { encoder_set.encode(c, encoder_index).len() };
let previous_encoder_index: i32 = if previous == null { 0 } else { previous.encoderIndex };
if previous_encoder_index != encoder_index {
size += COST_PER_ECI;
}
if previous != null {
size += previous.cachedTotalSize;
}
new_ie .cachedTotalSize = size;
new_ie fn new( c: char, encoder_set: &ECIEncoderSet, encoder_index: i32, previous: &InputEdge, fnc1: i32) -> Self {
} let mut new_ie : Self;
new_ie .c = if c == fnc1 { 1000 } else { c };
new_ie .encoderIndex = encoder_index;
new_ie .previous = previous;
let mut size: i32 = if new_ie .c == 1000 { 1 } else { encoder_set.encode(c, encoder_index).len() };
let previous_encoder_index: i32 = if previous == null { 0 } else { previous.encoderIndex };
if previous_encoder_index != encoder_index {
size += COST_PER_ECI;
}
if previous != null {
size += previous.cachedTotalSize;
}
new_ie .cachedTotalSize = size;
fn is_f_n_c1(&self) -> bool { new_ie
return self.c == 1000; }
}
}
fn is_f_n_c1(&self) -> bool {
return self.c == 1000;
}
} }
// PerspectiveTransform.java // PerspectiveTransform.java
@@ -3215,9 +3218,9 @@ impl PerspectiveTransform {
pub fn square_to_quadrilateral( x0: f32, y0: f32, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) -> PerspectiveTransform { pub fn square_to_quadrilateral( x0: f32, y0: f32, x1: f32, y1: f32, x2: f32, y2: f32, x3: f32, y3: f32) -> PerspectiveTransform {
let dx3: f32 = x0 - x1 + x2 - x3; let dx3: f32 = x0 - x1 + x2 - x3;
let dy3: f32 = y0 - y1 + y2 - y3; let dy3: f32 = y0 - y1 + y2 - y3;
if dx3 == 0.0f && dy3 == 0.0f { if dx3 == 0.0f32 && dy3 == 0.0f32 {
// Affine // Affine
return PerspectiveTransform::new(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f, 0.0f, 1.0f); return PerspectiveTransform::new(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f32, 0.0f32, 1.0f32);
} else { } else {
let dx1: f32 = x1 - x2; let dx1: f32 = x1 - x2;
let dx2: f32 = x3 - x2; let dx2: f32 = x3 - x2;
@@ -3226,7 +3229,7 @@ impl PerspectiveTransform {
let denominator: f32 = dx1 * dy2 - dx2 * dy1; let denominator: f32 = dx1 * dy2 - dx2 * dy1;
let a13: f32 = (dx3 * dy2 - dx2 * dy3) / denominator; let a13: f32 = (dx3 * dy2 - dx2 * dy3) / denominator;
let a23: f32 = (dx1 * dy3 - dx3 * dy1) / denominator; let a23: f32 = (dx1 * dy3 - dx3 * dy1) / denominator;
return PerspectiveTransform::new(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f); return PerspectiveTransform::new(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0 + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f32);
} }
} }

18
src/common/detector.rs
View File

@@ -24,7 +24,7 @@ impl MathUtils {
* @return nearest {@code int} * @return nearest {@code int}
*/ */
pub fn round( d: f32) -> i32 { pub fn round( d: f32) -> i32 {
return (d + ( if d < 0.0f { -0.5f } else { 0.5f })) as i32; return (d + ( if d < 0.0f32 { -0.5f32 } else { 0.5f32 })) as i32;
} }
/** /**
@@ -86,7 +86,7 @@ pub struct MonochromeRectangleDetector {
impl MonochromeRectangleDetector { impl MonochromeRectangleDetector {
pub fn new( image: &BitMatrix) -> Self { pub fn new( image: &BitMatrix) -> Self {
Self{ image }; Self{ image }
} }
/** /**
@@ -208,7 +208,7 @@ impl MonochromeRectangleDetector {
* @return int[] with start and end of found range, or null if no such range is found * @return int[] with start and end of found range, or null if no such range is found
* (e.g. only white was found) * (e.g. only white was found)
*/ */
fn black_white_range(&self, fixed_dimension: i32, max_white_run: i32, min_dim: i32, max_dim: i32, horizontal: bool) -> Vec<i32> { fn black_white_range(&self, fixed_dimension: i32, max_white_run: i32, min_dim: i32, max_dim: i32, horizontal: bool) -> Option<Vec<i32>> {
let center: i32 = (min_dim + max_dim) / 2; let center: i32 = (min_dim + max_dim) / 2;
// Scan left/up first // Scan left/up first
let mut start: i32 = center; let mut start: i32 = center;
@@ -248,7 +248,7 @@ impl MonochromeRectangleDetector {
} }
} }
end -= 1; end -= 1;
return if end > start { vec![start, end, ] return if end > start { Some(vec![start, end, ])
} else { null }; } else { null };
} }
} }
@@ -288,7 +288,7 @@ pub struct WhiteRectangleDetector {
impl WhiteRectangleDetector { impl WhiteRectangleDetector {
pub fn new( image: &BitMatrix) -> Result<Self, NotFoundException> { pub fn new( image: &BitMatrix) -> Result<Self, NotFoundException> {
this(image, INIT_SIZE, image.get_width() / 2, image.get_height() / 2); this(image, INIT_SIZE, image.get_width() / 2, image.get_height() / 2)
} }
/** /**
@@ -475,13 +475,13 @@ impl WhiteRectangleDetector {
if y == null { if y == null {
return Err( NotFoundException::get_not_found_instance()); return Err( NotFoundException::get_not_found_instance());
} }
return Ok(self.center_edges(y, z, x, t)); return Ok(self.center_edges(&y, &z, &x, &t));
} else { } else {
return Err( NotFoundException::get_not_found_instance()); return Err( NotFoundException::get_not_found_instance());
} }
} }
fn get_black_point_on_segment(&self, a_x: f32, a_y: f32, b_x: f32, b_y: f32) -> ResultPoint { fn get_black_point_on_segment(&self, a_x: f32, a_y: f32, b_x: f32, b_y: f32) -> Option<ResultPoint> {
let dist: i32 = MathUtils::round(&MathUtils::distance(a_x, a_y, b_x, b_y)); let dist: i32 = MathUtils::round(&MathUtils::distance(a_x, a_y, b_x, b_y));
let x_step: f32 = (b_x - a_x) / dist; let x_step: f32 = (b_x - a_x) / dist;
let y_step: f32 = (b_y - a_y) / dist; let y_step: f32 = (b_y - a_y) / dist;
@@ -492,7 +492,7 @@ impl WhiteRectangleDetector {
let x: i32 = MathUtils::round(a_x + i * x_step); let x: i32 = MathUtils::round(a_x + i * x_step);
let y: i32 = MathUtils::round(a_y + i * y_step); let y: i32 = MathUtils::round(a_y + i * y_step);
if self.image.get(x, y) { if self.image.get(x, y) {
return ResultPoint::new(x, y); return Some(ResultPoint::new(x, y));
} }
} }
i += 1; i += 1;
@@ -530,7 +530,7 @@ impl WhiteRectangleDetector {
let xj: f32 = x.get_y(); let xj: f32 = x.get_y();
let ti: f32 = t.get_x(); let ti: f32 = t.get_x();
let tj: f32 = t.get_y(); let tj: f32 = t.get_y();
if yi < self.width / 2.0f { if yi < self.width / 2.0f32 {
return vec![ResultPoint::new(ti - CORR, tj + CORR), ResultPoint::new(zi + CORR, zj + CORR), ResultPoint::new(xi - CORR, xj - CORR), ResultPoint::new(yi + CORR, yj - CORR), ] return vec![ResultPoint::new(ti - CORR, tj + CORR), ResultPoint::new(zi + CORR, zj + CORR), ResultPoint::new(xi - CORR, xj - CORR), ResultPoint::new(yi + CORR, yj - CORR), ]
; ;
} else { } else {

55
src/common/readsolomon.rs
View File

@@ -138,7 +138,7 @@ impl GenericGFPoly {
} }
} }
return GenericGFPoly::new(self.field, &sum_diff); return GenericGFPoly::new(&self.field, &sum_diff);
} }
fn multiply(&self, other: &GenericGFPoly) -> Result<GenericGFPoly,IllegalArgumentException> { fn multiply(&self, other: &GenericGFPoly) -> Result<GenericGFPoly,IllegalArgumentException> {
@@ -146,7 +146,7 @@ impl GenericGFPoly {
return Err(IllegalArgumentException::new("GenericGFPolys do not have same GenericGF field")); return Err(IllegalArgumentException::new("GenericGFPolys do not have same GenericGF field"));
} }
if self.is_zero() || other.is_zero() { if self.is_zero() || other.is_zero() {
return self.field.get_zero(); return Ok(self.field.get_zero());
} }
let a_coefficients: Vec<i32> = self.coefficients; let a_coefficients: Vec<i32> = self.coefficients;
let a_length: i32 = a_coefficients.len(); let a_length: i32 = a_coefficients.len();
@@ -173,7 +173,7 @@ impl GenericGFPoly {
} }
} }
return GenericGFPoly::new(self.field, &product); return GenericGFPoly::new(&self.field, &product);
} }
fn multiply(&self, scalar: i32) -> GenericGFPoly { fn multiply(&self, scalar: i32) -> GenericGFPoly {
@@ -195,7 +195,7 @@ impl GenericGFPoly {
} }
} }
return GenericGFPoly::new(self.field, &product); return GenericGFPoly::new(&self.field, &product);
} }
fn multiply_by_monomial(&self, degree: i32, coefficient: i32) -> Result<GenericGFPoly,IllegalArgumentException> { fn multiply_by_monomial(&self, degree: i32, coefficient: i32) -> Result<GenericGFPoly,IllegalArgumentException> {
@@ -203,7 +203,7 @@ impl GenericGFPoly {
return Err( IllegalArgumentException::new()); return Err( IllegalArgumentException::new());
} }
if coefficient == 0 { if coefficient == 0 {
return self.field.get_zero(); return Ok(self.field.get_zero());
} }
let size: i32 = self.coefficients.len(); let size: i32 = self.coefficients.len();
let mut product: [i32; size + degree] = [0; size + degree]; let mut product: [i32; size + degree] = [0; size + degree];
@@ -217,7 +217,7 @@ impl GenericGFPoly {
} }
} }
return GenericGFPoly::new(self.field, &product); return GenericGFPoly::new(&self.field, &product);
} }
fn divide(&self, other: &GenericGFPoly) -> Result<Vec<GenericGFPoly>,IllegalArgumentException> { fn divide(&self, other: &GenericGFPoly) -> Result<Vec<GenericGFPoly>,IllegalArgumentException> {
@@ -236,16 +236,15 @@ impl GenericGFPoly {
let scale: i32 = self.field.multiply(&remainder.get_coefficient(&remainder.get_degree()), inverse_denominator_leading_term); let scale: i32 = self.field.multiply(&remainder.get_coefficient(&remainder.get_degree()), inverse_denominator_leading_term);
let term: GenericGFPoly = other.multiply_by_monomial(degree_difference, scale); let term: GenericGFPoly = other.multiply_by_monomial(degree_difference, scale);
let iteration_quotient: GenericGFPoly = self.field.build_monomial(degree_difference, scale); let iteration_quotient: GenericGFPoly = self.field.build_monomial(degree_difference, scale);
quotient = quotient.add_or_subtract(iteration_quotient); quotient = quotient.add_or_subtract(&iteration_quotient);
remainder = remainder.add_or_subtract(term); remainder = remainder.add_or_subtract(&term);
} }
return vec![quotient, remainder, ] return Ok(vec![quotient, remainder, ]);
;
} }
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
if self.is_zero() { if self.is_zero() {
return "0"; return "0".to_owned();
} }
let result: StringBuilder = StringBuilder::new(8 * self.get_degree()); let result: StringBuilder = StringBuilder::new(8 * self.get_degree());
{ {
@@ -395,8 +394,8 @@ impl GenericGF {
} }
// logTable[0] == 0 but this should never be used // logTable[0] == 0 but this should never be used
new_generic_gf.zero = GenericGFPoly::new( vec![0, ]); new_generic_gf.zero = GenericGFPoly::new( 0, &vec![0, ]);
new_generic_gf.one = GenericGFPoly::new( vec![1, ]); new_generic_gf.one = GenericGFPoly::new( 0, &vec![1, ]);
new_generic_gf new_generic_gf
} }
@@ -417,7 +416,7 @@ impl GenericGF {
return Err( IllegalArgumentException::new()); return Err( IllegalArgumentException::new());
} }
if coefficient == 0 { if coefficient == 0 {
return self.zero; return Ok(self.zero);
} }
let mut coefficients: [i32; degree + 1] = [0; degree + 1]; let mut coefficients: [i32; degree + 1] = [0; degree + 1];
coefficients[0] = coefficient; coefficients[0] = coefficient;
@@ -526,8 +525,8 @@ impl ReedSolomonDecoder {
* @param twoS number of error-correction codewords available * @param twoS number of error-correction codewords available
* @throws ReedSolomonException if decoding fails for any reason * @throws ReedSolomonException if decoding fails for any reason
*/ */
pub fn decode(&self, received: &Vec<i32>, two_s: i32) -> Result<_, ReedSolomonException> { pub fn decode(&self, received: &Vec<i32>, two_s: i32) -> Result<(), ReedSolomonException> {
let poly: GenericGFPoly = GenericGFPoly::new(self.field, &received); let poly: GenericGFPoly = GenericGFPoly::new(&self.field, &received);
let syndrome_coefficients: [i32; two_s] = [0; two_s]; let syndrome_coefficients: [i32; two_s] = [0; two_s];
let no_error: bool = true; let no_error: bool = true;
{ {
@@ -547,12 +546,12 @@ impl ReedSolomonDecoder {
if no_error { if no_error {
return; return;
} }
let syndrome: GenericGFPoly = GenericGFPoly::new(self.field, &syndrome_coefficients); let syndrome: GenericGFPoly = GenericGFPoly::new(&self.field, &syndrome_coefficients);
let sigma_omega: Vec<GenericGFPoly> = self.run_euclidean_algorithm(&self.field.build_monomial(two_s, 1), syndrome, two_s); let sigma_omega: Vec<GenericGFPoly> = self.run_euclidean_algorithm(&self.field.build_monomial(two_s, 1), &syndrome, two_s);
let sigma: GenericGFPoly = sigma_omega[0]; let sigma: GenericGFPoly = sigma_omega[0];
let omega: GenericGFPoly = sigma_omega[1]; let omega: GenericGFPoly = sigma_omega[1];
let error_locations: Vec<i32> = self.find_error_locations(sigma); let error_locations: Vec<i32> = self.find_error_locations(&sigma);
let error_magnitudes: Vec<i32> = self.find_error_magnitudes(omega, &error_locations); let error_magnitudes: Vec<i32> = self.find_error_magnitudes(&omega, &error_locations);
{ {
let mut i: i32 = 0; let mut i: i32 = 0;
while i < error_locations.len() { while i < error_locations.len() {
@@ -566,6 +565,7 @@ impl ReedSolomonDecoder {
i += 1; i += 1;
} }
} }
Ok(())
} }
@@ -574,7 +574,7 @@ impl ReedSolomonDecoder {
if a.get_degree() < b.get_degree() { if a.get_degree() < b.get_degree() {
let temp: GenericGFPoly = a; let temp: GenericGFPoly = a;
a = b; a = b;
b = temp; b = &temp;
} }
let r_last: GenericGFPoly = a; let r_last: GenericGFPoly = a;
let mut r: GenericGFPoly = b; let mut r: GenericGFPoly = b;
@@ -601,7 +601,7 @@ impl ReedSolomonDecoder {
q = q.add_or_subtract(&self.field.build_monomial(degree_diff, scale)); q = q.add_or_subtract(&self.field.build_monomial(degree_diff, scale));
r = r.add_or_subtract(&r_last.multiply_by_monomial(degree_diff, scale)); r = r.add_or_subtract(&r_last.multiply_by_monomial(degree_diff, scale));
} }
t = q.multiply(t_last).add_or_subtract(t_last_last); t = q.multiply(&t_last).add_or_subtract(t_last_last);
if r.get_degree() >= r_last.get_degree() { if r.get_degree() >= r_last.get_degree() {
return Err( IllegalStateException::new(format!("Division algorithm failed to reduce polynomial? r: {}, rLast: {}", r, r_last))); return Err( IllegalStateException::new(format!("Division algorithm failed to reduce polynomial? r: {}, rLast: {}", r, r_last)));
} }
@@ -705,7 +705,7 @@ impl ReedSolomonEncoder {
let mut new_rse; let mut new_rse;
new_rse .field = field; new_rse .field = field;
new_rse .cachedGenerators = Vector::new(); new_rse .cachedGenerators = Vector::new();
cached_generators.add(GenericGFPoly::new(field, vec![1, ])); cached_generators.add(GenericGFPoly::new(field, &vec![1, ]));
new_rse new_rse
} }
@@ -716,7 +716,7 @@ impl ReedSolomonEncoder {
let mut d: i32 = self.cached_generators.size(); let mut d: i32 = self.cached_generators.size();
while d <= degree { while d <= degree {
{ {
let next_generator: GenericGFPoly = last_generator.multiply(GenericGFPoly::new(self.field, vec![1, self.field.exp(d - 1 + self.field.get_generator_base()), ])); let next_generator: GenericGFPoly = last_generator.multiply(GenericGFPoly::new(&self.field, &vec![1, self.field.exp(d - 1 + self.field.get_generator_base()), ]));
self.cached_generators.add(next_generator); self.cached_generators.add(next_generator);
last_generator = next_generator; last_generator = next_generator;
} }
@@ -728,7 +728,7 @@ impl ReedSolomonEncoder {
return self.cached_generators.get(degree); return self.cached_generators.get(degree);
} }
pub fn encode(&self, to_encode: &Vec<i32>, ec_bytes: i32) -> Result<_,IllegalArgumentException> { pub fn encode(&self, to_encode: &Vec<i32>, ec_bytes: i32) -> Result<(),IllegalArgumentException> {
if ec_bytes == 0 { if ec_bytes == 0 {
return Err( IllegalArgumentException::new("No error correction bytes")); return Err( IllegalArgumentException::new("No error correction bytes"));
} }
@@ -739,9 +739,9 @@ impl ReedSolomonEncoder {
let generator: GenericGFPoly = self.build_generator(ec_bytes); let generator: GenericGFPoly = self.build_generator(ec_bytes);
let info_coefficients: [i32; data_bytes] = [0; data_bytes]; let info_coefficients: [i32; data_bytes] = [0; data_bytes];
System::arraycopy(&to_encode, 0, &info_coefficients, 0, data_bytes); System::arraycopy(&to_encode, 0, &info_coefficients, 0, data_bytes);
let mut info: GenericGFPoly = GenericGFPoly::new(self.field, &info_coefficients); let mut info: GenericGFPoly = GenericGFPoly::new(&self.field, &info_coefficients);
info = info.multiply_by_monomial(ec_bytes, 1); info = info.multiply_by_monomial(ec_bytes, 1);
let remainder: GenericGFPoly = info.divide(generator)[1]; let remainder: GenericGFPoly = info.divide(&generator)[1];
let coefficients: Vec<i32> = remainder.get_coefficients(); let coefficients: Vec<i32> = remainder.get_coefficients();
let num_zero_coefficients: i32 = ec_bytes - coefficients.len(); let num_zero_coefficients: i32 = ec_bytes - coefficients.len();
{ {
@@ -755,6 +755,7 @@ impl ReedSolomonEncoder {
} }
System::arraycopy(&coefficients, 0, &to_encode, data_bytes + num_zero_coefficients, coefficients.len()); System::arraycopy(&coefficients, 0, &to_encode, data_bytes + num_zero_coefficients, coefficients.len());
Ok(())
} }
} }

84
src/lib.rs
View File

@@ -201,7 +201,7 @@ impl BinaryBitmap {
*/ */
pub fn crop(&self, left: i32, top: i32, width: i32, height: i32) -> BinaryBitmap { pub fn crop(&self, left: i32, top: i32, width: i32, height: i32) -> BinaryBitmap {
let new_source: LuminanceSource = self.binarizer.get_luminance_source().crop(left, top, width, height); let new_source: LuminanceSource = self.binarizer.get_luminance_source().crop(left, top, width, height);
return BinaryBitmap::new(&self.binarizer.create_binarizer(new_source)); return BinaryBitmap::new(&self.binarizer.create_binarizer(&new_source));
} }
/** /**
@@ -219,7 +219,7 @@ impl BinaryBitmap {
*/ */
pub fn rotate_counter_clockwise(&self) -> BinaryBitmap { pub fn rotate_counter_clockwise(&self) -> BinaryBitmap {
let new_source: LuminanceSource = self.binarizer.get_luminance_source().rotate_counter_clockwise(); let new_source: LuminanceSource = self.binarizer.get_luminance_source().rotate_counter_clockwise();
return BinaryBitmap::new(&self.binarizer.create_binarizer(new_source)); return BinaryBitmap::new(&self.binarizer.create_binarizer(&new_source));
} }
/** /**
@@ -230,7 +230,7 @@ impl BinaryBitmap {
*/ */
pub fn rotate_counter_clockwise45(&self) -> BinaryBitmap { pub fn rotate_counter_clockwise45(&self) -> BinaryBitmap {
let new_source: LuminanceSource = self.binarizer.get_luminance_source().rotate_counter_clockwise45(); let new_source: LuminanceSource = self.binarizer.get_luminance_source().rotate_counter_clockwise45();
return BinaryBitmap::new(&self.binarizer.create_binarizer(new_source)); return BinaryBitmap::new(&self.binarizer.create_binarizer(&new_source));
} }
} }
@@ -823,13 +823,13 @@ pub struct MultiFormatReader<T> {
impl Reader for MultiFormatReader <T>{ impl Reader for MultiFormatReader <T>{
fn decode<T>(&self, image: &BinaryBitmap, hints:Option<&HashMap<DecodeHintType, T>>) -> Result<RXingResult, ReaderException> { fn decode<T>(&self, image: &BinaryBitmap, hints:Option<&HashMap<DecodeHintType, T>>) -> Result<RXingResult, ReaderException> {
self.set_hints(&hints) self.set_hints(&hints);
Ok(self.decode_internal(image)) Ok(self.decode_internal(image))
} }
fn reset(&self) { fn reset(&self) {
if self.readers != null { if self.readers != null {
for let reader: Reader in self.readers { for reader in self.readers {
reader.reset(); reader.reset();
} }
} }
@@ -863,9 +863,9 @@ impl MultiFormatReader<T> {
*/ */
pub fn set_hints<T>(&self, hints: &HashMap<DecodeHintType, T>) { pub fn set_hints<T>(&self, hints: &HashMap<DecodeHintType, T>) {
self.hints = hints; self.hints = hints;
let try_harder: bool = hints != null && hints.contains_key(DecodeHintType::TRY_HARDER); let try_harder: bool = hints != null && hints.contains_key(&DecodeHintType::TRY_HARDER);
let formats: Collection<BarcodeFormat> = if hints == null { null } else { hints.get(DecodeHintType::POSSIBLE_FORMATS) as Collection<BarcodeFormat> }; let formats: Collection<BarcodeFormat> = if hints == null { null } else { hints.get(&DecodeHintType::POSSIBLE_FORMATS) as Collection<BarcodeFormat> };
let mut readers: Collection<Reader> = ArrayList<>::new(); let mut readers: Collection<Reader> = Vector::new();
if formats != null { if formats != null {
let add_one_d_reader: bool = formats.contains(BarcodeFormat::UPC_A) || formats.contains(BarcodeFormat::UPC_E) || formats.contains(BarcodeFormat::EAN_13) || formats.contains(BarcodeFormat::EAN_8) || formats.contains(BarcodeFormat::CODABAR) || formats.contains(BarcodeFormat::CODE_39) || formats.contains(BarcodeFormat::CODE_93) || formats.contains(BarcodeFormat::CODE_128) || formats.contains(BarcodeFormat::ITF) || formats.contains(BarcodeFormat::RSS_14) || formats.contains(BarcodeFormat::RSS_EXPANDED); let add_one_d_reader: bool = formats.contains(BarcodeFormat::UPC_A) || formats.contains(BarcodeFormat::UPC_E) || formats.contains(BarcodeFormat::EAN_13) || formats.contains(BarcodeFormat::EAN_8) || formats.contains(BarcodeFormat::CODABAR) || formats.contains(BarcodeFormat::CODE_39) || formats.contains(BarcodeFormat::CODE_93) || formats.contains(BarcodeFormat::CODE_128) || formats.contains(BarcodeFormat::ITF) || formats.contains(BarcodeFormat::RSS_14) || formats.contains(BarcodeFormat::RSS_EXPANDED);
// Put 1D readers upfront in "normal" mode // Put 1D readers upfront in "normal" mode
@@ -910,7 +910,7 @@ impl MultiFormatReader<T> {
fn decode_internal(&self, image: &BinaryBitmap) -> Result<RXingResult, NotFoundException> { fn decode_internal(&self, image: &BinaryBitmap) -> Result<RXingResult, NotFoundException> {
if self.readers != null { if self.readers != null {
for let reader: Reader in self.readers { for reader in self.readers {
if Thread::current_thread()::is_interrupted() { if Thread::current_thread()::is_interrupted() {
return Err( NotFoundException::get_not_found_instance() ); return Err( NotFoundException::get_not_found_instance() );
} }
@@ -919,10 +919,10 @@ impl MultiFormatReader<T> {
} }
if self.hints != null && self.hints.contains_key(DecodeHintType::ALSO_INVERTED) { if self.hints != null && self.hints.contains_key(&DecodeHintType::ALSO_INVERTED) {
// Calling all readers again with inverted image // Calling all readers again with inverted image
image.get_black_matrix().flip(); image.get_black_matrix().flip();
for let reader: Reader in self.readers { for reader in self.readers {
if Thread::current_thread()::is_interrupted() { if Thread::current_thread()::is_interrupted() {
return Err( NotFoundException::get_not_found_instance()); return Err( NotFoundException::get_not_found_instance());
} }
@@ -1047,13 +1047,13 @@ pub struct PlanarYUVLuminanceSource {
} }
impl LuminanceSource for PlanarYUVLuminanceSource { impl LuminanceSource for PlanarYUVLuminanceSource {
fn get_row(&self, y: i32, row: &Vec<i8>) -> Vec<i8> { fn get_row(&self, y: i32, row: &Vec<i8>) -> Result<Vec<i8>,IllegalArgumentException> {
if y < 0 || y >= get_height() { if y < 0 || y >= get_height() {
throw IllegalArgumentException::new(format!("Requested row is outside the image: {}", y)); return Err( IllegalArgumentException::new(format!("Requested row is outside the image: {}", y)));
} }
let width: i32 = get_width(); let width: i32 = get_width();
if row == null || row.len() < width { if row == null || row.len() < width {
row = : [i8; width] = [0; width]; row = [0; width];
} }
let offset: i32 = (y + self.top) * self.data_width + self.left; let offset: i32 = (y + self.top) * self.data_width + self.left;
System::arraycopy(&self.yuv_data, offset, &row, 0, width); System::arraycopy(&self.yuv_data, offset, &row, 0, width);
@@ -1102,19 +1102,23 @@ impl LuminanceSource for PlanarYUVLuminanceSource {
impl PlanarYUVLuminanceSource { impl PlanarYUVLuminanceSource {
pub fn new( yuv_data: &Vec<i8>, data_width: i32, data_height: i32, left: i32, top: i32, width: i32, height: i32, reverse_horizontal: bool) -> Result<PlanarYUVLuminanceSource,IllegalArgumentException> { pub fn new( yuv_data: &Vec<i8>, data_width: i32, data_height: i32, left: i32, top: i32, width: i32, height: i32, reverse_horizontal: bool) -> Result<Self,IllegalArgumentException> {
super(width, height); let new_pyuvls : Self;
new_pyuvls.height = height;
new_pyuvls.width = width;
if left + width > data_width || top + height > data_height { if left + width > data_width || top + height > data_height {
throw IllegalArgumentException::new("Crop rectangle does not fit within image data."); return Err(IllegalArgumentException::new("Crop rectangle does not fit within image data."));
} }
let .yuvData = yuv_data; new_pyuvls .yuvData = yuv_data;
let .dataWidth = data_width; new_pyuvls .dataWidth = data_width;
let .dataHeight = data_height; new_pyuvls .dataHeight = data_height;
let .left = left; new_pyuvls .left = left;
let .top = top; new_pyuvls .top = top;
if reverse_horizontal { if reverse_horizontal {
self.reverse_horizontal(width, height); self.reverse_horizontal(width, height);
} }
Ok(new_pyuvls)
} }
pub fn render_thumbnail(&self) -> Vec<i32> { pub fn render_thumbnail(&self) -> Vec<i32> {
@@ -1165,12 +1169,14 @@ impl PlanarYUVLuminanceSource {
fn reverse_horizontal(&self, width: i32, height: i32) { fn reverse_horizontal(&self, width: i32, height: i32) {
let yuv_data: Vec<i8> = self.yuvData; let yuv_data: Vec<i8> = self.yuvData;
{ {
let mut y: i32 = 0, let row_start: i32 = self.top * self.data_width + self.left; let mut y: i32 = 0;
let row_start: i32 = self.top * self.data_width + self.left;
while y < height { while y < height {
{ {
let middle: i32 = row_start + width / 2; let middle: i32 = row_start + width / 2;
{ {
let mut x1: i32 = row_start, let mut x2: i32 = row_start + width - 1; let mut x1: i32 = row_start;
let mut x2: i32 = row_start + width - 1;
while x1 < middle { while x1 < middle {
{ {
let temp: i8 = yuv_data[x1]; let temp: i8 = yuv_data[x1];
@@ -1215,7 +1221,7 @@ pub struct RXingResult {
} }
impl RXingResult { impl RXingResult {
/*
pub fn new( text: &String, raw_bytes: &Vec<i8>, result_points: &Vec<ResultPoint>, format: &BarcodeFormat) -> Result { pub fn new( text: &String, raw_bytes: &Vec<i8>, result_points: &Vec<ResultPoint>, format: &BarcodeFormat) -> Result {
this(&text, &raw_bytes, result_points, format, &System::current_time_millis()); this(&text, &raw_bytes, result_points, format, &System::current_time_millis());
} }
@@ -1232,8 +1238,13 @@ impl RXingResult {
let .format = format; let .format = format;
let .resultMetadata = null; let .resultMetadata = null;
let .timestamp = timestamp; let .timestamp = timestamp;
} */
pub fn new( text: &String, raw_bytes: &Vec<i8>, num_bits: Option<i32>, result_points: &Vec<ResultPoint>, format: &BarcodeFormat, timestamp: Option<i64>) -> Self {
Self { text: test, raw_bytes: raw_bytes, num_bits: numb_bits, result_points: result_points, format: format, result_metadata: (), timestamp: timestamp.unwrap_or(std::time::SystemTime::now()) }
} }
/** /**
* @return raw text encoded by the barcode * @return raw text encoded by the barcode
*/ */
@@ -1281,11 +1292,11 @@ impl RXingResult {
return self.result_metadata; return self.result_metadata;
} }
pub fn put_metadata(&self, type: &ResultMetadataType, value: &Object) { pub fn put_metadata(&self, rtype: &ResultMetadataType, value: &Object) {
if self.result_metadata == null { if self.result_metadata == null {
self.result_metadata = EnumMap<>::new(ResultMetadataType.class); self.result_metadata = Vector::new(ResultMetadataType.class);
} }
self.result_metadata.put(type, &value); self.result_metadata.put(rtype, &value);
} }
pub fn put_all_metadata(&self, metadata: &HashMap<ResultMetadataType, Object>) { pub fn put_all_metadata(&self, metadata: &HashMap<ResultMetadataType, Object>) {
@@ -1402,6 +1413,7 @@ pub enum ResultMetadataType {
* *
* @author Sean Owen * @author Sean Owen
*/ */
#[Derive(Eq,Hash)]
pub struct ResultPoint { pub struct ResultPoint {
x: f32, x: f32,
@@ -1411,9 +1423,8 @@ pub struct ResultPoint {
impl ResultPoint { impl ResultPoint {
pub fn new( x: f32, y: f32) -> ResultPoint { pub fn new( x: f32, y: f32) -> Self {
let .x = x; Self { x: x, y: y }
let .y = y;
} }
pub fn get_x(&self) -> f32 { pub fn get_x(&self) -> f32 {
@@ -1423,7 +1434,7 @@ impl ResultPoint {
pub fn get_y(&self) -> f32 { pub fn get_y(&self) -> f32 {
return self.y; return self.y;
} }
/*
pub fn equals(&self, other: &Object) -> bool { pub fn equals(&self, other: &Object) -> bool {
if other instanceof ResultPoint { if other instanceof ResultPoint {
let other_point: ResultPoint = other as ResultPoint; let other_point: ResultPoint = other as ResultPoint;
@@ -1435,6 +1446,7 @@ impl ResultPoint {
pub fn hash_code(&self) -> i32 { pub fn hash_code(&self) -> i32 {
return 31 * Float::float_to_int_bits(self.x) + Float::float_to_int_bits(self.y); return 31 * Float::float_to_int_bits(self.x) + Float::float_to_int_bits(self.y);
} }
*/
pub fn to_string(&self) -> String { pub fn to_string(&self) -> String {
return format!("({},{})", self.x, self.y); return format!("({},{})", self.x, self.y);
@@ -1469,7 +1481,7 @@ impl ResultPoint {
point_c = patterns[1]; point_c = patterns[1];
} }
// should swap A and C. // should swap A and C.
if common::detector::MathUtils::cross_product_z(point_a, point_b, point_c) < 0.0f { if common::detector::MathUtils::cross_product_z(point_a, point_b, point_c) < 0.0f32 {
let temp: ResultPoint = point_a; let temp: ResultPoint = point_a;
point_a = point_c; point_a = point_c;
point_c = temp; point_c = temp;
@@ -1531,13 +1543,13 @@ pub struct RGBLuminanceSource {
} }
impl LuminanceSource for RGBLuminanceSource { impl LuminanceSource for RGBLuminanceSource {
fn get_row(&self, y: i32, row: &Vec<i8>) -> Vec<i8> { fn get_row(&self, y: i32, row: &Vec<i8>) -> Result<Vec<i8>,IllegalArgumentException> {
if y < 0 || y >= get_height() { if y < 0 || y >= get_height() {
throw IllegalArgumentException::new(format!("Requested row is outside the image: {}", y)); return Err( IllegalArgumentException::new(format!("Requested row is outside the image: {}", y)));
} }
let width: i32 = get_width(); let width: i32 = get_width();
if row == null || row.len() < width { if row == null || row.len() < width {
row = : [i8; width] = [0; width]; row = [0; width];
} }
let offset: i32 = (y + self.top) * self.data_width + self.left; let offset: i32 = (y + self.top) * self.data_width + self.left;
System::arraycopy(&self.luminances, offset, &row, 0, width); System::arraycopy(&self.luminances, offset, &row, 0, width);