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

ean13 passes integration

Browse Source
This commit is contained in:
Henry Schimke
2022-12-09 18:37:27 -06:00
parent 81f2298dd0
commit 42e5312e4c
12 changed files with 304 additions and 330 deletions
Download Patch File Download Diff File Expand all files Collapse all files

138
src/oned/EAN13Reader.java
View File

@@ -1,138 +0,0 @@
/*
* Copyright 2008 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.google.zxing.oned;
import com.google.zxing.BarcodeFormat;
import com.google.zxing.NotFoundException;
import com.google.zxing.common.BitArray;
/**
* <p>Implements decoding of the EAN-13 format.</p>
*
* @author dswitkin@google.com (Daniel Switkin)
* @author Sean Owen
* @author alasdair@google.com (Alasdair Mackintosh)
*/
public final class EAN13Reader extends UPCEANReader {
// For an EAN-13 barcode, the first digit is represented by the parities used
// to encode the next six digits, according to the table below. For example,
// if the barcode is 5 123456 789012 then the value of the first digit is
// signified by using odd for '1', even for '2', even for '3', odd for '4',
// odd for '5', and even for '6'. See http://en.wikipedia.org/wiki/EAN-13
//
// Parity of next 6 digits
// Digit 0 1 2 3 4 5
// 0 Odd Odd Odd Odd Odd Odd
// 1 Odd Odd Even Odd Even Even
// 2 Odd Odd Even Even Odd Even
// 3 Odd Odd Even Even Even Odd
// 4 Odd Even Odd Odd Even Even
// 5 Odd Even Even Odd Odd Even
// 6 Odd Even Even Even Odd Odd
// 7 Odd Even Odd Even Odd Even
// 8 Odd Even Odd Even Even Odd
// 9 Odd Even Even Odd Even Odd
//
// Note that the encoding for '0' uses the same parity as a UPC barcode. Hence
// a UPC barcode can be converted to an EAN-13 barcode by prepending a 0.
//
// The encoding is represented by the following array, which is a bit pattern
// using Odd = 0 and Even = 1. For example, 5 is represented by:
//
// Odd Even Even Odd Odd Even
// in binary:
// 0 1 1 0 0 1 == 0x19
//
static final int[] FIRST_DIGIT_ENCODINGS = {
0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A
};
private final int[] decodeMiddleCounters;
public EAN13Reader() {
decodeMiddleCounters = new int[4];
}
@Override
protected int decodeMiddle(BitArray row,
int[] startRange,
StringBuilder resultString) throws NotFoundException {
int[] counters = decodeMiddleCounters;
counters[0] = 0;
counters[1] = 0;
counters[2] = 0;
counters[3] = 0;
int end = row.getSize();
int rowOffset = startRange[1];
int lgPatternFound = 0;
for (int x = 0; x < 6 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_AND_G_PATTERNS);
resultString.append((char) ('0' + bestMatch % 10));
for (int counter : counters) {
rowOffset += counter;
}
if (bestMatch >= 10) {
lgPatternFound |= 1 << (5 - x);
}
}
determineFirstDigit(resultString, lgPatternFound);
int[] middleRange = findGuardPattern(row, rowOffset, true, MIDDLE_PATTERN);
rowOffset = middleRange[1];
for (int x = 0; x < 6 && rowOffset < end; x++) {
int bestMatch = decodeDigit(row, counters, rowOffset, L_PATTERNS);
resultString.append((char) ('0' + bestMatch));
for (int counter : counters) {
rowOffset += counter;
}
}
return rowOffset;
}
@Override
BarcodeFormat getBarcodeFormat() {
return BarcodeFormat.EAN_13;
}
/**
* Based on pattern of odd-even ('L' and 'G') patterns used to encoded the explicitly-encoded
* digits in a barcode, determines the implicitly encoded first digit and adds it to the
* result string.
*
* @param resultString string to insert decoded first digit into
* @param lgPatternFound int whose bits indicates the pattern of odd/even L/G patterns used to
* encode digits
* @throws NotFoundException if first digit cannot be determined
*/
private static void determineFirstDigit(StringBuilder resultString, int lgPatternFound)
throws NotFoundException {
for (int d = 0; d < 10; d++) {
if (lgPatternFound == FIRST_DIGIT_ENCODINGS[d]) {
resultString.insert(0, (char) ('0' + d));
return;
}
}
throw NotFoundException.getNotFoundInstance();
}
}

159
src/oned/ean_13_reader.rs Normal file
View File

@@ -0,0 +1,159 @@
/*
* Copyright 2008 ZXing authors
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
use one_d_reader_derive::{EANReader, OneDReader};
use super::UPCEANReader;
use super::upc_ean_reader;
use super::OneDReader;
use crate::BarcodeFormat;
use crate::Exceptions;
/**
* <p>Implements decoding of the EAN-13 format.</p>
*
* @author dswitkin@google.com (Daniel Switkin)
* @author Sean Owen
* @author alasdair@google.com (Alasdair Mackintosh)
*/
#[derive(OneDReader, EANReader)]
pub struct EAN13Reader;
impl UPCEANReader for EAN13Reader {
fn getBarcodeFormat(&self) -> crate::BarcodeFormat {
BarcodeFormat::EAN_13
}
fn decodeMiddle(
&self,
row: &crate::common::BitArray,
startRange: &[usize; 2],
resultString: &mut String,
) -> Result<usize, crate::Exceptions> {
let mut counters = [0_u32; 4]; //decodeMiddleCounters;
// counters[0] = 0;
// counters[1] = 0;
// counters[2] = 0;
// counters[3] = 0;
let end = row.getSize();
let mut rowOffset = startRange[1];
let mut lgPatternFound = 0;
let mut x = 0;
while x < 6 && rowOffset < end {
// for (int x = 0; x < 6 && rowOffset < end; x++) {
let bestMatch = Self::decodeDigit(
row,
&mut counters,
rowOffset,
&upc_ean_reader::L_AND_G_PATTERNS,
)?;
resultString.push(char::from_u32('0' as u32 + bestMatch as u32 % 10).unwrap());
// for (int counter : counters) {
// rowOffset += counter;
// }
rowOffset += counters.iter().sum::<u32>() as usize;
if bestMatch >= 10 {
lgPatternFound |= 1 << (5 - x);
}
x += 1;
}
Self::determineFirstDigit(resultString, lgPatternFound)?;
let middleRange =
Self::findGuardPattern(row, rowOffset, true, &upc_ean_reader::MIDDLE_PATTERN)?;
rowOffset = middleRange[1];
let mut x = 0;
while x < 6 && rowOffset < end {
// for (int x = 0; x < 6 && rowOffset < end; x++) {
let bestMatch =
Self::decodeDigit(row, &mut counters, rowOffset, &upc_ean_reader::L_PATTERNS)?;
resultString.push(char::from_u32('0' as u32 + bestMatch as u32).unwrap());
// for (int counter : counters) {
// rowOffset += counter;
// }
rowOffset += counters.iter().sum::<u32>() as usize;
x += 1;
}
Ok(rowOffset)
}
}
impl EAN13Reader {
// For an EAN-13 barcode, the first digit is represented by the parities used
// to encode the next six digits, according to the table below. For example,
// if the barcode is 5 123456 789012 then the value of the first digit is
// signified by using odd for '1', even for '2', even for '3', odd for '4',
// odd for '5', and even for '6'. See http://en.wikipedia.org/wiki/EAN-13
//
// Parity of next 6 digits
// Digit 0 1 2 3 4 5
// 0 Odd Odd Odd Odd Odd Odd
// 1 Odd Odd Even Odd Even Even
// 2 Odd Odd Even Even Odd Even
// 3 Odd Odd Even Even Even Odd
// 4 Odd Even Odd Odd Even Even
// 5 Odd Even Even Odd Odd Even
// 6 Odd Even Even Even Odd Odd
// 7 Odd Even Odd Even Odd Even
// 8 Odd Even Odd Even Even Odd
// 9 Odd Even Even Odd Even Odd
//
// Note that the encoding for '0' uses the same parity as a UPC barcode. Hence
// a UPC barcode can be converted to an EAN-13 barcode by prepending a 0.
//
// The encoding is represented by the following array, which is a bit pattern
// using Odd = 0 and Even = 1. For example, 5 is represented by:
//
// Odd Even Even Odd Odd Even
// in binary:
// 0 1 1 0 0 1 == 0x19
//
const FIRST_DIGIT_ENCODINGS: [usize; 10] =
[0x00, 0x0B, 0x0D, 0xE, 0x13, 0x19, 0x1C, 0x15, 0x16, 0x1A];
/**
* Based on pattern of odd-even ('L' and 'G') patterns used to encoded the explicitly-encoded
* digits in a barcode, determines the implicitly encoded first digit and adds it to the
* result string.
*
* @param resultString string to insert decoded first digit into
* @param lgPatternFound int whose bits indicates the pattern of odd/even L/G patterns used to
* encode digits
* @throws NotFoundException if first digit cannot be determined
*/
fn determineFirstDigit(
resultString: &mut String,
lgPatternFound: usize,
) -> Result<(), Exceptions> {
for d in 0..10 {
// for (int d = 0; d < 10; d++) {
if lgPatternFound == Self::FIRST_DIGIT_ENCODINGS[d] {
resultString.insert(0, char::from_u32('0' as u32 + d as u32).unwrap());
return Ok(());
}
}
return Err(Exceptions::NotFoundException("".to_owned()));
}
}

8
src/oned/ean_8_reader.rs
View File

@@ -41,10 +41,10 @@ impl UPCEANReader for EAN8Reader {
resultString: &mut String,
) -> Result<usize, Exceptions> {
let mut counters = [0_u32; 4]; //decodeMiddleCounters;
// counters[0] = 0;
// counters[1] = 0;
// counters[2] = 0;
// counters[3] = 0;
// counters[0] = 0;
// counters[1] = 0;
// counters[2] = 0;
// counters[3] = 0;
let end = row.getSize();
let mut rowOffset = startRange[1];

3
src/oned/mod.rs
View File

@@ -37,3 +37,6 @@ pub use upc_ean_extension_support::*;
mod ean_8_reader;
pub use ean_8_reader::*;
mod ean_13_reader;
pub use ean_13_reader::*;

17
src/oned/upc_ean_reader.rs
View File

@@ -347,7 +347,12 @@ pub trait UPCEANReader: OneDReader {
let check_against = &s[..length - 1]; //s.subSequence(0, length - 1);
let calculated_checksum = Self::getStandardUPCEANChecksum(check_against)?;
Ok( calculated_checksum == if check { char_in_question.to_digit(10).unwrap() } else { u32::MAX })
Ok(calculated_checksum
== if check {
char_in_question.to_digit(10).unwrap()
} else {
u32::MAX
})
}
fn getStandardUPCEANChecksum(s: &str) -> Result<u32, Exceptions> {
@@ -395,7 +400,13 @@ pub trait UPCEANReader: OneDReader {
where
Self: Sized,
{
Self::findGuardPatternWithCounters(row, rowOffset, whiteFirst, pattern, &mut vec![0u32; pattern.len()])
Self::findGuardPatternWithCounters(
row,
rowOffset,
whiteFirst,
pattern,
&mut vec![0u32; pattern.len()],
)
}
/**
@@ -525,7 +536,7 @@ pub trait UPCEANReader: OneDReader {
) -> Result<usize, Exceptions>;
}
pub struct StandIn;
pub(crate) struct StandIn;
impl UPCEANReader for StandIn {
fn getBarcodeFormat(&self) -> BarcodeFormat {
todo!()