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

Cleanup of many components of the code.

Browse Source 
Many unwraps, expects, and panics removed or handled.

More rustification of the codebase.

Squashed commit of the following:

commit 80c6483cf8c819496a7b781f9e3a149d1f18d5fe
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 20:36:57 2023 -0600

    add other parsed result option

commit 412d92ae585e7bf194697f5282dbc045e448bace
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 19:06:34 2023 -0600

    fix some panics

commit 9108d3e931aadec00fc0bf346ebc52d24e5d8146
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 18:56:30 2023 -0600

    clippy --fix

commit 8cd89d314323f54f342f15fc73297b62d418ac79
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 18:55:45 2023 -0600

    some more cleanup in aztec

commit fb7f9242e273b85a4bb212f22a185a0dcbfafc36
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 18:19:54 2023 -0600

    cleanup root

commit 4fb7c0639830869149332b29be789e891eade3e7
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 16:50:15 2023 -0600

    format

commit 3ac271af657b25fbe5ee39cbdf8859e5aa38ea41
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 16:43:14 2023 -0600

    clippy --fix

commit 0c5b4c1477159db93a9da9645039f51cd1a7c574
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 16:04:31 2023 -0600

    qrcode cleanup complete

commit 70c1d107cc672e45d46567c650c46fece7e7da9c
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 13:28:25 2023 -0600

    clippy --fix

commit e13263d0f1f2a13dbb59b6e60d8b871a32babc92
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 13:27:44 2023 -0600

    qrcode detector cleanup

commit f7f2855099e469fe1091868c6099196705d0ae83
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 11:48:13 2023 -0600

    qrcode decoder

commit bdbaaba597b3479639c2ed3726465a69e3004471
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 11:13:18 2023 -0600

    clippy --fix

commit fd6dbcaeb1f45dc91ae98f0e7c58aad48d67df78
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 11:12:28 2023 -0600

    pdf417 cleanup complete

commit 7bbd47604c2639a5eb61bdb5533e71be3bce95a1
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 10:39:28 2023 -0600

    clippy --fix

commit 8f4962b7bb5f133524fe4d3d4948e5672a88c545
Author: Henry Schimke <henry@azule.info>
Date:   Fri Feb 10 10:39:00 2023 -0600

    cleanup on pdf417 hie

commit 254c8243953776d3c8704dd81529aadd05d5a94e
Author: Henry <henry@azule.info>
Date:   Fri Feb 10 02:51:21 2023 +0000

    partway through pdf417 hle

commit d4a5b00fde8c0282b0c6e4175a21c1e111b11533
Author: Henry <henry@azule.info>
Date:   Wed Feb 8 21:35:25 2023 +0000

    clippy --fix

commit 2bd4a8e218aa963a88997b50bc5a198f9a88205e
Author: Henry <henry@azule.info>
Date:   Wed Feb 8 21:31:55 2023 +0000

    pdf417 decode and detect cleanup

commit 05130ac54a72c2303045d64507bf6185aa74e531
Author: Henry Schimke <henry@azule.info>
Date:   Tue Feb 7 08:06:25 2023 -0600

    at decodeTextCompaction in decoded_bit_straem_parser

commit 924c023a7d2339dfffa6ef0c4a805fb192576796
Author: Henry Schimke <henry@azule.info>
Date:   Mon Feb 6 18:22:02 2023 -0600

    clippy --fix

commit 5cfb81a885c22b4b5ec937a79be31d0815def211
Author: Henry Schimke <henry@azule.info>
Date:   Mon Feb 6 18:20:22 2023 -0600

    oned cleanup

commit 0649b64854baf56a8e3314728d4f6cf4063db8b2
Author: Henry Schimke <henry@azule.info>
Date:   Mon Feb 6 11:47:28 2023 -0600

    rss cleanup

commit 2d3127898fc11f7e65d590e983cda799b798b646
Author: Henry Schimke <henry@azule.info>
Date:   Mon Feb 6 10:19:56 2023 -0600

    multi cleanup

commit 7e8b43a159083a2096123e6204d4d1d359c59981
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 21:41:59 2023 -0600

    cargo fmt

commit df8285e8da07b4bffd48ca6e596de3f010eb8d9e
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 21:41:29 2023 -0600

    maxicode cleanup

commit a51f923a14016eb416ca202b2194258808dde3e7
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 21:27:57 2023 -0600

    cargo fmt

commit 332d7eef4a25318611025a3fcb0b70c604d917be
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 21:27:48 2023 -0600

    cleanup datamatrix

commit eb2311c476a9c9993f271ab6cf9fd359aedca26f
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 21:27:26 2023 -0600

    cargo clippy --fix

commit 2abaa4c51d287f619d4c7a438f85ba2a30f159cf
Author: Henry <henry@azule.info>
Date:   Sun Feb 5 19:13:02 2023 -0600

    finish cleanup in parsers

commit 716aa2fbf728716cff36657a5fd80e7bca5276b7
Author: Henry Schimke <henry@azule.info>
Date:   Sun Feb 5 17:44:56 2023 -0600

    cleanup continues

commit 7d843788a49fa9cc82c4616d226c0f882e73612b
Author: Henry Schimke <henry@azule.info>
Date:   Sun Feb 5 15:15:09 2023 -0600

    common cleanup

commit fd251866c68f22d450dd428c93d7a3620bf1be27
Author: Henry Schimke <henry@azule.info>
Date:   Sun Feb 5 10:24:54 2023 -0600

    cleanup reedsolomon

commit 132e27ed1468f5c1ce998516ff5a00687217c3e6
Author: Henry Schimke <henry@azule.info>
Date:   Sun Feb 5 09:52:04 2023 -0600

    make MathUtils more generic

commit d8352b7fff4cb4f9ecc8e8a969710d26ef410e8b
Author: Henry Schimke <henry@azule.info>
Date:   Sun Feb 5 09:29:33 2023 -0600

    cleanup some string handling in ResultParser

    There may still be some edge cases where multi-byte characters break the parser
This commit is contained in:
Henry
2023-02-10 20:41:25 -06:00
parent 5222bb25b7
commit 28723be2eb
180 changed files with 3248 additions and 4117 deletions
Download Patch File Download Diff File Expand all files Collapse all files

19
src/pdf417/decoder/barcode_value.rs
View File

@@ -21,7 +21,6 @@ use std::collections::HashMap;
*/
#[derive(Clone, Default)]
pub struct BarcodeValue(HashMap<u32, u32>);
// private final Map<Integer,Integer> values = new HashMap<>();
impl BarcodeValue {
pub fn new() -> Self {
@@ -32,13 +31,10 @@ impl BarcodeValue {
* Add an occurrence of a value
*/
pub fn setValue(&mut self, value: u32) {
let mut confidence = if let Some(value) = self.0.get(&value) {
*value
} else {
0
};
confidence += 1;
self.0.insert(value, confidence);
self.0
.entry(value)
.and_modify(|confidence| *confidence += 1)
.or_insert(1);
}
/**
@@ -49,7 +45,6 @@ impl BarcodeValue {
let mut maxConfidence = -1_i32;
let mut result = Vec::new();
for (key, value) in &self.0 {
// for (Entry<Integer,Integer> entry : values.entrySet()) {
match (*value as i32).cmp(&maxConfidence) {
std::cmp::Ordering::Greater => {
maxConfidence = *value as i32;
@@ -65,10 +60,6 @@ impl BarcodeValue {
}
pub fn getConfidence(&self, value: u32) -> u32 {
if let Some(v) = self.0.get(&value) {
*v
} else {
0
}
*self.0.get(&value).unwrap_or(&0)
}
}

30
src/pdf417/decoder/bounding_box.rs
View File

@@ -53,21 +53,21 @@ impl BoundingBox {
let newBottomRight;
if leftUnspecified {
newTopRight = topRight.unwrap();
newBottomRight = bottomRight.unwrap();
newTopRight = topRight.ok_or(Exceptions::IllegalStateException(None))?;
newBottomRight = bottomRight.ok_or(Exceptions::IllegalStateException(None))?;
newTopLeft = RXingResultPoint::new(0.0, newTopRight.getY());
newBottomLeft = RXingResultPoint::new(0.0, newBottomRight.getY());
} else if rightUnspecified {
newTopLeft = topLeft.unwrap();
newBottomLeft = bottomLeft.unwrap();
newTopLeft = topLeft.ok_or(Exceptions::IllegalStateException(None))?;
newBottomLeft = bottomLeft.ok_or(Exceptions::IllegalStateException(None))?;
newTopRight = RXingResultPoint::new(image.getWidth() as f32 - 1.0, newTopLeft.getY());
newBottomRight =
RXingResultPoint::new(image.getWidth() as f32 - 1.0, newBottomLeft.getY());
} else {
newTopLeft = topLeft.unwrap();
newTopRight = topRight.unwrap();
newBottomLeft = bottomLeft.unwrap();
newBottomRight = bottomRight.unwrap();
newTopLeft = topLeft.ok_or(Exceptions::IllegalStateException(None))?;
newTopRight = topRight.ok_or(Exceptions::IllegalStateException(None))?;
newBottomLeft = bottomLeft.ok_or(Exceptions::IllegalStateException(None))?;
newBottomRight = bottomRight.ok_or(Exceptions::IllegalStateException(None))?;
}
Ok(BoundingBox {
@@ -102,13 +102,19 @@ impl BoundingBox {
rightBox: Option<BoundingBox>,
) -> Result<BoundingBox, Exceptions> {
if leftBox.is_none() {
return Ok(rightBox.as_ref().unwrap().clone());
return Ok(rightBox
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?
.clone());
}
if rightBox.is_none() {
return Ok(leftBox.as_ref().unwrap().clone());
return Ok(leftBox
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?
.clone());
}
let leftBox = leftBox.unwrap();
let rightBox = rightBox.unwrap();
let leftBox = leftBox.ok_or(Exceptions::IllegalStateException(None))?;
let rightBox = rightBox.ok_or(Exceptions::IllegalStateException(None))?;
BoundingBox::new(
leftBox.image,

397
src/pdf417/decoder/decoded_bit_stream_parser.rs
View File

@@ -62,6 +62,8 @@ const MACRO_PDF417_OPTIONAL_FIELD_ADDRESSEE: u32 = 4;
const MACRO_PDF417_OPTIONAL_FIELD_FILE_SIZE: u32 = 5;
const MACRO_PDF417_OPTIONAL_FIELD_CHECKSUM: u32 = 6;
const PRE_TEXT_COMPACTION_MODE_LATCH: u32 = TEXT_COMPACTION_MODE_LATCH - 1;
const PL: u32 = 25;
const LL: u32 = 27;
const AS: u32 = 27;
@@ -89,12 +91,11 @@ use once_cell::sync::Lazy;
static EXP900: Lazy<Vec<BigUint>> = Lazy::new(|| {
const EXP_LEN: usize = 16;
let mut exp900 = Vec::with_capacity(EXP_LEN); //[0;16];
exp900.push(ToBigUint::to_biguint(&1).unwrap());
let nineHundred = ToBigUint::to_biguint(&900).unwrap();
exp900.push(ToBigUint::to_biguint(&1).unwrap_or_default());
let nineHundred = ToBigUint::to_biguint(&900).unwrap_or_default();
exp900.push(nineHundred);
let mut i = 2;
while i < EXP_LEN {
// for (int i = 2; i < EXP900.length; i++) {
exp900.push(&exp900[i - 1] * 900_u32);
i += 1;
@@ -103,28 +104,6 @@ static EXP900: Lazy<Vec<BigUint>> = Lazy::new(|| {
exp900
});
// /**
// * Table containing values for the exponent of 900.
// * This is used in the numeric compaction decode algorithm.
// */
// const EXP900 : [u128;16] =
// {
// let mut exp900 = [0;16];
// exp900[0] = 1;
// let nineHundred = 900;
// exp900[1] = nineHundred;
// let mut i = 2;
// while i < exp900.len() {
// // for (int i = 2; i < EXP900.length; i++) {
// exp900[i] = exp900[i - 1] * (nineHundred);
// i+=1;
// }
// exp900
// };
const NUMBER_OF_SEQUENCE_CODEWORDS: usize = 2;
pub fn decode(codewords: &[u32], ecLevel: &str) -> Result<DecoderRXingResult, Exceptions> {
@@ -142,7 +121,9 @@ pub fn decode(codewords: &[u32], ecLevel: &str) -> Result<DecoderRXingResult, Ex
codeIndex = byteCompaction(code, codewords, codeIndex, &mut result)?
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(codewords[codeIndex]).unwrap());
result.append_char(
char::from_u32(codewords[codeIndex]).ok_or(Exceptions::ParseException(None))?,
);
codeIndex += 1;
}
NUMERIC_COMPACTION_MODE_LATCH => {
@@ -212,7 +193,6 @@ pub fn decodeMacroBlock(
.iter_mut()
.take(NUMBER_OF_SEQUENCE_CODEWORDS)
{
// for (int i = 0; i < NUMBER_OF_SEQUENCE_CODEWORDS; i++, codeIndex++) {
*seq = codewords[codeIndex];
codeIndex += 1;
}
@@ -304,7 +284,7 @@ pub fn decodeMacroBlock(
let mut fileSize = ECIStringBuilder::new();
codeIndex = numericCompaction(codewords, codeIndex + 1, &mut fileSize)?;
fileSize = fileSize.build_result();
let Ok(parsed_file_size)= fileSize.to_string().parse()else {
let Ok(parsed_file_size)= fileSize.to_string().parse() else {
return Err(Exceptions::FormatException(None));
};
resultMetadata.setFileSize(parsed_file_size);
@@ -327,8 +307,7 @@ pub fn decodeMacroBlock(
// do not include terminator
optionalFieldsLength -= 1;
}
// resultMetadata.setOptionalData(
// Arrays.copyOfRange(codewords, optionalFieldsStart, optionalFieldsStart + optionalFieldsLength));
resultMetadata.setOptionalData(
codewords[optionalFieldsStart as usize
..(optionalFieldsStart + optionalFieldsLength as isize) as usize]
@@ -363,58 +342,60 @@ fn textCompaction(
let mut index = 0;
let mut end = false;
let mut subMode = Mode::Alpha;
while (codeIndex < codewords[0] as usize) && !end {
let mut code = codewords[codeIndex];
codeIndex += 1;
if code < TEXT_COMPACTION_MODE_LATCH {
textCompactionData[index] = code / 30;
textCompactionData[index + 1] = code % 30;
index += 2;
} else {
match code {
TEXT_COMPACTION_MODE_LATCH => {
// reinitialize text compaction mode to alpha sub mode
textCompactionData[index] = TEXT_COMPACTION_MODE_LATCH;
index += 1;
}
BYTE_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH_6
| NUMERIC_COMPACTION_MODE_LATCH
| BEGIN_MACRO_PDF417_CONTROL_BLOCK
| BEGIN_MACRO_PDF417_OPTIONAL_FIELD
| MACRO_PDF417_TERMINATOR => {
codeIndex -= 1;
end = true;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
// The Mode Shift codeword 913 shall cause a temporary
// switch from Text Compaction mode to Byte Compaction Mode::
// This switch shall be in effect for only the next codeword,
// after which the mode shall revert to the prevailing sub-mode
// of the Text Compaction Mode:: Codeword 913 is only available
// in Text Compaction mode; its use is described in 5.4.2.4.
textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
code = codewords[codeIndex];
codeIndex += 1;
byteCompactionData[index] = code;
index += 1;
}
ECI_CHARSET => {
subMode = decodeTextCompaction(
&textCompactionData,
&byteCompactionData,
index,
result,
subMode,
);
result.appendECI(codewords[codeIndex])?;
codeIndex += 1;
textCompactionData = vec![0; (codewords[0] as usize - codeIndex) * 2];
byteCompactionData = vec![0; (codewords[0] as usize - codeIndex) * 2];
index = 0;
}
_ => {}
match code {
..=PRE_TEXT_COMPACTION_MODE_LATCH => {
textCompactionData[index] = code / 30;
textCompactionData[index + 1] = code % 30;
index += 2;
}
TEXT_COMPACTION_MODE_LATCH => {
// reinitialize text compaction mode to alpha sub mode
textCompactionData[index] = TEXT_COMPACTION_MODE_LATCH;
index += 1;
}
BYTE_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH_6
| NUMERIC_COMPACTION_MODE_LATCH
| BEGIN_MACRO_PDF417_CONTROL_BLOCK
| BEGIN_MACRO_PDF417_OPTIONAL_FIELD
| MACRO_PDF417_TERMINATOR => {
codeIndex -= 1;
end = true;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
// The Mode Shift codeword 913 shall cause a temporary
// switch from Text Compaction mode to Byte Compaction Mode::
// This switch shall be in effect for only the next codeword,
// after which the mode shall revert to the prevailing sub-mode
// of the Text Compaction Mode:: Codeword 913 is only available
// in Text Compaction mode; its use is described in 5.4.2.4.
textCompactionData[index] = MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
code = codewords[codeIndex];
codeIndex += 1;
byteCompactionData[index] = code;
index += 1;
}
ECI_CHARSET => {
subMode = decodeTextCompaction(
&textCompactionData,
&byteCompactionData,
index,
result,
subMode,
)
.ok_or(Exceptions::IllegalStateException(None))?;
result.appendECI(codewords[codeIndex])?;
codeIndex += 1;
textCompactionData = vec![0; (codewords[0] as usize - codeIndex) * 2];
byteCompactionData = vec![0; (codewords[0] as usize - codeIndex) * 2];
index = 0;
}
_ => {}
}
}
decodeTextCompaction(
@@ -452,7 +433,7 @@ fn decodeTextCompaction(
length: usize,
result: &mut ECIStringBuilder,
startMode: Mode,
) -> Mode {
) -> Option<Mode> {
// Beginning from an initial state
// The default compaction mode for PDF417 in effect at the start of each symbol shall always be Text
// Compaction mode Alpha sub-mode (uppercase alphabetic). A latch codeword from another mode to the Text
@@ -461,6 +442,8 @@ fn decodeTextCompaction(
let mut priorToShiftMode = startMode;
let mut latchedMode = startMode;
let mut i = 0;
const PRE_PL: u32 = PL - 1;
const PRE_PAL: u32 = PAL - 1;
while i < length {
let subModeCh = textCompactionData[i];
let mut ch = 0 as char;
@@ -468,153 +451,137 @@ fn decodeTextCompaction(
Mode::Alpha =>
// Alpha (uppercase alphabetic)
{
if subModeCh < 26 {
match subModeCh {
// Upper case Alpha Character
ch = char::from_u32('A' as u32 + subModeCh).unwrap();
} else {
match subModeCh {
26 => ch = ' ',
LL => {
subMode = Mode::Lower;
latchedMode = subMode;
}
ML => {
subMode = Mode::Mixed;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i]).unwrap())
}
TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
_ => {}
0..=25 => ch = char::from_u32('A' as u32 + subModeCh)?,
26 => ch = ' ',
LL => {
subMode = Mode::Lower;
latchedMode = subMode;
}
ML => {
subMode = Mode::Mixed;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i])?)
}
TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
_ => {}
}
}
Mode::Lower =>
// Lower (lowercase alphabetic)
{
if subModeCh < 26 {
ch = char::from_u32('a' as u32 + subModeCh).unwrap();
} else {
match subModeCh {
26 => ch = ' ',
AS => {
// Shift to alpha
priorToShiftMode = subMode;
subMode = Mode::AlphaShift;
}
ML => {
subMode = Mode::Mixed;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i]).unwrap())
}
TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
_ => {}
match subModeCh {
..=25 => ch = char::from_u32('a' as u32 + subModeCh)?,
26 => ch = ' ',
AS => {
// Shift to alpha
priorToShiftMode = subMode;
subMode = Mode::AlphaShift;
}
ML => {
subMode = Mode::Mixed;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i])?)
}
TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
_ => {}
}
}
Mode::Mixed =>
// Mixed (numeric and some punctuation)
{
if subModeCh < PL {
ch = MIXED_CHARS[subModeCh as usize];
} else {
match subModeCh {
PL => {
subMode = Mode::Punct;
latchedMode = subMode;
}
26 => ch = ' ',
LL => {
subMode = Mode::Lower;
latchedMode = subMode;
}
AL | TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i]).unwrap())
}
_ => {}
match subModeCh {
0..=PRE_PL => ch = MIXED_CHARS[subModeCh as usize],
PL => {
subMode = Mode::Punct;
latchedMode = subMode;
}
26 => ch = ' ',
LL => {
subMode = Mode::Lower;
latchedMode = subMode;
}
AL | TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
PS => {
// Shift to punctuation
priorToShiftMode = subMode;
subMode = Mode::PunctShift;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i])?)
}
_ => {}
}
}
Mode::Punct =>
// Punctuation
{
if subModeCh < PAL {
ch = PUNCT_CHARS[subModeCh as usize];
} else {
match subModeCh {
PAL | TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i]).unwrap())
}
_ => {}
match subModeCh {
..=PRE_PAL => ch = PUNCT_CHARS[subModeCh as usize],
PAL | TEXT_COMPACTION_MODE_LATCH => {
subMode = Mode::Alpha;
latchedMode = subMode;
}
MODE_SHIFT_TO_BYTE_COMPACTION_MODE => {
result.append_char(char::from_u32(byteCompactionData[i])?)
}
_ => {}
}
}
Mode::AlphaShift => {
// Restore sub-mode
subMode = priorToShiftMode;
if subModeCh < 26 {
ch = char::from_u32('A' as u32 + subModeCh).unwrap();
} else {
match subModeCh {
26 => ch = ' ',
TEXT_COMPACTION_MODE_LATCH => subMode = Mode::Alpha,
_ => {}
}
match subModeCh {
..=25 => ch = char::from_u32('A' as u32 + subModeCh)?,
26 => ch = ' ',
TEXT_COMPACTION_MODE_LATCH => subMode = Mode::Alpha,
_ => {}
}
}
Mode::PunctShift => {
// Restore sub-mode
subMode = priorToShiftMode;
if subModeCh < PAL {
ch = PUNCT_CHARS[subModeCh as usize];
} else {
match subModeCh {
PAL | TEXT_COMPACTION_MODE_LATCH => subMode = Mode::Alpha,
MODE_SHIFT_TO_BYTE_COMPACTION_MODE =>
// PS before Shift-to-Byte is used as a padding character,
// see 5.4.2.4 of the specification
{
result.append_char(char::from_u32(byteCompactionData[i]).unwrap())
}
_ => {}
match subModeCh {
..=PRE_PAL => ch = PUNCT_CHARS[subModeCh as usize],
PAL | TEXT_COMPACTION_MODE_LATCH => subMode = Mode::Alpha,
MODE_SHIFT_TO_BYTE_COMPACTION_MODE =>
// PS before Shift-to-Byte is used as a padding character,
// see 5.4.2.4 of the specification
{
result.append_char(char::from_u32(byteCompactionData[i])?)
}
_ => {}
}
}
}
@@ -624,7 +591,7 @@ fn decodeTextCompaction(
}
i += 1;
}
latchedMode
Some(latchedMode)
}
/**
@@ -672,16 +639,13 @@ fn byteCompaction(
{
break;
}
} /*while (count < 5 &&
codeIndex < codewords[0] &&
codewords[codeIndex] < TEXT_COMPACTION_MODE_LATCH);*/
}
if count == 5
&& (mode == BYTE_COMPACTION_MODE_LATCH_6
|| codeIndex < codewords[0] as usize
&& codewords[codeIndex] < TEXT_COMPACTION_MODE_LATCH)
{
for i in 0..6 {
// for (int i = 0; i < 6; i++) {
result.append_byte((value >> (8 * (5 - i))) as u8);
}
} else {
@@ -730,24 +694,24 @@ fn numericCompaction(
if codeIndex == codewords[0] as usize {
end = true;
}
if code < TEXT_COMPACTION_MODE_LATCH {
numericCodewords[count] = code;
count += 1;
} else {
match code {
TEXT_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH_6
| BEGIN_MACRO_PDF417_CONTROL_BLOCK
| BEGIN_MACRO_PDF417_OPTIONAL_FIELD
| MACRO_PDF417_TERMINATOR
| ECI_CHARSET => {
codeIndex -= 1;
end = true;
}
_ => {}
match code {
..=PRE_TEXT_COMPACTION_MODE_LATCH => {
numericCodewords[count] = code;
count += 1;
}
TEXT_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH
| BYTE_COMPACTION_MODE_LATCH_6
| BEGIN_MACRO_PDF417_CONTROL_BLOCK
| BEGIN_MACRO_PDF417_OPTIONAL_FIELD
| MACRO_PDF417_TERMINATOR
| ECI_CHARSET => {
codeIndex -= 1;
end = true;
}
_ => {}
}
if (count % MAX_NUMERIC_CODEWORDS == 0 || code == NUMERIC_COMPACTION_MODE_LATCH || end)
&& count > 0
{
@@ -806,11 +770,14 @@ fn numericCompaction(
Remove leading 1 => RXingResult is 000213298174000
*/
fn decodeBase900toBase10(codewords: &[u32], count: usize) -> Result<String, Exceptions> {
let mut result = 0.to_biguint().unwrap();
let mut result = 0
.to_biguint()
.ok_or(Exceptions::ArithmeticException(None))?;
for i in 0..count {
// for (int i = 0; i < count; i++) {
result += &EXP900[count - i - 1] * (codewords[i].to_biguint().unwrap());
// result = result.add(EXP900[count - i - 1].multiply(BigInteger.valueOf(codewords[i])));
result += &EXP900[count - i - 1]
* (codewords[i]
.to_biguint()
.ok_or(Exceptions::ArithmeticException(None))?);
}
let resultString = result.to_string();
if !resultString.starts_with('1') {

18
src/pdf417/decoder/detection_result.rs
View File

@@ -40,20 +40,16 @@ impl DetectionRXingResult {
barcodeMetadata: BarcodeMetadata,
boundingBox: Rc<BoundingBox>,
) -> DetectionRXingResult {
let mut columns = Vec::new();
let mut columns = Vec::with_capacity(barcodeMetadata.getColumnCount() as usize + 2);
for _i in 0..(barcodeMetadata.getColumnCount() as usize + 2) {
columns.push(None);
}
DetectionRXingResult {
barcodeColumnCount: barcodeMetadata.getColumnCount() as usize,
detectionRXingResultColumns: columns, //vec![None; barcodeMetadata.getColumnCount() as usize + 2],
detectionRXingResultColumns: columns,
barcodeMetadata,
boundingBox,
}
// this.barcodeMetadata = barcodeMetadata;
// this.barcodeColumnCount = barcodeMetadata.getColumnCount();
// this.boundingBox = boundingBox;
// detectionRXingResultColumns = new DetectionRXingResultColumn[barcodeColumnCount + 2];
}
pub fn getDetectionRXingResultColumns(
@@ -70,7 +66,7 @@ impl DetectionRXingResult {
if !(unadjustedCodewordCount > 0 && unadjustedCodewordCount < previousUnadjustedCount) {
break;
}
} //while (unadjustedCodewordCount > 0 && unadjustedCodewordCount < previousUnadjustedCount);
}
&self.detectionRXingResultColumns
}
@@ -79,15 +75,13 @@ impl DetectionRXingResult {
pos: usize,
// detectionRXingResultColumn: &mut Option<DetectionRXingResultColumn>,
) {
if self.detectionRXingResultColumns[pos].is_some() {
if let Some(col) = self.detectionRXingResultColumns[pos].as_mut() {
// if self.detectionRXingResultColumns[pos].is_some() {
// if (detectionRXingResultColumn != null) {
// ((DetectionRXingResultRowIndicatorColumn) detectionRXingResultColumn)
// .adjustCompleteIndicatorColumnRowNumbers(barcodeMetadata);
// }
self.detectionRXingResultColumns[pos]
.as_mut()
.unwrap()
.as_indicator_row()
col.as_indicator_row()
.adjustCompleteIndicatorColumnRowNumbers(&self.barcodeMetadata);
}
}

49
src/pdf417/decoder/detection_result_column.rs
View File

@@ -54,8 +54,6 @@ impl DetectionRXingResultColumnTrait for DetectionRXingResultColumn {
codewords: vec![None; (boundingBox.getMaxY() - boundingBox.getMinY() + 1) as usize],
isLeft: None,
}
// this.boundingBox = new BoundingBox(boundingBox);
// codewords = new Codeword[boundingBox.getMaxY() - boundingBox.getMinY() + 1];
}
fn new_with_is_left(boundingBox: Rc<BoundingBox>, isLeft: bool) -> DetectionRXingResultColumn {
@@ -72,7 +70,6 @@ impl DetectionRXingResultColumnTrait for DetectionRXingResultColumn {
return codeword;
}
for i in 1..MAX_NEARBY_DISTANCE as usize {
// for (int i = 1; i < MAX_NEARBY_DISTANCE; i++) {
let mut nearImageRow = self.imageRowToCodewordIndex(imageRow) as isize - i as isize;
if nearImageRow >= 0 {
codeword = &self.codewords[nearImageRow as usize];
@@ -119,48 +116,26 @@ impl DetectionRXingResultColumnTrait for DetectionRXingResultColumn {
fn as_indicator_row(&mut self) -> &mut dyn DetectionRXingResultRowIndicatorColumn {
self as &mut dyn DetectionRXingResultRowIndicatorColumn
}
// pub fn as_row_indicator(&self) -> DetectionRXingResultRowIndicatorColumn {
// DetectionRXingResultRowIndicatorColumn::new(&self.boundingBox, false)
// }
}
impl Display for DetectionRXingResultColumn {
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
if self.isLeft.is_some() {
writeln!(f, "IsLeft: {} ", self.isLeft.as_ref().unwrap())?;
if let Some(isLeft) = self.isLeft {
writeln!(f, "IsLeft: {isLeft} ")?;
}
let mut row = 0;
for codeword in &self.codewords {
// for (Codeword codeword : codewords) {
if codeword.is_none() {
for (row, codeword) in self.codewords.iter().enumerate() {
if let Some(codeword) = codeword {
writeln!(
f,
"{:3}: {:3}|{:3}",
row,
codeword.getRowNumber(),
codeword.getValue()
)?;
} else {
writeln!(f, "{row:3}: | ")?;
row += 1;
continue;
}
writeln!(
f,
"{:3}: {:3}|{:3}",
row,
codeword.as_ref().unwrap().getRowNumber(),
codeword.as_ref().unwrap().getValue()
)?;
row += 1;
}
write!(f, "")
}
// @Override
// public String toString() {
// try (Formatter formatter = new Formatter()) {
// int row = 0;
// for (Codeword codeword : codewords) {
// if (codeword == null) {
// formatter.format("%3d: | %n", row++);
// continue;
// }
// formatter.format("%3d: %3d|%3d%n", row++, codeword.getRowNumber(), codeword.getValue());
// }
// return formatter.toString();
// }
// }
}

140
src/pdf417/decoder/detection_result_row_indicator_column.rs
View File

@@ -29,24 +29,28 @@ pub trait DetectionRXingResultRowIndicatorColumn: DetectionRXingResultColumnTrai
// TODO maybe we should add missing codewords to store the correct row number to make
// finding row numbers for other columns easier
// use row height count to make detection of invalid row numbers more reliable
fn adjustCompleteIndicatorColumnRowNumbers(&mut self, barcodeMetadata: &BarcodeMetadata);
fn adjustCompleteIndicatorColumnRowNumbers(&mut self, barcodeMetadata: &BarcodeMetadata)
-> u32;
fn getRowHeights(&mut self) -> Option<Vec<u32>>;
fn getBarcodeMetadata(&mut self) -> Option<BarcodeMetadata>;
fn isLeft(&self) -> bool;
}
impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
// private final boolean isLeft;
// TODO implement properly
// TODO maybe we should add missing codewords to store the correct row number to make
// finding row numbers for other columns easier
// use row height count to make detection of invalid row numbers more reliable
fn adjustCompleteIndicatorColumnRowNumbers(&mut self, barcodeMetadata: &BarcodeMetadata) {
// let codewords = self.0.getCodewordsMut();
fn adjustCompleteIndicatorColumnRowNumbers(
&mut self,
barcodeMetadata: &BarcodeMetadata,
) -> u32 {
setRowNumbers(self.getCodewordsMut());
let isLeft = self.isLeft.unwrap();
let isLeft = matches!(self.isLeft, Some(true));
removeIncorrectCodewords(self.getCodewordsMut(), barcodeMetadata, isLeft);
let boundingBox = self.getBoundingBox();
let top = if self.isLeft() {
boundingBox.getTopLeft()
@@ -58,22 +62,18 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
} else {
boundingBox.getBottomRight()
};
let firstRow = self.imageRowToCodewordIndex(top.getY() as u32);
let lastRow = self.imageRowToCodewordIndex(bottom.getY() as u32);
// We need to be careful using the average row height. Barcode could be skewed so that we have smaller and
// taller rows
//float averageRowHeight = (lastRow - firstRow) / (float) barcodeMetadata.getRowCount();
let averageRowHeight: f64 =
(lastRow as f64 - firstRow as f64) / barcodeMetadata.getRowCount() as f64;
let mut barcodeRow = -1;
let mut maxRowHeight = 1;
let mut currentRowHeight = 0;
for codewordsRow in firstRow..lastRow {
// for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
if let Some(codeword) = self.getCodewordsMut()[codewordsRow] {
// if (codewords[codewordsRow] == null) {
// continue;
// }
// let codeword = codewords[codewordsRow];
let rowDifference = codeword.getRowNumber() - barcodeRow;
// TODO improve handling with case where first row indicator doesn't start with 0
@@ -81,7 +81,7 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
if rowDifference == 0 {
currentRowHeight += 1;
} else if rowDifference == 1 {
maxRowHeight = maxRowHeight.max(currentRowHeight);
maxRowHeight = std::cmp::max(maxRowHeight, currentRowHeight);
currentRowHeight = 1;
barcodeRow = codeword.getRowNumber();
} else if rowDifference < 0
@@ -98,7 +98,6 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
let mut closePreviousCodewordFound = checkedRows >= codewordsRow as i32;
let mut i = 1;
while i <= checkedRows && !closePreviousCodewordFound {
// for (int i = 1; i <= checkedRows && !closePreviousCodewordFound; i++) {
// there must be (height * rowDifference) number of codewords missing. For now we assume height = 1.
// This should hopefully get rid of most problems already.
closePreviousCodewordFound =
@@ -117,27 +116,26 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
continue;
}
}
//return (int) (averageRowHeight + 0.5);
(averageRowHeight + 0.5) as u32
}
fn getRowHeights(&mut self) -> Option<Vec<u32>> {
if let Some(barcodeMetadata) = self.getBarcodeMetadata() {
adjustIncompleteIndicatorColumnRowNumbers(self, &barcodeMetadata);
let mut result = vec![0; barcodeMetadata.getRowCount() as usize];
for codeword_opt in self.getCodewords() {
// for (Codeword codeword : getCodewords()) {
if let Some(codeword) = codeword_opt {
let rowNumber = codeword.getRowNumber();
if rowNumber as usize >= result.len() {
// We have more rows than the barcode metadata allows for, ignore them.
continue;
}
result[rowNumber as usize] += 1;
}
// else throw exception?
else {
for codeword in self.getCodewords().iter().flatten() {
// if let Some(codeword) = codeword_opt {
let rowNumber = codeword.getRowNumber() as usize;
if rowNumber >= result.len() {
// We have more rows than the barcode metadata allows for, ignore them.
continue;
}
result[rowNumber] += 1;
// }
// else throw exception?
// else {
// continue;
// }
}
Some(result)
} else {
@@ -146,33 +144,33 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
}
fn getBarcodeMetadata(&mut self) -> Option<BarcodeMetadata> {
let isLeft = self.isLeft.unwrap();
let isLeft = matches!(self.isLeft, Some(true));
let codewords = self.getCodewordsMut();
let mut barcodeColumnCount = BarcodeValue::new();
let mut barcodeRowCountUpperPart = BarcodeValue::new();
let mut barcodeRowCountLowerPart = BarcodeValue::new();
let mut barcodeECLevel = BarcodeValue::new();
for codeword_opt in codewords.iter_mut() {
for codeword in codewords.iter_mut().flatten() {
// for (Codeword codeword : codewords) {
if let Some(codeword) = codeword_opt {
codeword.setRowNumberAsRowIndicatorColumn();
let rowIndicatorValue = codeword.getValue() % 30;
let mut codewordRowNumber = codeword.getRowNumber();
if !isLeft {
codewordRowNumber += 2;
}
match codewordRowNumber % 3 {
0 => barcodeRowCountUpperPart.setValue(rowIndicatorValue * 3 + 1),
1 => {
barcodeECLevel.setValue(rowIndicatorValue / 3);
barcodeRowCountLowerPart.setValue(rowIndicatorValue % 3);
}
2 => barcodeColumnCount.setValue(rowIndicatorValue + 1),
_ => {}
}
} else {
continue;
// if let Some(codeword) = codeword_opt {
codeword.setRowNumberAsRowIndicatorColumn();
let rowIndicatorValue = codeword.getValue() % 30;
let mut codewordRowNumber = codeword.getRowNumber();
if !isLeft {
codewordRowNumber += 2;
}
match codewordRowNumber % 3 {
0 => barcodeRowCountUpperPart.setValue(rowIndicatorValue * 3 + 1),
1 => {
barcodeECLevel.setValue(rowIndicatorValue / 3);
barcodeRowCountLowerPart.setValue(rowIndicatorValue % 3);
}
2 => barcodeColumnCount.setValue(rowIndicatorValue + 1),
_ => {}
}
// } else {
// continue;
// }
}
// Maybe we should check if we have ambiguous values?
if barcodeColumnCount.getValue().is_empty()
@@ -199,24 +197,13 @@ impl DetectionRXingResultRowIndicatorColumn for DetectionRXingResultColumn {
}
fn isLeft(&self) -> bool {
self.isLeft.unwrap()
matches!(self.isLeft, Some(true))
}
}
// impl Display for DetectionRXingResultRowIndicatorColumn {
// fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
// write!(f, "IsLeft: {} \n {}", self.1, self.0)
// }
// }
fn setRowNumbers(code_words: &mut [Option<Codeword>]) {
for codeword in code_words.iter_mut().flatten() {
//self.0.getCodewordsMut() {
// for (Codeword codeword : getCodewords()) {
// if let Some(codeword) = codeword_opt {
// if (codeword != null) {
codeword.setRowNumberAsRowIndicatorColumn();
// }
}
}
@@ -228,8 +215,6 @@ fn removeIncorrectCodewords(
// Remove codewords which do not match the metadata
// TODO Maybe we should keep the incorrect codewords for the start and end positions?
for codeword_row in codewords.iter_mut() {
// for codewordRow in 0..codewords.len() {
// for (int codewordRow = 0; codewordRow < codewords.length; codewordRow++) {
if let Some(codeword) = codeword_row {
let rowIndicatorValue = codeword.getValue() % 30;
let mut codewordRowNumber = codeword.getRowNumber();
@@ -241,22 +226,16 @@ fn removeIncorrectCodewords(
codewordRowNumber += 2;
}
match codewordRowNumber % 3 {
0 => {
if rowIndicatorValue * 3 + 1 != barcodeMetadata.getRowCountUpperPart() {
*codeword_row = None;
}
0 if rowIndicatorValue * 3 + 1 != barcodeMetadata.getRowCountUpperPart() => {
*codeword_row = None;
}
1 => {
if rowIndicatorValue / 3 != barcodeMetadata.getErrorCorrectionLevel()
|| rowIndicatorValue % 3 != barcodeMetadata.getRowCountLowerPart()
{
*codeword_row = None;
}
1 if rowIndicatorValue / 3 != barcodeMetadata.getErrorCorrectionLevel()
|| rowIndicatorValue % 3 != barcodeMetadata.getRowCountLowerPart() =>
{
*codeword_row = None;
}
2 => {
if rowIndicatorValue + 1 != barcodeMetadata.getColumnCount() {
*codeword_row = None;
}
2 if rowIndicatorValue + 1 != barcodeMetadata.getColumnCount() => {
*codeword_row = None;
}
_ => {}
}
@@ -272,7 +251,7 @@ fn removeIncorrectCodewords(
fn adjustIncompleteIndicatorColumnRowNumbers(
col: &mut DetectionRXingResultColumn,
barcodeMetadata: &BarcodeMetadata,
) {
) -> i32 {
let boundingBox = col.getBoundingBox();
let top = if col.isLeft() {
boundingBox.getTopLeft()
@@ -286,11 +265,14 @@ fn adjustIncompleteIndicatorColumnRowNumbers(
};
let firstRow = col.imageRowToCodewordIndex(top.getY() as u32);
let lastRow = col.imageRowToCodewordIndex(bottom.getY() as u32);
//float averageRowHeight = (lastRow - firstRow) / (float) barcodeMetadata.getRowCount();
let averageRowHeight: f64 =
(lastRow as f64 - firstRow as f64) / barcodeMetadata.getRowCount() as f64;
let codewords = col.getCodewordsMut();
let mut barcodeRow = -1;
let mut maxRowHeight = 1;
let mut currentRowHeight = 0;
// todo: It might be clearer what we're doing if we rewrote this a different way?
// Perhaps codewords.iter_mut().skip(firstRow).take(lastRow-firstRow)?
for codword_opt in codewords.iter_mut().take(lastRow).skip(firstRow) {
// for (int codewordsRow = firstRow; codewordsRow < lastRow; codewordsRow++) {
@@ -317,5 +299,5 @@ fn adjustIncompleteIndicatorColumnRowNumbers(
continue;
}
}
//return (int) (averageRowHeight + 0.5);
(averageRowHeight + 0.5) as i32
}

7
src/pdf417/decoder/ec/abstract_error_correction_test_case.rs
View File

@@ -32,14 +32,13 @@ pub fn corrupt(received: &mut [u32], howMany: u32, random: &mut rand::rngs::Thre
#[allow(dead_code)]
pub fn erase(received: &mut [u32], howMany: u32, random: &mut rand::rngs::ThreadRng) -> Vec<u32> {
let mut erased = vec![false; received.len()]; //BitSet::new(received.len());
let mut erased = vec![false; received.len()];
let mut erasures = vec![0_u32; howMany as usize];
let mut erasureOffset = 0;
let mut j = 0;
while j < howMany {
// for (int j = 0; j < howMany; j++) {
let location = random.gen_range(0..received.len()); //random.nextInt(received.len());
if *erased.get(location).unwrap() {
let location = random.gen_range(0..received.len());
if *erased.get(location).unwrap_or(&false) {
j -= 1;
} else {
erased[location] = true;

8
src/pdf417/decoder/ec/modulus_poly.rs
View File

@@ -155,9 +155,7 @@ impl ModulusPoly {
.add(smallerCoefficients[i - lengthDiff], largerCoefficients[i]);
}
Ok(Rc::new(
ModulusPoly::new(self.field, sumDiff).expect("should always generate with known goods"),
))
Ok(Rc::new(ModulusPoly::new(self.field, sumDiff)?))
}
pub fn subtract(&self, other: Rc<ModulusPoly>) -> Result<Rc<ModulusPoly>, Exceptions> {
@@ -198,9 +196,7 @@ impl ModulusPoly {
}
}
Ok(Rc::new(
ModulusPoly::new(self.field, product).expect("should always generate with known goods"),
))
Ok(Rc::new(ModulusPoly::new(self.field, product)?))
}
pub fn negative(&self) -> Rc<ModulusPoly> {

220
src/pdf417/decoder/pdf_417_scanning_decoder.rs
View File

@@ -64,7 +64,6 @@ pub fn decode(
let mut rightRowIndicatorColumn = None;
let mut detectionRXingResult = None;
for firstPass in [true, false] {
// for (boolean firstPass = true; ; firstPass = false) {
if imageTopLeft.is_some() {
leftRowIndicatorColumn = Some(getRowIndicatorColumn(
image,
@@ -142,7 +141,8 @@ pub fn decode(
for imageRow in boundingBox.getMinY()..=boundingBox.getMaxY() {
// for (int imageRow = boundingBox.getMinY(); imageRow <= boundingBox.getMaxY(); imageRow++) {
startColumn =
getStartColumn(&detectionRXingResult, barcodeColumn, imageRow, leftToRight) as i32;
getStartColumn(&detectionRXingResult, barcodeColumn, imageRow, leftToRight)
.ok_or(Exceptions::IllegalStateException(None))? as i32;
if startColumn < 0 || startColumn > boundingBox.getMaxX() as i32 {
if previousStartColumn == -1 {
continue;
@@ -264,68 +264,95 @@ fn getBarcodeMetadata<T: DetectionRXingResultRowIndicatorColumn>(
leftRowIndicatorColumn: &mut Option<T>,
rightRowIndicatorColumn: &mut Option<T>,
) -> Option<BarcodeMetadata> {
let leftBarcodeMetadata = if leftRowIndicatorColumn.is_none()
|| leftRowIndicatorColumn
.as_mut()
.unwrap()
.getBarcodeMetadata()
.is_none()
{
return if rightRowIndicatorColumn.is_none() {
None
} else {
rightRowIndicatorColumn
.as_mut()
.unwrap()
.getBarcodeMetadata()
};
} else {
leftRowIndicatorColumn
.as_mut()
.unwrap()
.getBarcodeMetadata()
};
// if leftRowIndicatorColumn.is_none() ||
// (leftBarcodeMetadata = leftRowIndicatorColumn.getBarcodeMetadata()).is_none() {
// return if rightRowIndicatorColumn.is_none() {None} else {rightRowIndicatorColumn.getBarcodeMetadata()};
// }
let rightBarcodeMetadata = if rightRowIndicatorColumn.is_none() {
return leftBarcodeMetadata;
} else if let Some(mdt) = rightRowIndicatorColumn
let left_ri_md = leftRowIndicatorColumn
.as_mut()
.unwrap()
.getBarcodeMetadata()
{
mdt
// rightRowIndicatorColumn
// .as_mut()
// .unwrap()
// .getBarcodeMetadata()
// .unwrap()
} else {
return leftBarcodeMetadata;
};
// if rightRowIndicatorColumn.is_none() ||
// (rightBarcodeMetadata = rightRowIndicatorColumn.getBarcodeMetadata()).is_none() {
// return leftBarcodeMetadata;
// }
.map_or_else(|| None, |col| col.getBarcodeMetadata());
let right_ri_md = rightRowIndicatorColumn
.as_mut()
.map_or_else(|| None, |col| col.getBarcodeMetadata());
leftBarcodeMetadata?;
if leftBarcodeMetadata.as_ref().unwrap().getColumnCount()
!= rightBarcodeMetadata.getColumnCount()
&& leftBarcodeMetadata
.as_ref()
.unwrap()
.getErrorCorrectionLevel()
!= rightBarcodeMetadata.getErrorCorrectionLevel()
&& leftBarcodeMetadata.as_ref().unwrap().getRowCount() != rightBarcodeMetadata.getRowCount()
{
if leftRowIndicatorColumn.is_none() && rightRowIndicatorColumn.is_none() {
return None;
} else if leftRowIndicatorColumn.is_none() {
return right_ri_md;
} else if rightRowIndicatorColumn.is_none() && right_ri_md.is_none() {
return left_ri_md;
} else if let Some((leftBarcodeMetadata, rightBarcodeMetadata)) =
left_ri_md.as_ref().zip(right_ri_md.as_ref())
{
if leftBarcodeMetadata.getColumnCount() != rightBarcodeMetadata.getColumnCount()
&& leftBarcodeMetadata.getErrorCorrectionLevel()
!= rightBarcodeMetadata.getErrorCorrectionLevel()
&& leftBarcodeMetadata.getRowCount() != rightBarcodeMetadata.getRowCount()
{
return None;
}
}
leftBarcodeMetadata
left_ri_md
// let leftBarcodeMetadata = if leftRowIndicatorColumn.is_none()
// || leftRowIndicatorColumn
// .as_mut()
// .unwrap()
// .getBarcodeMetadata()
// .is_none()
// {
// return if rightRowIndicatorColumn.is_none() {
// None
// } else {
// rightRowIndicatorColumn
// .as_mut()
// .unwrap()
// .getBarcodeMetadata()
// };
// } else {
// leftRowIndicatorColumn
// .as_mut()
// .unwrap()
// .getBarcodeMetadata()
// };
// // if leftRowIndicatorColumn.is_none() ||
// // (leftBarcodeMetadata = leftRowIndicatorColumn.getBarcodeMetadata()).is_none() {
// // return if rightRowIndicatorColumn.is_none() {None} else {rightRowIndicatorColumn.getBarcodeMetadata()};
// // }
// let rightBarcodeMetadata = if rightRowIndicatorColumn.is_none() {
// return leftBarcodeMetadata;
// } else if let Some(mdt) = rightRowIndicatorColumn
// .as_mut()
// .unwrap()
// .getBarcodeMetadata()
// {
// mdt
// // rightRowIndicatorColumn
// // .as_mut()
// // .unwrap()
// // .getBarcodeMetadata()
// // .unwrap()
// } else {
// return leftBarcodeMetadata;
// };
// // if rightRowIndicatorColumn.is_none() ||
// // (rightBarcodeMetadata = rightRowIndicatorColumn.getBarcodeMetadata()).is_none() {
// // return leftBarcodeMetadata;
// // }
// leftBarcodeMetadata?;
// if leftBarcodeMetadata.as_ref().unwrap().getColumnCount()
// != rightBarcodeMetadata.getColumnCount()
// && leftBarcodeMetadata
// .as_ref()
// .unwrap()
// .getErrorCorrectionLevel()
// != rightBarcodeMetadata.getErrorCorrectionLevel()
// && leftBarcodeMetadata.as_ref().unwrap().getRowCount() != rightBarcodeMetadata.getRowCount()
// {
// return None;
// }
// leftBarcodeMetadata
}
fn getRowIndicatorColumn<'a>(
@@ -402,18 +429,16 @@ fn createDecoderRXingResult(
) -> Result<DecoderRXingResult, Exceptions> {
let mut barcodeMatrix = createBarcodeMatrix(detectionRXingResult);
adjustCodewordCount(detectionRXingResult, &mut barcodeMatrix)?;
let mut erasures = Vec::new(); //new ArrayList<>();
let mut erasures = Vec::new();
let mut codewords = vec![
0;
detectionRXingResult.getBarcodeRowCount() as usize
* detectionRXingResult.getBarcodeColumnCount()
];
let mut ambiguousIndexValuesList: Vec<Vec<u32>> = Vec::new();
let mut ambiguousIndexesList = Vec::new(); //new ArrayList<>();
let mut ambiguousIndexesList = Vec::new();
for row in 0..detectionRXingResult.getBarcodeRowCount() {
// for (int row = 0; row < detectionRXingResult.getBarcodeRowCount(); row++) {
for column in 0..detectionRXingResult.getBarcodeColumnCount() {
// for (int column = 0; column < detectionRXingResult.getBarcodeColumnCount(); column++) {
let values = barcodeMatrix[row as usize][column + 1].getValue();
let codewordIndex =
row as usize * detectionRXingResult.getBarcodeColumnCount() + column;
@@ -427,10 +452,10 @@ fn createDecoderRXingResult(
}
}
}
let mut ambiguousIndexValues = Vec::new(); //new int[ambiguousIndexValuesList.size()][];
for value in ambiguousIndexValuesList {
ambiguousIndexValues.push(value);
}
let ambiguousIndexValues = Vec::from_iter(ambiguousIndexValuesList.into_iter());
// for value in ambiguousIndexValuesList {
// ambiguousIndexValues.push(value);
// }
// for i in 0..ambiguousIndexValuesList.len() {
// // for (int i = 0; i < ambiguousIndexValues.length; i++) {
// ambiguousIndexValues[i] = ambiguousIndexValuesList.get(i) as u32;
@@ -559,22 +584,21 @@ fn getStartColumn(
barcodeColumn: usize,
imageRow: u32,
leftToRight: bool,
) -> u32 {
) -> Option<u32> {
let offset: isize = if leftToRight { 1 } else { -1 };
let mut barcodeColumn = barcodeColumn as isize;
let mut codeword = &None;
if isValidBarcodeColumn(detectionRXingResult, (barcodeColumn - offset) as usize) {
codeword = detectionRXingResult
.getDetectionRXingResultColumn((barcodeColumn - offset) as usize)
.as_ref()
.unwrap()
.as_ref()?
.getCodeword(imageRow);
}
if let Some(codeword) = codeword {
return if leftToRight {
codeword.getEndX()
Some(codeword.getEndX())
} else {
codeword.getStartX()
Some(codeword.getStartX())
};
}
@@ -584,30 +608,28 @@ fn getStartColumn(
{
codeword = detectionRXingResult
.getDetectionRXingResultColumn(barcodeColumn as usize)
.as_ref()
.unwrap()
.as_ref()?
.getCodewordNearby(imageRow);
}
if let Some(codeword) = codeword {
return if leftToRight {
codeword.getStartX()
Some(codeword.getStartX())
} else {
codeword.getEndX()
Some(codeword.getEndX())
};
}
if isValidBarcodeColumn(detectionRXingResult, (barcodeColumn - offset) as usize) {
codeword = detectionRXingResult
.getDetectionRXingResultColumn((barcodeColumn - offset) as usize)
.as_ref()
.unwrap()
.as_ref()?
.getCodewordNearby(imageRow);
}
if let Some(codeword) = codeword {
return if leftToRight {
codeword.getEndX()
Some(codeword.getEndX())
} else {
codeword.getStartX()
Some(codeword.getStartX())
};
}
let mut skippedColumns = 0;
@@ -616,8 +638,7 @@ fn getStartColumn(
barcodeColumn -= offset;
if let Some(previousRowCodeword) = detectionRXingResult
.getDetectionRXingResultColumn(barcodeColumn as usize)
.as_ref()
.unwrap()
.as_ref()?
.getCodewords()
.iter()
.flatten()
@@ -626,23 +647,25 @@ fn getStartColumn(
// for (Codeword previousRowCodeword : detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn).getCodewords()) {
// if let Some(previousRowCodeword) = previousRowCodeword {
// if previousRowCodeword.is_some() {
return ((if leftToRight {
previousRowCodeword.getEndX()
} else {
previousRowCodeword.getStartX()
}) as isize
+ offset
* skippedColumns as isize
* (previousRowCodeword.getEndX() - previousRowCodeword.getStartX()) as isize)
as u32;
return Some(
((if leftToRight {
previousRowCodeword.getEndX()
} else {
previousRowCodeword.getStartX()
}) as isize
+ offset
* skippedColumns as isize
* (previousRowCodeword.getEndX() - previousRowCodeword.getStartX())
as isize) as u32,
);
// }
}
skippedColumns += 1;
}
if leftToRight {
detectionRXingResult.getBoundingBox().getMinX()
Some(detectionRXingResult.getBoundingBox().getMinX())
} else {
detectionRXingResult.getBoundingBox().getMaxX()
Some(detectionRXingResult.getBoundingBox().getMaxX())
}
}
@@ -669,16 +692,14 @@ fn detectCodeword(
// and try to adjust the read pixels, e.g. remove single pixel errors or try to cut off exceeding pixels.
// min and maxCodewordWidth should not be used as they are calculated for the whole barcode an can be inaccurate
// for the current position
let moduleBitCount = getModuleBitCount(
let mut moduleBitCount = getModuleBitCount(
image,
minColumn,
maxColumn,
leftToRight,
startColumn,
imageRow,
);
moduleBitCount?;
let mut moduleBitCount = moduleBitCount.unwrap();
)?;
let endColumn;
let codewordBitCount = moduleBitCount.iter().sum::<u32>();
@@ -791,7 +812,6 @@ fn adjustCodewordStartColumn(
let mut leftToRight = leftToRight;
// there should be no black pixels before the start column. If there are, then we need to start earlier.
for _i in 0..2 {
// for (int i = 0; i < 2; i++) {
while (if leftToRight {
correctedStartColumn >= minColumn
} else {
@@ -815,7 +835,7 @@ fn adjustCodewordStartColumn(
}
fn checkCodewordSkew(codewordSize: u32, minCodewordWidth: u32, maxCodewordWidth: u32) -> bool {
minCodewordWidth - CODEWORD_SKEW_SIZE <= codewordSize
minCodewordWidth as i64 - CODEWORD_SKEW_SIZE as i64 <= codewordSize as i64
&& codewordSize <= maxCodewordWidth + CODEWORD_SKEW_SIZE
}
@@ -894,7 +914,7 @@ fn verifyCodewordCount(codewords: &mut [u32], numECCodewords: u32) -> Result<(),
fn getBitCountForCodeword(codeword: u32) -> [u32; 8] {
let mut codeword = codeword;
let mut result = [0; 8]; //new int[8];
let mut result = [0; 8];
let mut previousValue = 0;
let mut i = result.len() as isize - 1;
loop {

98
src/pdf417/detector/pdf_417_detector.rs
View File

@@ -19,6 +19,8 @@ use crate::{
ResultPoint,
};
use std::borrow::Cow;
use super::PDF417DetectorRXingResult;
/**
@@ -32,8 +34,8 @@ use super::PDF417DetectorRXingResult;
const INDEXES_START_PATTERN: [u32; 4] = [0, 4, 1, 5];
const INDEXES_STOP_PATTERN: [u32; 4] = [6, 2, 7, 3];
const MAX_AVG_VARIANCE: f32 = 0.42;
const MAX_INDIVIDUAL_VARIANCE: f32 = 0.8;
const MAX_AVG_VARIANCE: f64 = 0.42;
const MAX_INDIVIDUAL_VARIANCE: f64 = 0.8;
// B S B S B S B S Bar/Space pattern
// 11111111 0 1 0 1 0 1 000
@@ -70,15 +72,17 @@ pub fn detect_with_hints(
// TODO detection improvement, tryHarder could try several different luminance thresholds/blackpoints or even
// different binarizers
//boolean tryHarder = hints != null && hints.containsKey(DecodeHintType.TRY_HARDER);
//let try_harder = matches!(hints.get(&DecodeHintType::TRY_HARDER), Some(DecodeHintValue::TryHarder(true)));
let originalMatrix = image.getBlackMatrix();
for rotation in ROTATIONS {
// for (int rotation : ROTATIONS) {
let bitMatrix = applyRotation(originalMatrix, rotation);
let barcodeCoordinates = detect(multiple, &bitMatrix);
let bitMatrix = applyRotation(originalMatrix, rotation)?;
let barcodeCoordinates =
detect(multiple, &bitMatrix).ok_or(Exceptions::NotFoundException(None))?;
if !barcodeCoordinates.is_empty() {
return Ok(PDF417DetectorRXingResult::with_rotation(
bitMatrix,
bitMatrix.into_owned(),
barcodeCoordinates,
rotation,
));
@@ -97,13 +101,13 @@ pub fn detect_with_hints(
* @param rotation the degrees of rotation to apply
* @return BitMatrix with applied rotation
*/
fn applyRotation(matrix: &BitMatrix, rotation: u32) -> BitMatrix {
fn applyRotation(matrix: &BitMatrix, rotation: u32) -> Result<Cow<BitMatrix>, Exceptions> {
if rotation % 360 == 0 {
matrix.clone()
Ok(Cow::Borrowed(matrix))
} else {
let mut newMatrix = matrix.clone();
newMatrix.rotate(rotation).expect("rotation must complete");
newMatrix
newMatrix.rotate(rotation)?;
Ok(Cow::Owned(newMatrix))
}
}
@@ -114,13 +118,13 @@ fn applyRotation(matrix: &BitMatrix, rotation: u32) -> BitMatrix {
* @param bitMatrix bit matrix to detect barcodes in
* @return List of RXingResultPoint arrays containing the coordinates of found barcodes
*/
pub fn detect(multiple: bool, bitMatrix: &BitMatrix) -> Vec<[Option<RXingResultPoint>; 8]> {
pub fn detect(multiple: bool, bitMatrix: &BitMatrix) -> Option<Vec<[Option<RXingResultPoint>; 8]>> {
let mut barcodeCoordinates: Vec<[Option<RXingResultPoint>; 8]> = Vec::new();
let mut row = 0;
let mut column = 0;
let mut foundBarcodeInRow = false;
while row < bitMatrix.getHeight() {
let vertices = findVertices(bitMatrix, row, column);
let vertices = findVertices(bitMatrix, row, column)?;
if vertices[0].is_none() && vertices[3].is_none() {
if !foundBarcodeInRow {
@@ -132,9 +136,7 @@ pub fn detect(multiple: bool, bitMatrix: &BitMatrix) -> Vec<[Option<RXingResultP
foundBarcodeInRow = false;
column = 0;
for barcodeCoordinate in &barcodeCoordinates {
// for (RXingResultPoint[] barcodeCoordinate : barcodeCoordinates) {
if let Some(coord_1) = barcodeCoordinate[1] {
// if barcodeCoordinate[1].is_some() {
row = row.max(coord_1.getY() as u32);
}
if let Some(coord_3) = barcodeCoordinate[3] {
@@ -159,7 +161,7 @@ pub fn detect(multiple: bool, bitMatrix: &BitMatrix) -> Vec<[Option<RXingResultP
row = vertices[4].as_ref().unwrap().getY() as u32;
}
}
barcodeCoordinates
Some(barcodeCoordinates)
}
/**
@@ -181,7 +183,7 @@ fn findVertices(
matrix: &BitMatrix,
startRow: u32,
startColumn: u32,
) -> [Option<RXingResultPoint>; 8] {
) -> Option<[Option<RXingResultPoint>; 8]> {
let height = matrix.getHeight();
let width = matrix.getWidth();
let mut startRow = startRow;
@@ -190,7 +192,7 @@ fn findVertices(
let mut result = [None::<RXingResultPoint>; 8]; //RXingResultPoint[8];
copyToRXingResult(
&mut result,
&findRowsWithPattern(matrix, height, width, startRow, startColumn, &START_PATTERN),
&findRowsWithPattern(matrix, height, width, startRow, startColumn, &START_PATTERN)?,
&INDEXES_START_PATTERN,
);
@@ -200,11 +202,11 @@ fn findVertices(
}
copyToRXingResult(
&mut result,
&findRowsWithPattern(matrix, height, width, startRow, startColumn, &STOP_PATTERN),
&findRowsWithPattern(matrix, height, width, startRow, startColumn, &STOP_PATTERN)?,
&INDEXES_STOP_PATTERN,
);
result
Some(result)
}
fn copyToRXingResult(
@@ -213,7 +215,6 @@ fn copyToRXingResult(
destinationIndexes: &[u32],
) {
for i in 0..destinationIndexes.len() {
// for (int i = 0; i < destinationIndexes.length; i++) {
result[destinationIndexes[i] as usize] = tmpRXingResult[i];
}
}
@@ -225,38 +226,35 @@ fn findRowsWithPattern(
startRow: u32,
startColumn: u32,
pattern: &[u32],
) -> [Option<RXingResultPoint>; 4] {
) -> Option<[Option<RXingResultPoint>; 4]> {
let mut startRow = startRow;
let mut result = [None; 4]; //new RXingResultPoint[4];
let mut result = [None; 4];
let mut found = false;
let mut counters = vec![0_u32; pattern.len()];
while startRow < height {
// for (; startRow < height; startRow += ROW_STEP) {
let mut loc_store; // = None;
let mut loc_store;
if let Some(loc) =
findGuardPattern(matrix, startColumn, startRow, width, pattern, &mut counters)
{
// if (loc != null) {
loc_store = Some(loc);
while startRow > 0 {
startRow -= 1;
if let Some(previousRowLoc) =
findGuardPattern(matrix, startColumn, startRow, width, pattern, &mut counters)
{
// if (previousRowLoc != null) {
//loc = previousRowLoc;
loc_store = Some(previousRowLoc);
loc_store.replace(previousRowLoc);
// loc_store = Some(previousRowLoc);
} else {
startRow += 1;
break;
}
}
result[0] = Some(RXingResultPoint::new(
loc_store.as_ref().unwrap()[0] as f32,
loc_store.as_ref()?[0] as f32,
startRow as f32,
));
result[1] = Some(RXingResultPoint::new(
loc_store.as_ref().unwrap()[1] as f32,
loc_store.as_ref()?[1] as f32,
startRow as f32,
));
found = true;
@@ -265,16 +263,16 @@ fn findRowsWithPattern(
startRow += ROW_STEP;
}
let mut stopRow = startRow + 1;
// Last row of the current symbol that contains pattern
if found {
let mut skippedRowCount = 0;
let mut previousRowLoc = [
result[0].as_ref().unwrap().getX() as u32,
result[1].as_ref().unwrap().getX() as u32,
result[0].as_ref()?.getX() as u32,
result[1].as_ref()?.getX() as u32,
];
while stopRow < height {
// for (; stopRow < height; stopRow++) {
if let Some(loc) = findGuardPattern(
matrix,
previousRowLoc[0],
@@ -317,10 +315,9 @@ fn findRowsWithPattern(
}
if stopRow - startRow < BARCODE_MIN_HEIGHT {
result.fill(None);
// Arrays.fill(result, null);
}
result
Some(result)
}
/**
@@ -342,7 +339,6 @@ fn findGuardPattern(
counters: &mut [u32],
) -> Option<[u32; 2]> {
counters.fill(0);
// Arrays.fill(counters, 0, counters.length, 0);
let mut patternStart = column;
let mut pixelDrift = 0;
@@ -400,40 +396,38 @@ fn findGuardPattern(
* @param pattern expected pattern
* @return ratio of total variance between counters and pattern compared to total pattern size
*/
fn patternMatchVariance(counters: &[u32], pattern: &[u32]) -> f32 {
fn patternMatchVariance(counters: &[u32], pattern: &[u32]) -> f64 {
let numCounters = counters.len();
let mut total = 0;
let mut patternLength = 0;
for i in 0..numCounters {
// for (int i = 0; i < numCounters; i++) {
total += counters[i];
patternLength += pattern[i];
}
let total = counters.iter().take(numCounters).sum::<u32>();
let patternLength = pattern.iter().take(numCounters).sum::<u32>();
// for i in 0..numCounters {
// total += counters[i];
// patternLength += pattern[i];
// }
if total < patternLength {
// If we don't even have one pixel per unit of bar width, assume this
// is too small to reliably match, so fail:
return f32::INFINITY; //Float.POSITIVE_INFINITY;
return f64::INFINITY; //Float.POSITIVE_INFINITY;
}
// We're going to fake floating-point math in integers. We just need to use more bits.
// Scale up patternLength so that intermediate values below like scaledCounter will have
// more "significant digits".
let unitBarWidth: f32 = total as f32 / patternLength as f32;
let unitBarWidth: f64 = total as f64 / patternLength as f64;
let maxIndividualVariance = MAX_INDIVIDUAL_VARIANCE * unitBarWidth;
let mut totalVariance = 0.0;
for x in 0..numCounters {
// for (int x = 0; x < numCounters; x++) {
let counter = counters[x];
let scaledPattern: f32 = pattern[x] as f32 * unitBarWidth;
let variance: f32 = if counter as f32 > scaledPattern {
counter as f32 - scaledPattern
let scaledPattern: f64 = pattern[x] as f64 * unitBarWidth;
let variance: f64 = if counter as f64 > scaledPattern {
counter as f64 - scaledPattern
} else {
scaledPattern - counter as f32
scaledPattern - counter as f64
};
if variance > maxIndividualVariance {
return f32::INFINITY;
return f64::INFINITY;
}
totalVariance += variance;
}
totalVariance / total as f32
totalVariance / total as f64
}

12
src/pdf417/encoder/barcode_matrix.rs
View File

@@ -33,11 +33,10 @@ impl BarcodeMatrix {
* @param width the width of the matrix (Cols)
*/
pub fn new(height: usize, width: usize) -> Self {
let mut matrix = Vec::new(); //new BarcodeRow[height];
//Initializes the array to the correct width
//Initializes the array to the correct width
let mut matrix = Vec::with_capacity(height);
for _i in 0..height {
// for (int i = 0, matrixLength = matrix.length; i < matrixLength; i++) {
//matrix[i] = new BarcodeRow((width + 4) * 17 + 1);
matrix.push(BarcodeRow::new((width + 4) * 17 + 1));
}
Self {
@@ -46,9 +45,6 @@ impl BarcodeMatrix {
height,
width: width * 17,
}
// this.width = width * 17;
// this.height = height;
// this.currentRow = -1;
}
pub fn set(&mut self, x: usize, y: usize, value: u8) {
@@ -73,10 +69,8 @@ impl BarcodeMatrix {
pub fn getScaledMatrix(&self, xScale: usize, yScale: usize) -> Vec<Vec<u8>> {
let mut matrixOut = vec![vec![0; self.width * xScale]; self.height * yScale];
// byte[][] matrixOut = new byte[height * yScale][width * xScale];
let yMax = self.height * yScale;
for i in 0..yMax {
// for (int i = 0; i < yMax; i++) {
matrixOut[yMax - i - 1] = self.matrix[i / yScale].getScaledRow(xScale);
}

18
src/pdf417/encoder/barcode_row.rs
View File

@@ -40,18 +40,8 @@ impl BarcodeRow {
* @param x The location in the bar
* @param value Black if true, white if false;
*/
pub fn set(&mut self, x: usize, value: u8) {
self.row[x] = value
}
/**
* Sets a specific location in the bar
*
* @param x The location in the bar
* @param black Black if true, white if false;
*/
fn set_bool(&mut self, x: usize, black: bool) {
self.row[x] = u8::from(black); //if black { 1 } else { 0 }
pub fn set<T: Into<u8>>(&mut self, x: usize, value: T) {
self.row[x] = value.into()
}
/**
@@ -61,7 +51,7 @@ impl BarcodeRow {
pub fn addBar(&mut self, black: bool, width: usize) {
for _ii in 0..width {
// for (int ii = 0; ii < width; ii++) {
self.set_bool(self.currentLocation, black);
self.set(self.currentLocation, black);
self.currentLocation += 1;
}
}
@@ -75,8 +65,6 @@ impl BarcodeRow {
pub fn getScaledRow(&self, scale: usize) -> Vec<u8> {
let mut output = vec![0; self.row.len() * scale];
for (i, row) in output.iter_mut().enumerate() {
// for i in 0..output.len() {
// for (int i = 0; i < output.length; i++) {
*row = self.row[i / scale];
}

65
src/pdf417/encoder/pdf_417.rs
View File

@@ -112,7 +112,6 @@ impl PDF417 {
let mut last = (pattern & map) != 0; //Initialize to inverse of first bit
let mut width = 0;
for _i in 0..len {
// for (int i = 0; i < len; i++) {
let black = (pattern & map) != 0;
if last == black {
width += 1;
@@ -134,33 +133,36 @@ impl PDF417 {
r: u32,
errorCorrectionLevel: u32,
logic: &mut BarcodeMatrix,
) {
) -> Result<(), Exceptions> {
let mut idx = 0;
for y in 0..r {
// for (int y = 0; y < r; y++) {
let cluster = y as usize % 3;
logic.startRow();
Self::encodeChar(START_PATTERN, 17, logic.getCurrentRowMut());
let left;
let right;
if cluster == 0 {
left = (30 * (y / 3)) + ((r - 1) / 3);
right = (30 * (y / 3)) + (c - 1);
} else if cluster == 1 {
left = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
right = (30 * (y / 3)) + ((r - 1) / 3);
} else {
left = (30 * (y / 3)) + (c - 1);
right = (30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3);
}
let (left, right) = match cluster {
0 => ((30 * (y / 3)) + ((r - 1) / 3), (30 * (y / 3)) + (c - 1)),
1 => (
(30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3),
(30 * (y / 3)) + ((r - 1) / 3),
),
_ => (
(30 * (y / 3)) + (c - 1),
(30 * (y / 3)) + (errorCorrectionLevel * 3) + ((r - 1) % 3),
),
};
let mut pattern = CODEWORD_TABLE[cluster][left as usize];
Self::encodeChar(pattern, 17, logic.getCurrentRowMut());
for _x in 0..c {
// for (int x = 0; x < c; x++) {
pattern = CODEWORD_TABLE[cluster][fullCodewords.chars().nth(idx).unwrap() as usize];
pattern = CODEWORD_TABLE[cluster][fullCodewords
.chars()
.nth(idx)
.ok_or(Exceptions::IndexOutOfBoundsException(None))?
as usize];
Self::encodeChar(pattern, 17, logic.getCurrentRowMut());
idx += 1;
}
@@ -174,6 +176,7 @@ impl PDF417 {
Self::encodeChar(STOP_PATTERN, 18, logic.getCurrentRowMut());
}
}
Ok(())
}
/**
@@ -230,11 +233,11 @@ impl PDF417 {
}
let n = sourceCodeWords + pad + 1;
let mut sb = String::with_capacity(n as usize);
sb.push(char::from_u32(n).unwrap());
sb.push(char::from_u32(n).ok_or(Exceptions::ParseException(None))?);
sb.push_str(&highLevel);
for _i in 0..pad {
// for (int i = 0; i < pad; i++) {
sb.push(char::from_u32(900).unwrap()); //PAD characters
sb.push(char::from_u32(900).ok_or(Exceptions::ParseException(None))?);
//PAD characters
}
let dataCodewords = sb;
@@ -252,7 +255,7 @@ impl PDF417 {
rows,
errorCorrectionLevel,
&mut barcode_matrix,
);
)?;
self.barcodeMatrix = Some(barcode_matrix);
Ok(())
}
@@ -286,8 +289,8 @@ impl PDF417 {
continue;
}
let newRatio: f32 =
((17 * cols + 69) as f32 * DEFAULT_MODULE_WIDTH) / (rows as f32 * HEIGHT);
let newRatio: f64 =
((17 * cols + 69) as f64 * DEFAULT_MODULE_WIDTH) / (rows as f64 * HEIGHT);
// ignore if previous ratio is closer to preferred ratio
if dimension.is_some()
@@ -312,13 +315,9 @@ impl PDF417 {
}
}
if let Some(dim) = dimension {
Ok(dim)
} else {
Err(Exceptions::WriterException(Some(
"Unable to fit message in columns".to_owned(),
)))
}
dimension.ok_or(Exceptions::WriterException(Some(
"Unable to fit message in columns".to_owned(),
)))
}
/**
@@ -658,6 +657,6 @@ const CODEWORD_TABLE: [[u32; 929]; 3] = [
],
];
const PREFERRED_RATIO: f32 = 3.0;
const DEFAULT_MODULE_WIDTH: f32 = 0.357; //1px in mm
const HEIGHT: f32 = 2.0; //mm
const PREFERRED_RATIO: f64 = 3.0;
const DEFAULT_MODULE_WIDTH: f64 = 0.357; //1px in mm
const HEIGHT: f64 = 2.0; //mm

21
src/pdf417/encoder/pdf_417_error_correction.rs
View File

@@ -122,7 +122,6 @@ pub fn getErrorCorrectionCodewordCount(errorCorrectionLevel: u32) -> Result<u32,
return Err(Exceptions::IllegalArgumentException(Some(
"Error correction level must be between 0 and 8!".to_owned(),
)));
// throw new IllegalArgumentException("Error correction level must be between 0 and 8!");
}
Ok(1 << (errorCorrectionLevel + 1))
}
@@ -169,28 +168,32 @@ pub fn generateErrorCorrection(
let mut e = vec![0 as char; k as usize]; //new char[k];
let sld = dataCodewords.chars().count();
for i in 0..sld {
// for (int i = 0; i < sld; i++) {
let t1 = (dataCodewords.chars().nth(i).unwrap() as u32 + e[e.len() - 1] as u32) % 929;
let t1 = (dataCodewords
.chars()
.nth(i)
.ok_or(Exceptions::IndexOutOfBoundsException(None))? as u32
+ e[e.len() - 1] as u32)
% 929;
let mut t2;
let mut t3;
let mut j = k as usize - 1;
while j >= 1 {
// for (int j = k - 1; j >= 1; j--) {
t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel as usize][j]) % 929;
t3 = 929 - t2;
e[j] = char::from_u32((e[j - 1] as u32 + t3) % 929).unwrap();
e[j] = char::from_u32((e[j - 1] as u32 + t3) % 929)
.ok_or(Exceptions::ParseException(None))?;
j -= 1;
}
t2 = (t1 * EC_COEFFICIENTS[errorCorrectionLevel as usize][0]) % 929;
t3 = 929 - t2;
e[0] = char::from_u32(t3 % 929).unwrap();
e[0] = char::from_u32(t3 % 929).ok_or(Exceptions::ParseException(None))?;
}
let mut sb = String::with_capacity(k as usize); // StringBuilder(k);
let mut sb = String::with_capacity(k as usize);
let mut j = k as isize - 1;
while j >= 0 {
// for (int j = k - 1; j >= 0; j--) {
if e[j as usize] as u32 != 0 {
e[j as usize] = char::from_u32(929 - e[j as usize] as u32).unwrap();
e[j as usize] = char::from_u32(929 - e[j as usize] as u32)
.ok_or(Exceptions::ParseException(None))?;
}
sb.push(e[j as usize]);

346
src/pdf417/encoder/pdf_417_high_level_encoder.rs
View File

@@ -18,7 +18,7 @@
* This file has been modified from its original form in Barcode4J.
*/
use std::{any::TypeId, fmt::Display};
use std::{any::TypeId, fmt::Display, str::FromStr};
use encoding::EncodingRef;
@@ -125,10 +125,6 @@ const TEXT_PUNCTUATION_RAW: [u8; 30] = [
40, 41, 63, 123, 125, 39, 0,
];
// const MIXED : [u8;128]= [0;128];//new byte[128];
// const PUNCTUATION : [u8;128]= [0;128];//new byte[128];
const DEFAULT_ENCODING: EncodingRef = encoding::all::ISO_8859_1; //StandardCharsets.ISO_8859_1;
const MIXED: [i8; 128] = {
@@ -158,23 +154,6 @@ const PUNCTUATION: [i8; 128] = {
punct
};
// static {
// //Construct inverse lookups
// Arrays.fill(MIXED, (byte) -1);
// for (int i = 0; i < TEXT_MIXED_RAW.length; i++) {
// byte b = TEXT_MIXED_RAW[i];
// if (b > 0) {
// MIXED[b] = (byte) i;
// }
// }
// Arrays.fill(PUNCTUATION, (byte) -1);
// for (int i = 0; i < TEXT_PUNCTUATION_RAW.length; i++) {
// byte b = TEXT_PUNCTUATION_RAW[i];
// if (b > 0) {
// PUNCTUATION[b] = (byte) i;
// }
// }
// }
/**
* Performs high-level encoding of a PDF417 message using the algorithm described in annex P
@@ -206,15 +185,14 @@ pub fn encodeHighLevel(
}
if encoding.is_none() && !autoECI {
for i in 0..msg.chars().count() {
// for (int i = 0; i < msg.length(); i++) {
if msg.chars().nth(i).unwrap() as u32 > 255 {
return Err(Exceptions::WriterException(Some(format!("Non-encodable character detected: {} (Unicode: {}). Consider specifying EncodeHintType.PDF417_AUTO_ECI and/or EncodeTypeHint.CHARACTER_SET.",msg.chars().nth(i).unwrap() as u32,msg.chars().nth(i).unwrap()))));
for ch in msg.chars() {
if ch as u32 > 255 {
return Err(Exceptions::WriterException(Some(format!("Non-encodable character detected: {} (Unicode: {}). Consider specifying EncodeHintType.PDF417_AUTO_ECI and/or EncodeTypeHint.CHARACTER_SET.",ch as u32,ch))));
}
}
}
//the codewords 0..928 are encoded as Unicode characters
let mut sb = String::with_capacity(msg.len()); //new StringBuilder(msg.length());
let mut sb = String::with_capacity(msg.len());
let input: Box<dyn ECIInput>;
if autoECI {
@@ -223,9 +201,15 @@ pub fn encodeHighLevel(
input = Box::new(NoECIInput::new(msg.to_owned()));
if encoding.is_none() {
encoding = Some(DEFAULT_ENCODING);
} else if DEFAULT_ENCODING.name() != encoding.as_ref().unwrap().name() {
if let Some(eci) = CharacterSetECI::getCharacterSetECI(encoding.unwrap()) {
// if (eci != null) {
} else if DEFAULT_ENCODING.name()
!= encoding
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?
.name()
{
if let Some(eci) = CharacterSetECI::getCharacterSetECI(
encoding.ok_or(Exceptions::IllegalStateException(None))?,
) {
encodingECI(CharacterSetECI::getValue(&eci) as i32, &mut sb)?;
}
}
@@ -240,27 +224,26 @@ pub fn encodeHighLevel(
Compaction::TEXT => {
encodeText(&input, p, len as u32, &mut sb, textSubMode)?;
}
Compaction::BYTE if autoECI => {
encodeMultiECIBinary(&input, 0, input.length() as u32, TEXT_COMPACTION, &mut sb)?
}
Compaction::BYTE => {
if autoECI {
encodeMultiECIBinary(&input, 0, input.length() as u32, TEXT_COMPACTION, &mut sb)?;
} else {
let msgBytes = encoding
.as_ref()
.unwrap()
.encode(&input.to_string(), encoding::EncoderTrap::Strict)
.unwrap_or_default(); //input.to_string().getBytes(encoding);
encodeBinary(
&msgBytes,
p,
msgBytes.len() as u32,
BYTE_COMPACTION,
&mut sb,
);
}
let msgBytes = encoding
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?
.encode(&input.to_string(), encoding::EncoderTrap::Strict)
.unwrap_or_default(); //input.to_string().getBytes(encoding);
encodeBinary(
&msgBytes,
p,
msgBytes.len() as u32,
BYTE_COMPACTION,
&mut sb,
)?;
}
Compaction::NUMERIC => {
sb.push(char::from_u32(LATCH_TO_NUMERIC).unwrap());
encodeNumeric(&input, p, len as u32, &mut sb);
sb.push(char::from_u32(LATCH_TO_NUMERIC).ok_or(Exceptions::ParseException(None))?);
encodeNumeric(&input, p, len as u32, &mut sb)?;
}
_ => {
let mut encodingMode = TEXT_COMPACTION; //Default mode, see 4.4.2.1
@@ -272,18 +255,23 @@ pub fn encodeHighLevel(
if p >= len as u32 {
break;
}
let n = determineConsecutiveDigitCount(&input, p);
let n = determineConsecutiveDigitCount(&input, p)?;
if n >= 13 {
sb.push(char::from_u32(LATCH_TO_NUMERIC).unwrap());
sb.push(
char::from_u32(LATCH_TO_NUMERIC).ok_or(Exceptions::ParseException(None))?,
);
encodingMode = NUMERIC_COMPACTION;
textSubMode = SUBMODE_ALPHA; //Reset after latch
encodeNumeric(&input, p, n, &mut sb);
encodeNumeric(&input, p, n, &mut sb)?;
p += n;
} else {
let t = determineConsecutiveTextCount(&input, p);
let t = determineConsecutiveTextCount(&input, p)?;
if t >= 5 || n == len as u32 {
if encodingMode != TEXT_COMPACTION {
sb.push(char::from_u32(LATCH_TO_TEXT).unwrap());
sb.push(
char::from_u32(LATCH_TO_TEXT)
.ok_or(Exceptions::ParseException(None))?,
);
encodingMode = TEXT_COMPACTION;
textSubMode = SUBMODE_ALPHA; //start with submode alpha after latch
}
@@ -307,32 +295,30 @@ pub fn encodeHighLevel(
.collect::<String>();
if let Ok(enc_str) = encoding
.as_ref()
.unwrap()
.ok_or(Exceptions::IllegalStateException(None))?
.encode(&str, encoding::EncoderTrap::Strict)
{
Some(enc_str)
} else {
None
}
}; //.getBytes(encoding))};
// if let Some(byts) = bytes {
let bytes_ok = bytes.is_some(); //if let Some(_) = bytes { true } else { false };
if (bytes_ok && b == 1)
/*((bytes_ok && b == 1)
|| (!bytes_ok && bytes.as_ref().unwrap().len() == 1))*/
&& (encodingMode == TEXT_COMPACTION)
{
};
let bytes_ok = bytes.is_some();
if (bytes_ok && b == 1) && (encodingMode == TEXT_COMPACTION) {
//Switch for one byte (instead of latch)
if autoECI {
encodeMultiECIBinary(&input, p, 1, TEXT_COMPACTION, &mut sb)?;
} else {
encodeBinary(
bytes.as_ref().unwrap(),
bytes
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?,
0,
1,
TEXT_COMPACTION,
&mut sb,
);
)?;
}
} else {
//Mode latch performed by encodeBinary()
@@ -340,12 +326,17 @@ pub fn encodeHighLevel(
encodeMultiECIBinary(&input, p, p + b, encodingMode, &mut sb)?;
} else {
encodeBinary(
bytes.as_ref().unwrap(),
bytes
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?,
0,
bytes.as_ref().unwrap().len() as u32,
bytes
.as_ref()
.ok_or(Exceptions::IllegalStateException(None))?
.len() as u32,
encodingMode,
&mut sb,
);
)?;
}
encodingMode = BYTE_COMPACTION;
textSubMode = SUBMODE_ALPHA; //Reset after latch
@@ -393,7 +384,10 @@ fn encodeText<T: ECIInput + ?Sized>(
if ch == ' ' {
tmp.push(26 as char); //space
} else {
tmp.push(char::from_u32(ch as u32 - 65).unwrap());
tmp.push(
char::from_u32(ch as u32 - 65)
.ok_or(Exceptions::ParseException(None))?,
);
}
} else if isAlphaLower(ch) {
submode = SUBMODE_LOWER;
@@ -405,37 +399,49 @@ fn encodeText<T: ECIInput + ?Sized>(
continue;
} else {
tmp.push(29 as char); //ps
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
//break;
tmp.push(
char::from_u32(PUNCTUATION[ch as usize] as u32)
.ok_or(Exceptions::ParseException(None))?,
);
}
}
// break;
SUBMODE_LOWER => {
if isAlphaLower(ch) {
if ch == ' ' {
tmp.push(26 as char); //space
} else {
tmp.push(char::from_u32(ch as u32 - 97).unwrap());
tmp.push(
char::from_u32(ch as u32 - 97)
.ok_or(Exceptions::ParseException(None))?,
);
}
} else if isAlphaUpper(ch) {
tmp.push(27 as char); //as
tmp.push(char::from_u32(ch as u32 - 65).unwrap());
tmp.push(
char::from_u32(ch as u32 - 65)
.ok_or(Exceptions::ParseException(None))?,
);
//space cannot happen here, it is also in "Lower"
//break;
} else if isMixed(ch) {
submode = SUBMODE_MIXED;
tmp.push(28 as char); //ml
continue;
} else {
tmp.push(29 as char); //ps
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
//break;
tmp.push(
char::from_u32(PUNCTUATION[ch as usize] as u32)
.ok_or(Exceptions::ParseException(None))?,
);
}
}
// break;
SUBMODE_MIXED => {
if isMixed(ch) {
tmp.push(char::from_u32(MIXED[ch as usize] as u32).unwrap());
tmp.push(
char::from_u32(MIXED[ch as usize] as u32)
.ok_or(Exceptions::ParseException(None))?,
);
} else if isAlphaUpper(ch) {
submode = SUBMODE_ALPHA;
tmp.push(28 as char); //al
@@ -454,14 +460,20 @@ fn encodeText<T: ECIInput + ?Sized>(
continue;
}
tmp.push(29 as char); //ps
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
tmp.push(
char::from_u32(PUNCTUATION[ch as usize] as u32)
.ok_or(Exceptions::ParseException(None))?,
);
}
}
_ =>
//SUBMODE_PUNCTUATION
{
if isPunctuation(ch) {
tmp.push(char::from_u32(PUNCTUATION[ch as usize] as u32).unwrap());
tmp.push(
char::from_u32(PUNCTUATION[ch as usize] as u32)
.ok_or(Exceptions::ParseException(None))?,
);
} else {
submode = SUBMODE_ALPHA;
tmp.push(29 as char); //al
@@ -478,17 +490,28 @@ fn encodeText<T: ECIInput + ?Sized>(
let mut h = 0 as char;
let len = tmp.chars().count();
for i in 0..len {
// for (int i = 0; i < len; i++) {
let odd = (i % 2) != 0;
if odd {
h = char::from_u32((h as u32 * 30) + tmp.chars().nth(i).unwrap() as u32).unwrap();
h = char::from_u32(
(h as u32 * 30)
+ tmp
.chars()
.nth(i)
.ok_or(Exceptions::IndexOutOfBoundsException(None))?
as u32,
)
.ok_or(Exceptions::ParseException(None))?;
sb.push(h);
} else {
h = tmp.chars().nth(i).unwrap();
h = tmp
.chars()
.nth(i)
.ok_or(Exceptions::IndexOutOfBoundsException(None))?;
}
}
if (len % 2) != 0 {
sb.push(char::from_u32((h as u32 * 30) + 29).unwrap()); //ps
sb.push(char::from_u32((h as u32 * 30) + 29).ok_or(Exceptions::ParseException(None))?);
//ps
}
Ok(submode)
}
@@ -530,7 +553,7 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
} else {
//encode the segment
encodeBinary(
&subBytes(input, localStart, localEnd),
&subBytes(input, localStart, localEnd)?,
0,
localCount as u32,
if localStart == startpos {
@@ -539,7 +562,7 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
BYTE_COMPACTION
},
sb,
);
)?;
localStart = localEnd;
}
}
@@ -547,14 +570,17 @@ fn encodeMultiECIBinary<T: ECIInput + ?Sized>(
Ok(())
}
pub fn subBytes<T: ECIInput + ?Sized>(input: &Box<T>, start: u32, end: u32) -> Vec<u8> {
pub fn subBytes<T: ECIInput + ?Sized>(
input: &Box<T>,
start: u32,
end: u32,
) -> Result<Vec<u8>, Exceptions> {
let count = (end - start) as usize;
let mut result = vec![0_u8; count];
for i in start as usize..end as usize {
// for (int i = start; i < end; i++) {
result[i - start as usize] = input.charAt(i).unwrap() as u8;
result[i - start as usize] = input.charAt(i)? as u8;
}
result
Ok(result)
}
/**
@@ -568,13 +594,19 @@ pub fn subBytes<T: ECIInput + ?Sized>(input: &Box<T>, start: u32, end: u32) -> V
* @param startmode the mode from which this method starts
* @param sb receives the encoded codewords
*/
fn encodeBinary(bytes: &[u8], startpos: u32, count: u32, startmode: u32, sb: &mut String) {
fn encodeBinary(
bytes: &[u8],
startpos: u32,
count: u32,
startmode: u32,
sb: &mut String,
) -> Result<(), Exceptions> {
if count == 1 && startmode == TEXT_COMPACTION {
sb.push(char::from_u32(SHIFT_TO_BYTE).unwrap());
sb.push(char::from_u32(SHIFT_TO_BYTE).ok_or(Exceptions::ParseException(None))?);
} else if (count % 6) == 0 {
sb.push(char::from_u32(LATCH_TO_BYTE).unwrap());
sb.push(char::from_u32(LATCH_TO_BYTE).ok_or(Exceptions::ParseException(None))?);
} else {
sb.push(char::from_u32(LATCH_TO_BYTE_PADDED).unwrap());
sb.push(char::from_u32(LATCH_TO_BYTE_PADDED).ok_or(Exceptions::ParseException(None))?);
}
let mut idx = startpos;
@@ -584,37 +616,39 @@ fn encodeBinary(bytes: &[u8], startpos: u32, count: u32, startmode: u32, sb: &mu
while (startpos + count - idx) >= 6 {
let mut t: i64 = 0;
for i in 0..6 {
// for (int i = 0; i < 6; i++) {
t <<= 8;
t += bytes[idx as usize + i as usize] as i64;
}
for ch in &mut chars {
// for i in 0..5 {
// for (int i = 0; i < 5; i++) {
*ch = char::from_u32((t % 900) as u32).unwrap();
*ch = char::from_u32((t % 900) as u32).ok_or(Exceptions::ParseException(None))?;
t /= 900;
}
for ch in chars.into_iter().rev() {
// for i in (0..chars.len()).rev() {
// for (int i = chars.length - 1; i >= 0; i--) {
sb.push(ch);
}
sb.push_str(&chars.into_iter().rev().collect::<String>());
idx += 6;
}
}
//Encode rest (remaining n<5 bytes if any)
for i in idx..(startpos + count) {
// for (int i = idx; i < startpos + count; i++) {
let ch = bytes[i as usize];
sb.push(ch as char);
}
Ok(())
}
fn encodeNumeric<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32, count: u32, sb: &mut String) {
fn encodeNumeric<T: ECIInput + ?Sized>(
input: &Box<T>,
startpos: u32,
count: u32,
sb: &mut String,
) -> Result<(), Exceptions> {
let mut idx = 0;
let mut tmp = String::with_capacity(count as usize / 3 + 1);
let num900: u128 = 900;
let num0: u128 = 0;
let NUM900: num::BigUint = num::BigUint::from(900_u16); //.ok_or(Exceptions::ParseException(None))?;
let NUM0: num::BigUint = num::BigUint::from(0_u8); //.ok_or(Exceptions::ParseException(None))?;
// let num900: u128 = 900;
// const NUM0: u128 = 0;
while idx < count {
tmp.clear();
let len = 44.min(count as isize - idx as isize);
@@ -624,31 +658,35 @@ fn encodeNumeric<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32, count: u32
.subSequence(
(startpos + idx) as usize,
(startpos + idx + len as u32) as usize
)
.unwrap()
)?
.iter()
.collect::<String>()
);
let mut bigint: u128 = part.parse().unwrap();
// let mut bigint: u128 = part.parse().map_err(|_| Exceptions::ParseException(None))?;
let mut bigint = num::BigUint::from_str(&part)
.map_err(|e| Exceptions::ParseException(Some(format!("issue parsing {part}: {e}"))))?; // part.parse().map_err(|_| Exceptions::ParseException(None))?;
loop {
tmp.push(char::from_u32((bigint % num900) as u32).unwrap());
bigint /= num900;
tmp.push(
char::from_u32((&bigint % &NUM900).try_into().map_err(|e| {
Exceptions::ParseException(Some(format!(
"erorr converting {bigint} to u32: {e}"
)))
})?)
.ok_or(Exceptions::ParseException(None))?,
);
bigint /= &NUM900;
if bigint == num0 {
if bigint == NUM0 {
break;
}
} //while (!bigint.equals(num0));
}
//Reverse temporary string
let mut i = tmp.chars().count() as isize - 1;
while i >= 0 {
// for (int i = tmp.length() - 1; i >= 0; i--) {
sb.push(tmp.chars().nth(i as usize).unwrap());
i -= 1;
}
sb.push_str(&tmp.chars().rev().collect::<String>());
idx += len as u32;
}
Ok(())
}
fn isDigit(ch: char) -> bool {
@@ -682,19 +720,21 @@ fn isText(ch: char) -> bool {
* @param startpos the start position within the input
* @return the requested character count
*/
fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32) -> u32 {
fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(
input: &Box<T>,
startpos: u32,
) -> Result<u32, Exceptions> {
let mut count = 0;
let len = input.length();
let mut idx = startpos as usize;
if idx < len {
while idx < len && !input.isECI(idx as u32).unwrap() && isDigit(input.charAt(idx).unwrap())
{
while idx < len && !input.isECI(idx as u32)? && isDigit(input.charAt(idx)?) {
count += 1;
idx += 1;
}
}
count
Ok(count)
}
/**
@@ -704,21 +744,24 @@ fn determineConsecutiveDigitCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos
* @param startpos the start position within the input
* @return the requested character count
*/
fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos: u32) -> u32 {
fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(
input: &Box<T>,
startpos: u32,
) -> Result<u32, Exceptions> {
let len = input.length();
let mut idx = startpos as usize;
while idx < len {
let mut numericCount = 0;
while numericCount < 13
&& idx < len
&& !input.isECI(idx as u32).unwrap()
&& isDigit(input.charAt(idx).unwrap())
&& !input.isECI(idx as u32)?
&& isDigit(input.charAt(idx)?)
{
numericCount += 1;
idx += 1;
}
if numericCount >= 13 {
return (idx - startpos as usize - numericCount) as u32;
return Ok((idx - startpos as usize - numericCount) as u32);
}
if numericCount > 0 {
//Heuristic: All text-encodable chars or digits are binary encodable
@@ -726,12 +769,12 @@ fn determineConsecutiveTextCount<T: ECIInput + ?Sized>(input: &Box<T>, startpos:
}
//Check if character is encodable
if input.isECI(idx as u32).unwrap() || !isText(input.charAt(idx).unwrap()) {
if input.isECI(idx as u32)? || !isText(input.charAt(idx)?) {
break;
}
idx += 1;
}
(idx - startpos as usize) as u32
Ok((idx - startpos as usize) as u32)
}
/**
@@ -747,17 +790,13 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
startpos: u32,
encoding: Option<EncodingRef>,
) -> Result<u32, Exceptions> {
// CharsetEncoder encoder = encoding == null ? null : encoding.newEncoder();
let len = input.length();
let mut idx = startpos as usize;
while idx < len {
let mut numericCount = 0;
let mut i = idx;
while numericCount < 13
&& !input.isECI(i as u32).unwrap()
&& isDigit(input.charAt(i).unwrap())
{
while numericCount < 13 && !input.isECI(i as u32)? && isDigit(input.charAt(i)?) {
numericCount += 1;
//textCount++;
i = idx + numericCount;
@@ -777,11 +816,13 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
)
.is_ok();
// if encoder != null && !encoder.canEncode(input.charAt(idx)) {
if !can_encode {
assert!(TypeId::of::<T>() == TypeId::of::<NoECIInput>());
// assert!(input instanceof NoECIInput);
let ch = input.charAt(idx).unwrap();
if TypeId::of::<T>() != TypeId::of::<NoECIInput>() {
return Err(Exceptions::IllegalStateException(Some(
"expected NoECIInput type".to_owned(),
)));
}
let ch = input.charAt(idx)?;
return Err(Exceptions::WriterException(Some(format!(
"Non-encodable character detected: {} (Unicode: {})",
ch, ch as u32
@@ -795,15 +836,15 @@ fn determineConsecutiveBinaryCount<T: ECIInput + ?Sized + 'static>(
fn encodingECI(eci: i32, sb: &mut String) -> Result<(), Exceptions> {
if (0..900).contains(&eci) {
sb.push(char::from_u32(ECI_CHARSET).unwrap());
sb.push(char::from_u32(eci as u32).unwrap());
sb.push(char::from_u32(ECI_CHARSET).ok_or(Exceptions::ParseException(None))?);
sb.push(char::from_u32(eci as u32).ok_or(Exceptions::ParseException(None))?);
} else if eci < 810900 {
sb.push(char::from_u32(ECI_GENERAL_PURPOSE).unwrap());
sb.push(char::from_u32((eci / 900 - 1) as u32).unwrap());
sb.push(char::from_u32((eci % 900) as u32).unwrap());
sb.push(char::from_u32(ECI_GENERAL_PURPOSE).ok_or(Exceptions::ParseException(None))?);
sb.push(char::from_u32((eci / 900 - 1) as u32).ok_or(Exceptions::ParseException(None))?);
sb.push(char::from_u32((eci % 900) as u32).ok_or(Exceptions::ParseException(None))?);
} else if eci < 811800 {
sb.push(char::from_u32(ECI_USER_DEFINED).unwrap());
sb.push(char::from_u32((810900 - eci) as u32).unwrap());
sb.push(char::from_u32(ECI_USER_DEFINED).ok_or(Exceptions::ParseException(None))?);
sb.push(char::from_u32((810900 - eci) as u32).ok_or(Exceptions::ParseException(None))?);
} else {
return Err(Exceptions::WriterException(Some(format!(
"ECI number not in valid range from 0..811799, but was {eci}"
@@ -819,11 +860,10 @@ impl ECIInput for NoECIInput {
}
fn charAt(&self, index: usize) -> Result<char, Exceptions> {
if let Some(ch) = self.0.chars().nth(index) {
Ok(ch)
} else {
Err(Exceptions::IndexOutOfBoundsException(None))
}
self.0
.chars()
.nth(index)
.ok_or(Exceptions::IndexOutOfBoundsException(None))
}
fn subSequence(&self, start: usize, end: usize) -> Result<Vec<char>, Exceptions> {
@@ -839,8 +879,8 @@ impl ECIInput for NoECIInput {
Ok(-1)
}
fn haveNCharacters(&self, index: usize, n: usize) -> bool {
index + n <= self.0.len()
fn haveNCharacters(&self, index: usize, n: usize) -> Result<bool, Exceptions> {
Ok(index + n <= self.0.len())
}
}
impl NoECIInput {

28
src/pdf417/pdf_417_common.rs
View File

@@ -39,33 +39,23 @@ pub const EMPTY_INT_ARRAY: [u32; 0] = [];
*/
#[deprecated]
pub fn getBitCountSum(moduleBitCount: &[u32]) -> u32 {
// return MathUtils.sum(moduleBitCount);
moduleBitCount.iter().sum::<u32>()
}
// pub fn toIntArray(list: Vec<u32>) -> Vec<u32> {
// // if (list == null || list.isEmpty()) {
// // return EMPTY_INT_ARRAY;
// // }
// // int[] result = new int[list.size()];
// // int i = 0;
// // for (Integer integer : list) {
// // result[i++] = integer;
// // }
// // return result;
// list
// }
/**
* @param symbol encoded symbol to translate to a codeword
* @return the codeword corresponding to the symbol.
*/
pub fn getCodeword(symbol: u32) -> i32 {
if let Ok(pos) = SYMBOL_TABLE.binary_search(&(symbol & 0x3FFFF)) {
((CODEWORD_TABLE[pos] - 1) % NUMBER_OF_CODEWORDS) as i32
} else {
-1
}
SYMBOL_TABLE.binary_search(&(symbol & 0x3FFFF)).map_or_else(
|_| -1,
|pos| ((CODEWORD_TABLE[pos] - 1) % NUMBER_OF_CODEWORDS) as i32,
)
// if let Ok(pos) = SYMBOL_TABLE.binary_search(&(symbol & 0x3FFFF)) {
// ((CODEWORD_TABLE[pos] - 1) % NUMBER_OF_CODEWORDS) as i32
// } else {
// -1
// }
// int i = Arrays.binarySearch(SYMBOL_TABLE, symbol & 0x3FFFF);
// if (i < 0) {
// return -1;

25
src/pdf417/pdf_417_reader.rs
View File

@@ -57,12 +57,12 @@ impl Reader for PDF417Reader {
) -> Result<crate::RXingResult, crate::Exceptions> {
let result = Self::decode(image, hints, false)?;
if result.is_empty() {
// if (result.length == 0 || result[0] == null) {
return Err(Exceptions::NotFoundException(None));
}
Ok(result[0].clone())
}
}
impl MultipleBarcodeReader for PDF417Reader {
fn decode_multiple(
&mut self,
@@ -76,11 +76,7 @@ impl MultipleBarcodeReader for PDF417Reader {
image: &mut crate::BinaryBitmap,
hints: &crate::DecodingHintDictionary,
) -> Result<Vec<crate::RXingResult>, crate::Exceptions> {
//try {
Self::decode(image, hints, true)
//} catch (FormatException | ChecksumException ignored) {
// throw NotFoundException.getNotFoundInstance();
//}
}
}
@@ -94,11 +90,13 @@ impl PDF417Reader {
hints: &DecodingHintDictionary,
multiple: bool,
) -> Result<Vec<RXingResult>, Exceptions> {
let mut results = Vec::new(); //new ArrayList<>();
let mut results = Vec::new();
let detectorRXingResult = pdf_417_detector::detect_with_hints(image, hints, multiple)?;
for points in detectorRXingResult.getPoints() {
let points_filtered = points.iter().filter_map(|e| *e).collect();
// for (RXingResultPoint[] points : detectorRXingResult.getPoints()) {
let points_filtered = points.iter().flatten().copied().collect();
// let points_filtered = points.iter().filter_map(|e| *e).collect();
let decoderRXingResult = pdf_417_scanning_decoder::decode(
detectorRXingResult.getBits(),
points[4],
@@ -108,6 +106,7 @@ impl PDF417Reader {
Self::getMinCodewordWidth(points),
Self::getMaxCodewordWidth(points),
)?;
let mut result = RXingResult::new(
decoderRXingResult.getText(),
decoderRXingResult.getRawBytes().clone(),
@@ -128,7 +127,7 @@ impl PDF417Reader {
pdf417RXingResultMetadata
.clone()
.downcast::<PDF417RXingResultMetadata>()
.unwrap(),
.map_err(|_| Exceptions::IllegalStateException(None))?,
);
result.putMetadata(RXingResultMetadataType::PDF417_EXTRA_METADATA, data);
}
@@ -161,10 +160,6 @@ impl PDF417Reader {
} else {
0
}
// if p1 == null || p2 == null {
// return 0;
// }
// return (int) Math.abs(p1.getX() - p2.getX());
}
fn getMinWidth(p1: &Option<RXingResultPoint>, p2: &Option<RXingResultPoint>) -> u64 {
@@ -173,10 +168,6 @@ impl PDF417Reader {
} else {
u32::MAX as u64
}
// if (p1 == null || p2 == null) {
// return Integer.MAX_VALUE;
// }
// return (int) Math.abs(p1.getX() - p2.getX());
}
fn getMaxCodewordWidth(p: &[Option<RXingResultPoint>]) -> u32 {

43
src/pdf417/pdf_417_writer.rs
View File

@@ -73,23 +73,18 @@ impl Writer for PDF417Writer {
if let Some(EncodeHintValue::Pdf417Compact(compact)) =
hints.get(&EncodeHintType::PDF417_COMPACT)
{
// if hints.containsKey(EncodeHintType::PDF417_COMPACT) {
if let Ok(res) = compact.parse::<bool>() {
encoder.setCompact(res);
}
// encoder.setCompact(Boolean.parseBoolean(hints.get(EncodeHintType::PDF417_COMPACT).toString()));
}
if let Some(EncodeHintValue::Pdf417Compaction(compaction)) =
hints.get(&EncodeHintType::PDF417_COMPACTION)
{
// if hints.containsKey(EncodeHintType::PDF417_COMPACTION) {
encoder.setCompaction(compaction.try_into()?);
}
if let Some(EncodeHintValue::Pdf417Dimensions(dimensions)) =
hints.get(&EncodeHintType::PDF417_DIMENSIONS)
{
// if hints.containsKey(EncodeHintType::PDF417_DIMENSIONS) {
// Dimensions dimensions = (Dimensions) hints.get(EncodeHintType::PDF417_DIMENSIONS);
encoder.setDimensions(
dimensions.getMaxCols() as u32,
dimensions.getMinCols() as u32,
@@ -98,27 +93,20 @@ impl Writer for PDF417Writer {
);
}
if let Some(EncodeHintValue::Margin(m1)) = hints.get(&EncodeHintType::MARGIN) {
// if hints.containsKey(EncodeHintType::MARGIN) {
if let Ok(m) = m1.parse::<u32>() {
//margin = Integer.parseInt(hints.get(EncodeHintType::MARGIN).toString());
margin = m;
}
}
if let Some(EncodeHintValue::ErrorCorrection(ec)) =
hints.get(&EncodeHintType::ERROR_CORRECTION)
{
// if hints.containsKey(EncodeHintType::ERROR_CORRECTION) {
if let Ok(ec_parsed) = ec.parse::<u32>() {
errorCorrectionLevel = ec_parsed;
}
// errorCorrectionLevel = Integer.parseInt(hints.get(EncodeHintType::ERROR_CORRECTION).toString());
}
if let Some(EncodeHintValue::CharacterSet(cs)) =
hints.get(&EncodeHintType::CHARACTER_SET)
{
// if hints.containsKey(EncodeHintType::CHARACTER_SET) {
// if let Some(encoding::label::encoding_from_whatwg_label(cs))
// let encoding = Charset.forName(hints.get(&EncodeHintType::CHARACTER_SET).toString());
encoder.setEncoding(encoding::label::encoding_from_whatwg_label(cs));
}
if let Some(EncodeHintValue::Pdf417AutoEci(auto_eci_str)) =
@@ -128,8 +116,6 @@ impl Writer for PDF417Writer {
autoECI = auto_eci_parsed;
}
}
// autoECI = hints.containsKey(EncodeHintType::PDF417_AUTO_ECI) &&
// Boolean.parseBoolean(hints.get(EncodeHintType::PDF417_AUTO_ECI).toString());
}
Self::bitMatrixFromEncoder(
@@ -163,7 +149,7 @@ impl PDF417Writer {
let mut originalScale = encoder
.getBarcodeMatrix()
.as_ref()
.unwrap()
.ok_or(Exceptions::IllegalStateException(None))?
.getScaledMatrix(1, aspectRatio);
let mut rotated = false;
if (height > width) != (originalScale[0].len() < originalScale.len()) {
@@ -179,14 +165,17 @@ impl PDF417Writer {
let mut scaledMatrix = encoder
.getBarcodeMatrix()
.as_ref()
.unwrap()
.ok_or(Exceptions::IllegalStateException(None))?
.getScaledMatrix(scale, scale * aspectRatio);
if rotated {
scaledMatrix = Self::rotateArray(&scaledMatrix);
}
return Ok(Self::bitMatrixFromBitArray(&scaledMatrix, margin));
return Self::bitMatrixFromBitArray(&scaledMatrix, margin)
.ok_or(Exceptions::IllegalStateException(None));
}
Ok(Self::bitMatrixFromBitArray(&originalScale, margin))
Self::bitMatrixFromBitArray(&originalScale, margin)
.ok_or(Exceptions::IllegalStateException(None))
}
/**
@@ -196,22 +185,19 @@ impl PDF417Writer {
* @param margin border around the barcode
* @return BitMatrix of the input
*/
fn bitMatrixFromBitArray(input: &Vec<Vec<u8>>, margin: u32) -> BitMatrix {
fn bitMatrixFromBitArray(input: &Vec<Vec<u8>>, margin: u32) -> Option<BitMatrix> {
// Creates the bit matrix with extra space for whitespace
let mut output = BitMatrix::new(
input[0].len() as u32 + 2 * margin,
input.len() as u32 + 2 * margin,
)
.expect("must generate");
.ok()?;
output.clear();
let mut y = 0;
let mut yOutput = (output.getHeight() - margin - 1) as isize;
while y < input.len() {
// for (int y = 0, yOutput = output.getHeight() - margin - 1; y < input.length; y++, yOutput--) {
let inputY = &input[y];
// for x in 0..input[y].len() {
for (x, x_index_val) in inputY.iter().enumerate().take(input[y].len()) {
// for (int x = 0; x < input[0].length; x++) {
// Zero is white in the byte matrix
if x_index_val == &1 {
output.set(x as u32 + margin, yOutput as u32);
@@ -220,22 +206,19 @@ impl PDF417Writer {
y += 1;
yOutput -= 1;
}
output
Some(output)
}
/**
* Takes and rotates the it 90 degrees
*/
fn rotateArray(bitarray: &Vec<Vec<u8>>) -> Vec<Vec<u8>> {
let mut temp = vec![vec![0; bitarray[0].len()]; bitarray.len()]; // new byte[bitarray[0].length][bitarray.length];
let mut temp = vec![vec![0; bitarray[0].len()]; bitarray.len()];
for ii in 0..bitarray.len() {
// for (int ii = 0; ii < bitarray.length; ii++) {
// This makes the direction consistent on screen when rotating the
// screen;
// This makes the direction consistent on screen when rotating the screen;
let inverseii = bitarray.len() - ii - 1;
for (jj, tmp_spot) in temp.iter_mut().enumerate().take(bitarray[0].len()) {
// for jj in 0..bitarray[0].len() {
// for (int jj = 0; jj < bitarray[0].length; jj++) {
tmp_spot[inverseii] = bitarray[ii][jj];
}
}