mirror of
https://github.com/starovoid/rxing.git
synced 2026-07-26 12:22:34 +00:00
402 lines
15 KiB
Rust
402 lines
15 KiB
Rust
/*
|
|
* 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;
|
|
|
|
/**
|
|
* <p>Decodes Code 39 barcodes. Supports "Full ASCII Code 39" if USE_CODE_39_EXTENDED_MODE is set.</p>
|
|
*
|
|
* @author Sean Owen
|
|
* @see Code93Reader
|
|
*/
|
|
|
|
const ALPHABET_STRING: &'static str = "0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZ-. $/+%";
|
|
|
|
/**
|
|
* These represent the encodings of characters, as patterns of wide and narrow bars.
|
|
* The 9 least-significant bits of each int correspond to the pattern of wide and narrow,
|
|
* with 1s representing "wide" and 0s representing narrow.
|
|
*/
|
|
const CHARACTER_ENCODINGS: vec![Vec<i32>; 43] = vec![// 0-9
|
|
0x034, // 0-9
|
|
0x121, // 0-9
|
|
0x061, // 0-9
|
|
0x160, // 0-9
|
|
0x031, // 0-9
|
|
0x130, // 0-9
|
|
0x070, // 0-9
|
|
0x025, // 0-9
|
|
0x124, // 0-9
|
|
0x064, // A-J
|
|
0x109, // A-J
|
|
0x049, // A-J
|
|
0x148, // A-J
|
|
0x019, // A-J
|
|
0x118, // A-J
|
|
0x058, // A-J
|
|
0x00D, // A-J
|
|
0x10C, // A-J
|
|
0x04C, // A-J
|
|
0x01C, // K-T
|
|
0x103, // K-T
|
|
0x043, // K-T
|
|
0x142, // K-T
|
|
0x013, // K-T
|
|
0x112, // K-T
|
|
0x052, // K-T
|
|
0x007, // K-T
|
|
0x106, // K-T
|
|
0x046, // K-T
|
|
0x016, // U-$
|
|
0x181, // U-$
|
|
0x0C1, // U-$
|
|
0x1C0, // U-$
|
|
0x091, // U-$
|
|
0x190, // U-$
|
|
0x0D0, // U-$
|
|
0x085, // U-$
|
|
0x184, // U-$
|
|
0x0C4, // U-$
|
|
0x0A8, // /-%
|
|
0x0A2, // /-%
|
|
0x08A, // /-%
|
|
0x02A, ]
|
|
;
|
|
|
|
const ASTERISK_ENCODING: i32 = 0x094;
|
|
pub struct Code39Reader {
|
|
super: OneDReader;
|
|
|
|
let using_check_digit: bool;
|
|
|
|
let extended_mode: bool;
|
|
|
|
let decode_row_result: StringBuilder;
|
|
|
|
let mut counters: Vec<i32>;
|
|
}
|
|
|
|
impl Code39Reader {
|
|
|
|
/**
|
|
* Creates a reader that assumes all encoded data is data, and does not treat the final
|
|
* character as a check digit. It will not decoded "extended Code 39" sequences.
|
|
*/
|
|
pub fn new() -> Code39Reader {
|
|
this(false);
|
|
}
|
|
|
|
/**
|
|
* Creates a reader that can be configured to check the last character as a check digit.
|
|
* It will not decoded "extended Code 39" sequences.
|
|
*
|
|
* @param usingCheckDigit if true, treat the last data character as a check digit, not
|
|
* data, and verify that the checksum passes.
|
|
*/
|
|
pub fn new( using_check_digit: bool) -> Code39Reader {
|
|
this(using_check_digit, false);
|
|
}
|
|
|
|
/**
|
|
* Creates a reader that can be configured to check the last character as a check digit,
|
|
* or optionally attempt to decode "extended Code 39" sequences that are used to encode
|
|
* the full ASCII character set.
|
|
*
|
|
* @param usingCheckDigit if true, treat the last data character as a check digit, not
|
|
* data, and verify that the checksum passes.
|
|
* @param extendedMode if true, will attempt to decode extended Code 39 sequences in the
|
|
* text.
|
|
*/
|
|
pub fn new( using_check_digit: bool, extended_mode: bool) -> Code39Reader {
|
|
let .usingCheckDigit = using_check_digit;
|
|
let .extendedMode = extended_mode;
|
|
decode_row_result = StringBuilder::new(20);
|
|
counters = : [i32; 9] = [0; 9];
|
|
}
|
|
|
|
pub fn decode_row(&self, row_number: i32, row: &BitArray, hints: &Map<DecodeHintType, ?>) -> /* throws NotFoundException, ChecksumException, FormatException */Result<Result, Rc<Exception>> {
|
|
let the_counters: Vec<i32> = self.counters;
|
|
Arrays::fill(&the_counters, 0);
|
|
let result: StringBuilder = self.decode_row_result;
|
|
result.set_length(0);
|
|
let start: Vec<i32> = ::find_asterisk_pattern(row, &the_counters);
|
|
// Read off white space
|
|
let next_start: i32 = row.get_next_set(start[1]);
|
|
let end: i32 = row.get_size();
|
|
let decoded_char: char;
|
|
let last_start: i32;
|
|
loop { {
|
|
record_pattern(row, next_start, &the_counters);
|
|
let pattern: i32 = ::to_narrow_wide_pattern(&the_counters);
|
|
if pattern < 0 {
|
|
throw NotFoundException::get_not_found_instance();
|
|
}
|
|
decoded_char = ::pattern_to_char(pattern);
|
|
result.append(decoded_char);
|
|
last_start = next_start;
|
|
for let counter: i32 in the_counters {
|
|
next_start += counter;
|
|
}
|
|
// Read off white space
|
|
next_start = row.get_next_set(next_start);
|
|
}if !(decoded_char != '*') break;}
|
|
// remove asterisk
|
|
result.set_length(result.length() - 1);
|
|
// Look for whitespace after pattern:
|
|
let last_pattern_size: i32 = 0;
|
|
for let counter: i32 in the_counters {
|
|
last_pattern_size += counter;
|
|
}
|
|
let white_space_after_end: i32 = next_start - last_start - last_pattern_size;
|
|
// (but if it's whitespace to the very end of the image, that's OK)
|
|
if next_start != end && (white_space_after_end * 2) < last_pattern_size {
|
|
throw NotFoundException::get_not_found_instance();
|
|
}
|
|
if self.using_check_digit {
|
|
let max: i32 = result.length() - 1;
|
|
let mut total: i32 = 0;
|
|
{
|
|
let mut i: i32 = 0;
|
|
while i < max {
|
|
{
|
|
total += ALPHABET_STRING::index_of(&self.decode_row_result.char_at(i));
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
if result.char_at(max) != ALPHABET_STRING::char_at(total % 43) {
|
|
throw ChecksumException::get_checksum_instance();
|
|
}
|
|
result.set_length(max);
|
|
}
|
|
if result.length() == 0 {
|
|
// false positive
|
|
throw NotFoundException::get_not_found_instance();
|
|
}
|
|
let result_string: String;
|
|
if self.extended_mode {
|
|
result_string = ::decode_extended(&result);
|
|
} else {
|
|
result_string = result.to_string();
|
|
}
|
|
let left: f32 = (start[1] + start[0]) / 2.0f;
|
|
let right: f32 = last_start + last_pattern_size / 2.0f;
|
|
let result_object: Result = Result::new(&result_string, null, : vec![ResultPoint; 2] = vec![ResultPoint::new(left, row_number), ResultPoint::new(right, row_number), ]
|
|
, BarcodeFormat::CODE_39);
|
|
result_object.put_metadata(ResultMetadataType::SYMBOLOGY_IDENTIFIER, "]A0");
|
|
return Ok(result_object);
|
|
}
|
|
|
|
fn find_asterisk_pattern( row: &BitArray, counters: &Vec<i32>) -> /* throws NotFoundException */Result<Vec<i32>, Rc<Exception>> {
|
|
let width: i32 = row.get_size();
|
|
let row_offset: i32 = row.get_next_set(0);
|
|
let counter_position: i32 = 0;
|
|
let pattern_start: i32 = row_offset;
|
|
let is_white: bool = false;
|
|
let pattern_length: i32 = counters.len();
|
|
{
|
|
let mut i: i32 = row_offset;
|
|
while i < width {
|
|
{
|
|
if row.get(i) != is_white {
|
|
counters[counter_position] += 1;
|
|
} else {
|
|
if counter_position == pattern_length - 1 {
|
|
// Look for whitespace before start pattern, >= 50% of width of start pattern
|
|
if ::to_narrow_wide_pattern(&counters) == ASTERISK_ENCODING && row.is_range(&Math::max(0, pattern_start - ((i - pattern_start) / 2)), pattern_start, false) {
|
|
return Ok( : vec![i32; 2] = vec![pattern_start, i, ]
|
|
);
|
|
}
|
|
pattern_start += counters[0] + counters[1];
|
|
System::arraycopy(&counters, 2, &counters, 0, counter_position - 1);
|
|
counters[counter_position - 1] = 0;
|
|
counters[counter_position] = 0;
|
|
counter_position -= 1;
|
|
} else {
|
|
counter_position += 1;
|
|
}
|
|
counters[counter_position] = 1;
|
|
is_white = !is_white;
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
throw NotFoundException::get_not_found_instance();
|
|
}
|
|
|
|
// For efficiency, returns -1 on failure. Not throwing here saved as many as 700 exceptions
|
|
// per image when using some of our blackbox images.
|
|
fn to_narrow_wide_pattern( counters: &Vec<i32>) -> i32 {
|
|
let num_counters: i32 = counters.len();
|
|
let max_narrow_counter: i32 = 0;
|
|
let wide_counters: i32;
|
|
loop { {
|
|
let min_counter: i32 = Integer::MAX_VALUE;
|
|
for let counter: i32 in counters {
|
|
if counter < min_counter && counter > max_narrow_counter {
|
|
min_counter = counter;
|
|
}
|
|
}
|
|
max_narrow_counter = min_counter;
|
|
wide_counters = 0;
|
|
let total_wide_counters_width: i32 = 0;
|
|
let mut pattern: i32 = 0;
|
|
{
|
|
let mut i: i32 = 0;
|
|
while i < num_counters {
|
|
{
|
|
let counter: i32 = counters[i];
|
|
if counter > max_narrow_counter {
|
|
pattern |= 1 << (num_counters - 1 - i);
|
|
wide_counters += 1;
|
|
total_wide_counters_width += counter;
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
if wide_counters == 3 {
|
|
// counter is more than 1.5 times the average:
|
|
{
|
|
let mut i: i32 = 0;
|
|
while i < num_counters && wide_counters > 0 {
|
|
{
|
|
let counter: i32 = counters[i];
|
|
if counter > max_narrow_counter {
|
|
wide_counters -= 1;
|
|
// totalWideCountersWidth = 3 * average, so this checks if counter >= 3/2 * average
|
|
if (counter * 2) >= total_wide_counters_width {
|
|
return -1;
|
|
}
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
return pattern;
|
|
}
|
|
}if !(wide_counters > 3) break;}
|
|
return -1;
|
|
}
|
|
|
|
fn pattern_to_char( pattern: i32) -> /* throws NotFoundException */Result<char, Rc<Exception>> {
|
|
{
|
|
let mut i: i32 = 0;
|
|
while i < CHARACTER_ENCODINGS.len() {
|
|
{
|
|
if CHARACTER_ENCODINGS[i] == pattern {
|
|
return Ok(ALPHABET_STRING::char_at(i));
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
if pattern == ASTERISK_ENCODING {
|
|
return Ok('*');
|
|
}
|
|
throw NotFoundException::get_not_found_instance();
|
|
}
|
|
|
|
fn decode_extended( encoded: &CharSequence) -> /* throws FormatException */Result<String, Rc<Exception>> {
|
|
let length: i32 = encoded.length();
|
|
let decoded: StringBuilder = StringBuilder::new(length);
|
|
{
|
|
let mut i: i32 = 0;
|
|
while i < length {
|
|
{
|
|
let c: char = encoded.char_at(i);
|
|
if c == '+' || c == '$' || c == '%' || c == '/' {
|
|
let next: char = encoded.char_at(i + 1);
|
|
let decoded_char: char = '\0';
|
|
match c {
|
|
'+' =>
|
|
{
|
|
// +A to +Z map to a to z
|
|
if next >= 'A' && next <= 'Z' {
|
|
decoded_char = (next + 32) as char;
|
|
} else {
|
|
throw FormatException::get_format_instance();
|
|
}
|
|
break;
|
|
}
|
|
'$' =>
|
|
{
|
|
// $A to $Z map to control codes SH to SB
|
|
if next >= 'A' && next <= 'Z' {
|
|
decoded_char = (next - 64) as char;
|
|
} else {
|
|
throw FormatException::get_format_instance();
|
|
}
|
|
break;
|
|
}
|
|
'%' =>
|
|
{
|
|
// %A to %E map to control codes ESC to US
|
|
if next >= 'A' && next <= 'E' {
|
|
decoded_char = (next - 38) as char;
|
|
} else if next >= 'F' && next <= 'J' {
|
|
decoded_char = (next - 11) as char;
|
|
} else if next >= 'K' && next <= 'O' {
|
|
decoded_char = (next + 16) as char;
|
|
} else if next >= 'P' && next <= 'T' {
|
|
decoded_char = (next + 43) as char;
|
|
} else if next == 'U' {
|
|
decoded_char = 0 as char;
|
|
} else if next == 'V' {
|
|
decoded_char = '@';
|
|
} else if next == 'W' {
|
|
decoded_char = '`';
|
|
} else if next == 'X' || next == 'Y' || next == 'Z' {
|
|
decoded_char = 127 as char;
|
|
} else {
|
|
throw FormatException::get_format_instance();
|
|
}
|
|
break;
|
|
}
|
|
'/' =>
|
|
{
|
|
// /A to /O map to ! to , and /Z maps to :
|
|
if next >= 'A' && next <= 'O' {
|
|
decoded_char = (next - 32) as char;
|
|
} else if next == 'Z' {
|
|
decoded_char = ':';
|
|
} else {
|
|
throw FormatException::get_format_instance();
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
decoded.append(decoded_char);
|
|
// bump up i again since we read two characters
|
|
i += 1;
|
|
} else {
|
|
decoded.append(c);
|
|
}
|
|
}
|
|
i += 1;
|
|
}
|
|
}
|
|
|
|
return Ok(decoded.to_string());
|
|
}
|
|
}
|
|
|