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

codeword detector

Browse Source
This commit is contained in:
Henry Schimke
2022-12-19 17:49:40 -06:00
parent 60fdd8e794
commit 9580f542d6
3 changed files with 131 additions and 121 deletions
Download Patch File Download Diff File Expand all files Collapse all files

120
src/pdf417/decoder/PDF417CodewordDecoder.java
View File

@@ -1,120 +0,0 @@
/*
* Copyright 2013 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.pdf417.decoder;
import com.google.zxing.common.detector.MathUtils;
import com.google.zxing.pdf417.PDF417Common;
/**
* @author Guenther Grau
* @author creatale GmbH (christoph.schulz@creatale.de)
*/
final class PDF417CodewordDecoder {
private static final float[][] RATIOS_TABLE =
new float[PDF417Common.SYMBOL_TABLE.length][PDF417Common.BARS_IN_MODULE];
static {
// Pre-computes the symbol ratio table.
for (int i = 0; i < PDF417Common.SYMBOL_TABLE.length; i++) {
int currentSymbol = PDF417Common.SYMBOL_TABLE[i];
int currentBit = currentSymbol & 0x1;
for (int j = 0; j < PDF417Common.BARS_IN_MODULE; j++) {
float size = 0.0f;
while ((currentSymbol & 0x1) == currentBit) {
size += 1.0f;
currentSymbol >>= 1;
}
currentBit = currentSymbol & 0x1;
RATIOS_TABLE[i][PDF417Common.BARS_IN_MODULE - j - 1] = size / PDF417Common.MODULES_IN_CODEWORD;
}
}
}
private PDF417CodewordDecoder() {
}
static int getDecodedValue(int[] moduleBitCount) {
int decodedValue = getDecodedCodewordValue(sampleBitCounts(moduleBitCount));
if (decodedValue != -1) {
return decodedValue;
}
return getClosestDecodedValue(moduleBitCount);
}
private static int[] sampleBitCounts(int[] moduleBitCount) {
float bitCountSum = MathUtils.sum(moduleBitCount);
int[] result = new int[PDF417Common.BARS_IN_MODULE];
int bitCountIndex = 0;
int sumPreviousBits = 0;
for (int i = 0; i < PDF417Common.MODULES_IN_CODEWORD; i++) {
float sampleIndex =
bitCountSum / (2 * PDF417Common.MODULES_IN_CODEWORD) +
(i * bitCountSum) / PDF417Common.MODULES_IN_CODEWORD;
if (sumPreviousBits + moduleBitCount[bitCountIndex] <= sampleIndex) {
sumPreviousBits += moduleBitCount[bitCountIndex];
bitCountIndex++;
}
result[bitCountIndex]++;
}
return result;
}
private static int getDecodedCodewordValue(int[] moduleBitCount) {
int decodedValue = getBitValue(moduleBitCount);
return PDF417Common.getCodeword(decodedValue) == -1 ? -1 : decodedValue;
}
private static int getBitValue(int[] moduleBitCount) {
long result = 0;
for (int i = 0; i < moduleBitCount.length; i++) {
for (int bit = 0; bit < moduleBitCount[i]; bit++) {
result = (result << 1) | (i % 2 == 0 ? 1 : 0);
}
}
return (int) result;
}
private static int getClosestDecodedValue(int[] moduleBitCount) {
int bitCountSum = MathUtils.sum(moduleBitCount);
float[] bitCountRatios = new float[PDF417Common.BARS_IN_MODULE];
if (bitCountSum > 1) {
for (int i = 0; i < bitCountRatios.length; i++) {
bitCountRatios[i] = moduleBitCount[i] / (float) bitCountSum;
}
}
float bestMatchError = Float.MAX_VALUE;
int bestMatch = -1;
for (int j = 0; j < RATIOS_TABLE.length; j++) {
float error = 0.0f;
float[] ratioTableRow = RATIOS_TABLE[j];
for (int k = 0; k < PDF417Common.BARS_IN_MODULE; k++) {
float diff = ratioTableRow[k] - bitCountRatios[k];
error += diff * diff;
if (error >= bestMatchError) {
break;
}
}
if (error < bestMatchError) {
bestMatchError = error;
bestMatch = PDF417Common.SYMBOL_TABLE[j];
}
}
return bestMatch;
}
}

4
src/pdf417/decoder/mod.rs
View File

@@ -13,4 +13,6 @@ mod bounding_box;
pub use bounding_box::*;
mod detection_result_column;
pub use detection_result_column::*;
pub use detection_result_column::*;
pub mod pdf_417_codeword_decoder;

128
src/pdf417/decoder/pdf_417_codeword_decoder.rs Normal file
View File

@@ -0,0 +1,128 @@
/*
* Copyright 2013 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 crate::pdf417::pdf_417_common;
/**
* @author Guenther Grau
* @author creatale GmbH (christoph.schulz@creatale.de)
*/
// const RATIOS_TABLE :[[f32]] =
// [[0.0;pdf_417_common::SYMBOL_TABLE.len()];pdf_417_common::BARS_IN_MODULE];
const RATIOS_TABLE : [[f64;pdf_417_common::BARS_IN_MODULE as usize];2787] = {
let mut table = [[0.0;pdf_417_common::BARS_IN_MODULE as usize];pdf_417_common::SYMBOL_TABLE.len()];
// Pre-computes the symbol ratio table.
let mut i = 0_usize;
while i < pdf_417_common::SYMBOL_TABLE.len() {
// for (int i = 0; i < PDF417Common.SYMBOL_TABLE.length; i++) {
let mut currentSymbol = pdf_417_common::SYMBOL_TABLE[i];
let mut currentBit = currentSymbol & 0x1;
let mut j = 0_usize;
while j < pdf_417_common::BARS_IN_MODULE as usize {
// for (int j = 0; j < pdf_417_common::BARS_IN_MODULE; j++) {
let mut size = 0.0;
while (currentSymbol & 0x1) == currentBit {
size += 1.0;
currentSymbol >>= 1;
}
currentBit = currentSymbol & 0x1;
table[i][pdf_417_common::BARS_IN_MODULE as usize - j - 1] = size / pdf_417_common::MODULES_IN_CODEWORD as f64;
j+=1;
}
i+=1;
}
table
};
pub fn getDecodedValue( moduleBitCount:&[u32]) -> u32{
let decodedValue = getDecodedCodewordValue(&sampleBitCounts(moduleBitCount));
if decodedValue != -1 {
return decodedValue as u32;
}
getClosestDecodedValue(moduleBitCount) as u32
}
fn sampleBitCounts( moduleBitCount:&[u32]) -> [u32;8]{
let bitCountSum:u32 = moduleBitCount.iter().sum(); //MathUtils.sum(moduleBitCount);
let mut result = [0;pdf_417_common::BARS_IN_MODULE as usize];
let mut bitCountIndex = 0;
let mut sumPreviousBits = 0;
for i in 0..pdf_417_common::MODULES_IN_CODEWORD {
// for (int i = 0; i < PDF417Common.MODULES_IN_CODEWORD; i++) {
let sampleIndex:f32 =
bitCountSum as f32/ (2 * pdf_417_common::MODULES_IN_CODEWORD) as f32 +
(i * bitCountSum) as f32 / pdf_417_common::MODULES_IN_CODEWORD as f32;
if sumPreviousBits as f32 + moduleBitCount[bitCountIndex] as f32 <= sampleIndex {
sumPreviousBits += moduleBitCount[bitCountIndex];
bitCountIndex+=1;
}
result[bitCountIndex]+=1;
}
result
}
fn getDecodedCodewordValue( moduleBitCount:&[u32]) -> i32{
let decodedValue = getBitValue(moduleBitCount);
if pdf_417_common::getCodeword(decodedValue as u32) == -1 {-1} else {decodedValue}
}
fn getBitValue( moduleBitCount:&[u32]) -> i32{
let mut result : u64 = 0;
for i in 0..moduleBitCount.len() {
// for (int i = 0; i < moduleBitCount.length; i++) {
for _bit in 0..moduleBitCount[i] {
// for (int bit = 0; bit < moduleBitCount[i]; bit++) {
result = (result << 1) | (if i % 2 == 0 {1} else {0});
}
}
result as i32
}
fn getClosestDecodedValue( moduleBitCount:&[u32]) -> i32{
let bitCountSum : u32= moduleBitCount.iter().sum();//MathUtils.sum(moduleBitCount);
let mut bitCountRatios = [0.0;pdf_417_common::BARS_IN_MODULE as usize];
if bitCountSum > 1 {
for i in 0..bitCountRatios.len() {
// for (int i = 0; i < bitCountRatios.length; i++) {
bitCountRatios[i] = moduleBitCount[i] as f64 / bitCountSum as f64;
}
}
let mut bestMatchError = f64::MAX;
let mut bestMatch = -1_i32;
for j in 0..RATIOS_TABLE.len() {
// for (int j = 0; j < RATIOS_TABLE.length; j++) {
let mut error = 0.0;
let ratioTableRow = RATIOS_TABLE[j];
for k in 0..pdf_417_common::BARS_IN_MODULE as usize{
// for (int k = 0; k < PDF417Common.BARS_IN_MODULE; k++) {
let diff = ratioTableRow[k] - bitCountRatios[k];
error += diff * diff;
if error >= bestMatchError {
break;
}
}
if error < bestMatchError {
bestMatchError = error;
bestMatch = pdf_417_common::SYMBOL_TABLE[j] as i32;
}
}
bestMatch
}