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

move all Result to RXingResult

Browse Source
This commit is contained in:
Henry Schimke
2022-08-20 12:12:30 -05:00
parent 9f72478dc8
commit 90ace738b7
149 changed files with 1658 additions and 1658 deletions
Download Patch File Download Diff File Expand all files Collapse all files

50
src/pdf417/decoder/BoundingBox.java
View File

@@ -17,7 +17,7 @@
package com.google.zxing.pdf417.decoder;
import com.google.zxing.NotFoundException;
import com.google.zxing.ResultPoint;
import com.google.zxing.RXingResultPoint;
import com.google.zxing.common.BitMatrix;
/**
@@ -26,31 +26,31 @@ import com.google.zxing.common.BitMatrix;
final class BoundingBox {
private final BitMatrix image;
private final ResultPoint topLeft;
private final ResultPoint bottomLeft;
private final ResultPoint topRight;
private final ResultPoint bottomRight;
private final RXingResultPoint topLeft;
private final RXingResultPoint bottomLeft;
private final RXingResultPoint topRight;
private final RXingResultPoint bottomRight;
private final int minX;
private final int maxX;
private final int minY;
private final int maxY;
BoundingBox(BitMatrix image,
ResultPoint topLeft,
ResultPoint bottomLeft,
ResultPoint topRight,
ResultPoint bottomRight) throws NotFoundException {
RXingResultPoint topLeft,
RXingResultPoint bottomLeft,
RXingResultPoint topRight,
RXingResultPoint bottomRight) throws NotFoundException {
boolean leftUnspecified = topLeft == null || bottomLeft == null;
boolean rightUnspecified = topRight == null || bottomRight == null;
if (leftUnspecified && rightUnspecified) {
throw NotFoundException.getNotFoundInstance();
}
if (leftUnspecified) {
topLeft = new ResultPoint(0, topRight.getY());
bottomLeft = new ResultPoint(0, bottomRight.getY());
topLeft = new RXingResultPoint(0, topRight.getY());
bottomLeft = new RXingResultPoint(0, bottomRight.getY());
} else if (rightUnspecified) {
topRight = new ResultPoint(image.getWidth() - 1, topLeft.getY());
bottomRight = new ResultPoint(image.getWidth() - 1, bottomLeft.getY());
topRight = new RXingResultPoint(image.getWidth() - 1, topLeft.getY());
bottomRight = new RXingResultPoint(image.getWidth() - 1, bottomLeft.getY());
}
this.image = image;
this.topLeft = topLeft;
@@ -86,18 +86,18 @@ final class BoundingBox {
}
BoundingBox addMissingRows(int missingStartRows, int missingEndRows, boolean isLeft) throws NotFoundException {
ResultPoint newTopLeft = topLeft;
ResultPoint newBottomLeft = bottomLeft;
ResultPoint newTopRight = topRight;
ResultPoint newBottomRight = bottomRight;
RXingResultPoint newTopLeft = topLeft;
RXingResultPoint newBottomLeft = bottomLeft;
RXingResultPoint newTopRight = topRight;
RXingResultPoint newBottomRight = bottomRight;
if (missingStartRows > 0) {
ResultPoint top = isLeft ? topLeft : topRight;
RXingResultPoint top = isLeft ? topLeft : topRight;
int newMinY = (int) top.getY() - missingStartRows;
if (newMinY < 0) {
newMinY = 0;
}
ResultPoint newTop = new ResultPoint(top.getX(), newMinY);
RXingResultPoint newTop = new RXingResultPoint(top.getX(), newMinY);
if (isLeft) {
newTopLeft = newTop;
} else {
@@ -106,12 +106,12 @@ final class BoundingBox {
}
if (missingEndRows > 0) {
ResultPoint bottom = isLeft ? bottomLeft : bottomRight;
RXingResultPoint bottom = isLeft ? bottomLeft : bottomRight;
int newMaxY = (int) bottom.getY() + missingEndRows;
if (newMaxY >= image.getHeight()) {
newMaxY = image.getHeight() - 1;
}
ResultPoint newBottom = new ResultPoint(bottom.getX(), newMaxY);
RXingResultPoint newBottom = new RXingResultPoint(bottom.getX(), newMaxY);
if (isLeft) {
newBottomLeft = newBottom;
} else {
@@ -138,19 +138,19 @@ final class BoundingBox {
return maxY;
}
ResultPoint getTopLeft() {
RXingResultPoint getTopLeft() {
return topLeft;
}
ResultPoint getTopRight() {
RXingResultPoint getTopRight() {
return topRight;
}
ResultPoint getBottomLeft() {
RXingResultPoint getBottomLeft() {
return bottomLeft;
}
ResultPoint getBottomRight() {
RXingResultPoint getBottomRight() {
return bottomRight;
}

18
src/pdf417/decoder/DecodedBitStreamParser.java
View File

@@ -18,8 +18,8 @@ package com.google.zxing.pdf417.decoder;
import com.google.zxing.FormatException;
import com.google.zxing.common.ECIStringBuilder;
import com.google.zxing.common.DecoderResult;
import com.google.zxing.pdf417.PDF417ResultMetadata;
import com.google.zxing.common.DecoderRXingResult;
import com.google.zxing.pdf417.PDF417RXingResultMetadata;
import java.math.BigInteger;
import java.util.Arrays;
@@ -97,10 +97,10 @@ final class DecodedBitStreamParser {
private DecodedBitStreamParser() {
}
static DecoderResult decode(int[] codewords, String ecLevel) throws FormatException {
static DecoderRXingResult decode(int[] codewords, String ecLevel) throws FormatException {
ECIStringBuilder result = new ECIStringBuilder(codewords.length * 2);
int codeIndex = textCompaction(codewords, 1, result);
PDF417ResultMetadata resultMetadata = new PDF417ResultMetadata();
PDF417RXingResultMetadata resultMetadata = new PDF417RXingResultMetadata();
while (codeIndex < codewords[0]) {
int code = codewords[codeIndex++];
switch (code) {
@@ -147,13 +147,13 @@ final class DecodedBitStreamParser {
if (result.isEmpty() && resultMetadata.getFileId() == null) {
throw FormatException.getFormatInstance();
}
DecoderResult decoderResult = new DecoderResult(null, result.toString(), null, ecLevel);
decoderResult.setOther(resultMetadata);
return decoderResult;
DecoderRXingResult decoderRXingResult = new DecoderRXingResult(null, result.toString(), null, ecLevel);
decoderRXingResult.setOther(resultMetadata);
return decoderRXingResult;
}
@SuppressWarnings("deprecation")
static int decodeMacroBlock(int[] codewords, int codeIndex, PDF417ResultMetadata resultMetadata)
static int decodeMacroBlock(int[] codewords, int codeIndex, PDF417RXingResultMetadata resultMetadata)
throws FormatException {
if (codeIndex + NUMBER_OF_SEQUENCE_CODEWORDS > codewords[0]) {
// we must have at least two bytes left for the segment index
@@ -681,7 +681,7 @@ final class DecodedBitStreamParser {
1 x 900 power of 5 + 624 x 900 power of 4 + 434 x 900 power of 3 +
632 x 900 power of 2 + 282 x 900 power of 1 + 200 x 900 power of 0 = 1000213298174000
Remove leading 1 => Result is 000213298174000
Remove leading 1 => RXingResult is 000213298174000
*/
private static String decodeBase900toBase10(int[] codewords, int count) throws FormatException {
BigInteger result = BigInteger.ZERO;

68
src/pdf417/decoder/DetectionResult.java
View File

@@ -23,37 +23,37 @@ import java.util.Formatter;
/**
* @author Guenther Grau
*/
final class DetectionResult {
final class DetectionRXingResult {
private static final int ADJUST_ROW_NUMBER_SKIP = 2;
private final BarcodeMetadata barcodeMetadata;
private final DetectionResultColumn[] detectionResultColumns;
private final DetectionRXingResultColumn[] detectionRXingResultColumns;
private BoundingBox boundingBox;
private final int barcodeColumnCount;
DetectionResult(BarcodeMetadata barcodeMetadata, BoundingBox boundingBox) {
DetectionRXingResult(BarcodeMetadata barcodeMetadata, BoundingBox boundingBox) {
this.barcodeMetadata = barcodeMetadata;
this.barcodeColumnCount = barcodeMetadata.getColumnCount();
this.boundingBox = boundingBox;
detectionResultColumns = new DetectionResultColumn[barcodeColumnCount + 2];
detectionRXingResultColumns = new DetectionRXingResultColumn[barcodeColumnCount + 2];
}
DetectionResultColumn[] getDetectionResultColumns() {
adjustIndicatorColumnRowNumbers(detectionResultColumns[0]);
adjustIndicatorColumnRowNumbers(detectionResultColumns[barcodeColumnCount + 1]);
DetectionRXingResultColumn[] getDetectionRXingResultColumns() {
adjustIndicatorColumnRowNumbers(detectionRXingResultColumns[0]);
adjustIndicatorColumnRowNumbers(detectionRXingResultColumns[barcodeColumnCount + 1]);
int unadjustedCodewordCount = PDF417Common.MAX_CODEWORDS_IN_BARCODE;
int previousUnadjustedCount;
do {
previousUnadjustedCount = unadjustedCodewordCount;
unadjustedCodewordCount = adjustRowNumbers();
} while (unadjustedCodewordCount > 0 && unadjustedCodewordCount < previousUnadjustedCount);
return detectionResultColumns;
return detectionRXingResultColumns;
}
private void adjustIndicatorColumnRowNumbers(DetectionResultColumn detectionResultColumn) {
if (detectionResultColumn != null) {
((DetectionResultRowIndicatorColumn) detectionResultColumn)
private void adjustIndicatorColumnRowNumbers(DetectionRXingResultColumn detectionRXingResultColumn) {
if (detectionRXingResultColumn != null) {
((DetectionRXingResultRowIndicatorColumn) detectionRXingResultColumn)
.adjustCompleteIndicatorColumnRowNumbers(barcodeMetadata);
}
}
@@ -71,7 +71,7 @@ final class DetectionResult {
return 0;
}
for (int barcodeColumn = 1; barcodeColumn < barcodeColumnCount + 1; barcodeColumn++) {
Codeword[] codewords = detectionResultColumns[barcodeColumn].getCodewords();
Codeword[] codewords = detectionRXingResultColumns[barcodeColumn].getCodewords();
for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {
if (codewords[codewordsRow] == null) {
continue;
@@ -95,23 +95,23 @@ final class DetectionResult {
}
private void adjustRowNumbersFromBothRI() {
if (detectionResultColumns[0] == null || detectionResultColumns[barcodeColumnCount + 1] == null) {
if (detectionRXingResultColumns[0] == null || detectionRXingResultColumns[barcodeColumnCount + 1] == null) {
return;
}
Codeword[] LRIcodewords = detectionResultColumns[0].getCodewords();
Codeword[] RRIcodewords = detectionResultColumns[barcodeColumnCount + 1].getCodewords();
Codeword[] LRIcodewords = detectionRXingResultColumns[0].getCodewords();
Codeword[] RRIcodewords = detectionRXingResultColumns[barcodeColumnCount + 1].getCodewords();
for (int codewordsRow = 0; codewordsRow < LRIcodewords.length; codewordsRow++) {
if (LRIcodewords[codewordsRow] != null &&
RRIcodewords[codewordsRow] != null &&
LRIcodewords[codewordsRow].getRowNumber() == RRIcodewords[codewordsRow].getRowNumber()) {
for (int barcodeColumn = 1; barcodeColumn <= barcodeColumnCount; barcodeColumn++) {
Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];
Codeword codeword = detectionRXingResultColumns[barcodeColumn].getCodewords()[codewordsRow];
if (codeword == null) {
continue;
}
codeword.setRowNumber(LRIcodewords[codewordsRow].getRowNumber());
if (!codeword.hasValidRowNumber()) {
detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow] = null;
detectionRXingResultColumns[barcodeColumn].getCodewords()[codewordsRow] = null;
}
}
}
@@ -119,11 +119,11 @@ final class DetectionResult {
}
private int adjustRowNumbersFromRRI() {
if (detectionResultColumns[barcodeColumnCount + 1] == null) {
if (detectionRXingResultColumns[barcodeColumnCount + 1] == null) {
return 0;
}
int unadjustedCount = 0;
Codeword[] codewords = detectionResultColumns[barcodeColumnCount + 1].getCodewords();
Codeword[] codewords = detectionRXingResultColumns[barcodeColumnCount + 1].getCodewords();
for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {
if (codewords[codewordsRow] == null) {
continue;
@@ -133,7 +133,7 @@ final class DetectionResult {
for (int barcodeColumn = barcodeColumnCount + 1;
barcodeColumn > 0 && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP;
barcodeColumn--) {
Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];
Codeword codeword = detectionRXingResultColumns[barcodeColumn].getCodewords()[codewordsRow];
if (codeword != null) {
invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);
if (!codeword.hasValidRowNumber()) {
@@ -146,11 +146,11 @@ final class DetectionResult {
}
private int adjustRowNumbersFromLRI() {
if (detectionResultColumns[0] == null) {
if (detectionRXingResultColumns[0] == null) {
return 0;
}
int unadjustedCount = 0;
Codeword[] codewords = detectionResultColumns[0].getCodewords();
Codeword[] codewords = detectionRXingResultColumns[0].getCodewords();
for (int codewordsRow = 0; codewordsRow < codewords.length; codewordsRow++) {
if (codewords[codewordsRow] == null) {
continue;
@@ -160,7 +160,7 @@ final class DetectionResult {
for (int barcodeColumn = 1;
barcodeColumn < barcodeColumnCount + 1 && invalidRowCounts < ADJUST_ROW_NUMBER_SKIP;
barcodeColumn++) {
Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];
Codeword codeword = detectionRXingResultColumns[barcodeColumn].getCodewords()[codewordsRow];
if (codeword != null) {
invalidRowCounts = adjustRowNumberIfValid(rowIndicatorRowNumber, invalidRowCounts, codeword);
if (!codeword.hasValidRowNumber()) {
@@ -189,10 +189,10 @@ final class DetectionResult {
private void adjustRowNumbers(int barcodeColumn, int codewordsRow, Codeword[] codewords) {
Codeword codeword = codewords[codewordsRow];
Codeword[] previousColumnCodewords = detectionResultColumns[barcodeColumn - 1].getCodewords();
Codeword[] previousColumnCodewords = detectionRXingResultColumns[barcodeColumn - 1].getCodewords();
Codeword[] nextColumnCodewords = previousColumnCodewords;
if (detectionResultColumns[barcodeColumn + 1] != null) {
nextColumnCodewords = detectionResultColumns[barcodeColumn + 1].getCodewords();
if (detectionRXingResultColumns[barcodeColumn + 1] != null) {
nextColumnCodewords = detectionRXingResultColumns[barcodeColumn + 1].getCodewords();
}
Codeword[] otherCodewords = new Codeword[14];
@@ -261,29 +261,29 @@ final class DetectionResult {
return boundingBox;
}
void setDetectionResultColumn(int barcodeColumn, DetectionResultColumn detectionResultColumn) {
detectionResultColumns[barcodeColumn] = detectionResultColumn;
void setDetectionRXingResultColumn(int barcodeColumn, DetectionRXingResultColumn detectionRXingResultColumn) {
detectionRXingResultColumns[barcodeColumn] = detectionRXingResultColumn;
}
DetectionResultColumn getDetectionResultColumn(int barcodeColumn) {
return detectionResultColumns[barcodeColumn];
DetectionRXingResultColumn getDetectionRXingResultColumn(int barcodeColumn) {
return detectionRXingResultColumns[barcodeColumn];
}
@Override
public String toString() {
DetectionResultColumn rowIndicatorColumn = detectionResultColumns[0];
DetectionRXingResultColumn rowIndicatorColumn = detectionRXingResultColumns[0];
if (rowIndicatorColumn == null) {
rowIndicatorColumn = detectionResultColumns[barcodeColumnCount + 1];
rowIndicatorColumn = detectionRXingResultColumns[barcodeColumnCount + 1];
}
try (Formatter formatter = new Formatter()) {
for (int codewordsRow = 0; codewordsRow < rowIndicatorColumn.getCodewords().length; codewordsRow++) {
formatter.format("CW %3d:", codewordsRow);
for (int barcodeColumn = 0; barcodeColumn < barcodeColumnCount + 2; barcodeColumn++) {
if (detectionResultColumns[barcodeColumn] == null) {
if (detectionRXingResultColumns[barcodeColumn] == null) {
formatter.format(" | ");
continue;
}
Codeword codeword = detectionResultColumns[barcodeColumn].getCodewords()[codewordsRow];
Codeword codeword = detectionRXingResultColumns[barcodeColumn].getCodewords()[codewordsRow];
if (codeword == null) {
formatter.format(" | ");
continue;

4
src/pdf417/decoder/DetectionResultColumn.java
View File

@@ -21,14 +21,14 @@ import java.util.Formatter;
/**
* @author Guenther Grau
*/
class DetectionResultColumn {
class DetectionRXingResultColumn {
private static final int MAX_NEARBY_DISTANCE = 5;
private final BoundingBox boundingBox;
private final Codeword[] codewords;
DetectionResultColumn(BoundingBox boundingBox) {
DetectionRXingResultColumn(BoundingBox boundingBox) {
this.boundingBox = new BoundingBox(boundingBox);
codewords = new Codeword[boundingBox.getMaxY() - boundingBox.getMinY() + 1];
}

14
src/pdf417/decoder/DetectionResultRowIndicatorColumn.java
View File

@@ -16,17 +16,17 @@
package com.google.zxing.pdf417.decoder;
import com.google.zxing.ResultPoint;
import com.google.zxing.RXingResultPoint;
import com.google.zxing.pdf417.PDF417Common;
/**
* @author Guenther Grau
*/
final class DetectionResultRowIndicatorColumn extends DetectionResultColumn {
final class DetectionRXingResultRowIndicatorColumn extends DetectionRXingResultColumn {
private final boolean isLeft;
DetectionResultRowIndicatorColumn(BoundingBox boundingBox, boolean isLeft) {
DetectionRXingResultRowIndicatorColumn(BoundingBox boundingBox, boolean isLeft) {
super(boundingBox);
this.isLeft = isLeft;
}
@@ -48,8 +48,8 @@ final class DetectionResultRowIndicatorColumn extends DetectionResultColumn {
setRowNumbers();
removeIncorrectCodewords(codewords, barcodeMetadata);
BoundingBox boundingBox = getBoundingBox();
ResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();
ResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();
RXingResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();
RXingResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();
int firstRow = imageRowToCodewordIndex((int) top.getY());
int lastRow = imageRowToCodewordIndex((int) bottom.getY());
// We need to be careful using the average row height. Barcode could be skewed so that we have smaller and
@@ -127,8 +127,8 @@ final class DetectionResultRowIndicatorColumn extends DetectionResultColumn {
// use row height count to make detection of invalid row numbers more reliable
private void adjustIncompleteIndicatorColumnRowNumbers(BarcodeMetadata barcodeMetadata) {
BoundingBox boundingBox = getBoundingBox();
ResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();
ResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();
RXingResultPoint top = isLeft ? boundingBox.getTopLeft() : boundingBox.getTopRight();
RXingResultPoint bottom = isLeft ? boundingBox.getBottomLeft() : boundingBox.getBottomRight();
int firstRow = imageRowToCodewordIndex((int) top.getY());
int lastRow = imageRowToCodewordIndex((int) bottom.getY());
//float averageRowHeight = (lastRow - firstRow) / (float) barcodeMetadata.getRowCount();

136
src/pdf417/decoder/PDF417ScanningDecoder.java
View File

@@ -19,9 +19,9 @@ package com.google.zxing.pdf417.decoder;
import com.google.zxing.ChecksumException;
import com.google.zxing.FormatException;
import com.google.zxing.NotFoundException;
import com.google.zxing.ResultPoint;
import com.google.zxing.RXingResultPoint;
import com.google.zxing.common.BitMatrix;
import com.google.zxing.common.DecoderResult;
import com.google.zxing.common.DecoderRXingResult;
import com.google.zxing.common.detector.MathUtils;
import com.google.zxing.pdf417.PDF417Common;
import com.google.zxing.pdf417.decoder.ec.ErrorCorrection;
@@ -49,18 +49,18 @@ public final class PDF417ScanningDecoder {
// columns. That way width can be deducted from the pattern column.
// This approach also allows to detect more details about the barcode, e.g. if a bar type (white or black) is wider
// than it should be. This can happen if the scanner used a bad blackpoint.
public static DecoderResult decode(BitMatrix image,
ResultPoint imageTopLeft,
ResultPoint imageBottomLeft,
ResultPoint imageTopRight,
ResultPoint imageBottomRight,
public static DecoderRXingResult decode(BitMatrix image,
RXingResultPoint imageTopLeft,
RXingResultPoint imageBottomLeft,
RXingResultPoint imageTopRight,
RXingResultPoint imageBottomRight,
int minCodewordWidth,
int maxCodewordWidth)
throws NotFoundException, FormatException, ChecksumException {
BoundingBox boundingBox = new BoundingBox(image, imageTopLeft, imageBottomLeft, imageTopRight, imageBottomRight);
DetectionResultRowIndicatorColumn leftRowIndicatorColumn = null;
DetectionResultRowIndicatorColumn rightRowIndicatorColumn = null;
DetectionResult detectionResult;
DetectionRXingResultRowIndicatorColumn leftRowIndicatorColumn = null;
DetectionRXingResultRowIndicatorColumn rightRowIndicatorColumn = null;
DetectionRXingResult detectionRXingResult;
for (boolean firstPass = true; ; firstPass = false) {
if (imageTopLeft != null) {
leftRowIndicatorColumn = getRowIndicatorColumn(image, boundingBox, imageTopLeft, true, minCodewordWidth,
@@ -70,11 +70,11 @@ public final class PDF417ScanningDecoder {
rightRowIndicatorColumn = getRowIndicatorColumn(image, boundingBox, imageTopRight, false, minCodewordWidth,
maxCodewordWidth);
}
detectionResult = merge(leftRowIndicatorColumn, rightRowIndicatorColumn);
if (detectionResult == null) {
detectionRXingResult = merge(leftRowIndicatorColumn, rightRowIndicatorColumn);
if (detectionRXingResult == null) {
throw NotFoundException.getNotFoundInstance();
}
BoundingBox resultBox = detectionResult.getBoundingBox();
BoundingBox resultBox = detectionRXingResult.getBoundingBox();
if (firstPass && resultBox != null &&
(resultBox.getMinY() < boundingBox.getMinY() || resultBox.getMaxY() > boundingBox.getMaxY())) {
boundingBox = resultBox;
@@ -82,30 +82,30 @@ public final class PDF417ScanningDecoder {
break;
}
}
detectionResult.setBoundingBox(boundingBox);
int maxBarcodeColumn = detectionResult.getBarcodeColumnCount() + 1;
detectionResult.setDetectionResultColumn(0, leftRowIndicatorColumn);
detectionResult.setDetectionResultColumn(maxBarcodeColumn, rightRowIndicatorColumn);
detectionRXingResult.setBoundingBox(boundingBox);
int maxBarcodeColumn = detectionRXingResult.getBarcodeColumnCount() + 1;
detectionRXingResult.setDetectionRXingResultColumn(0, leftRowIndicatorColumn);
detectionRXingResult.setDetectionRXingResultColumn(maxBarcodeColumn, rightRowIndicatorColumn);
boolean leftToRight = leftRowIndicatorColumn != null;
for (int barcodeColumnCount = 1; barcodeColumnCount <= maxBarcodeColumn; barcodeColumnCount++) {
int barcodeColumn = leftToRight ? barcodeColumnCount : maxBarcodeColumn - barcodeColumnCount;
if (detectionResult.getDetectionResultColumn(barcodeColumn) != null) {
if (detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn) != null) {
// This will be the case for the opposite row indicator column, which doesn't need to be decoded again.
continue;
}
DetectionResultColumn detectionResultColumn;
DetectionRXingResultColumn detectionRXingResultColumn;
if (barcodeColumn == 0 || barcodeColumn == maxBarcodeColumn) {
detectionResultColumn = new DetectionResultRowIndicatorColumn(boundingBox, barcodeColumn == 0);
detectionRXingResultColumn = new DetectionRXingResultRowIndicatorColumn(boundingBox, barcodeColumn == 0);
} else {
detectionResultColumn = new DetectionResultColumn(boundingBox);
detectionRXingResultColumn = new DetectionRXingResultColumn(boundingBox);
}
detectionResult.setDetectionResultColumn(barcodeColumn, detectionResultColumn);
detectionRXingResult.setDetectionRXingResultColumn(barcodeColumn, detectionRXingResultColumn);
int startColumn = -1;
int previousStartColumn = startColumn;
// TODO start at a row for which we know the start position, then detect upwards and downwards from there.
for (int imageRow = boundingBox.getMinY(); imageRow <= boundingBox.getMaxY(); imageRow++) {
startColumn = getStartColumn(detectionResult, barcodeColumn, imageRow, leftToRight);
startColumn = getStartColumn(detectionRXingResult, barcodeColumn, imageRow, leftToRight);
if (startColumn < 0 || startColumn > boundingBox.getMaxX()) {
if (previousStartColumn == -1) {
continue;
@@ -115,18 +115,18 @@ public final class PDF417ScanningDecoder {
Codeword codeword = detectCodeword(image, boundingBox.getMinX(), boundingBox.getMaxX(), leftToRight,
startColumn, imageRow, minCodewordWidth, maxCodewordWidth);
if (codeword != null) {
detectionResultColumn.setCodeword(imageRow, codeword);
detectionRXingResultColumn.setCodeword(imageRow, codeword);
previousStartColumn = startColumn;
minCodewordWidth = Math.min(minCodewordWidth, codeword.getWidth());
maxCodewordWidth = Math.max(maxCodewordWidth, codeword.getWidth());
}
}
}
return createDecoderResult(detectionResult);
return createDecoderRXingResult(detectionRXingResult);
}
private static DetectionResult merge(DetectionResultRowIndicatorColumn leftRowIndicatorColumn,
DetectionResultRowIndicatorColumn rightRowIndicatorColumn)
private static DetectionRXingResult merge(DetectionRXingResultRowIndicatorColumn leftRowIndicatorColumn,
DetectionRXingResultRowIndicatorColumn rightRowIndicatorColumn)
throws NotFoundException {
if (leftRowIndicatorColumn == null && rightRowIndicatorColumn == null) {
return null;
@@ -137,10 +137,10 @@ public final class PDF417ScanningDecoder {
}
BoundingBox boundingBox = BoundingBox.merge(adjustBoundingBox(leftRowIndicatorColumn),
adjustBoundingBox(rightRowIndicatorColumn));
return new DetectionResult(barcodeMetadata, boundingBox);
return new DetectionRXingResult(barcodeMetadata, boundingBox);
}
private static BoundingBox adjustBoundingBox(DetectionResultRowIndicatorColumn rowIndicatorColumn)
private static BoundingBox adjustBoundingBox(DetectionRXingResultRowIndicatorColumn rowIndicatorColumn)
throws NotFoundException {
if (rowIndicatorColumn == null) {
return null;
@@ -183,8 +183,8 @@ public final class PDF417ScanningDecoder {
return maxValue;
}
private static BarcodeMetadata getBarcodeMetadata(DetectionResultRowIndicatorColumn leftRowIndicatorColumn,
DetectionResultRowIndicatorColumn rightRowIndicatorColumn) {
private static BarcodeMetadata getBarcodeMetadata(DetectionRXingResultRowIndicatorColumn leftRowIndicatorColumn,
DetectionRXingResultRowIndicatorColumn rightRowIndicatorColumn) {
BarcodeMetadata leftBarcodeMetadata;
if (leftRowIndicatorColumn == null ||
(leftBarcodeMetadata = leftRowIndicatorColumn.getBarcodeMetadata()) == null) {
@@ -204,13 +204,13 @@ public final class PDF417ScanningDecoder {
return leftBarcodeMetadata;
}
private static DetectionResultRowIndicatorColumn getRowIndicatorColumn(BitMatrix image,
private static DetectionRXingResultRowIndicatorColumn getRowIndicatorColumn(BitMatrix image,
BoundingBox boundingBox,
ResultPoint startPoint,
RXingResultPoint startPoint,
boolean leftToRight,
int minCodewordWidth,
int maxCodewordWidth) {
DetectionResultRowIndicatorColumn rowIndicatorColumn = new DetectionResultRowIndicatorColumn(boundingBox,
DetectionRXingResultRowIndicatorColumn rowIndicatorColumn = new DetectionRXingResultRowIndicatorColumn(boundingBox,
leftToRight);
for (int i = 0; i < 2; i++) {
int increment = i == 0 ? 1 : -1;
@@ -232,13 +232,13 @@ public final class PDF417ScanningDecoder {
return rowIndicatorColumn;
}
private static void adjustCodewordCount(DetectionResult detectionResult, BarcodeValue[][] barcodeMatrix)
private static void adjustCodewordCount(DetectionRXingResult detectionRXingResult, BarcodeValue[][] barcodeMatrix)
throws NotFoundException {
BarcodeValue barcodeMatrix01 = barcodeMatrix[0][1];
int[] numberOfCodewords = barcodeMatrix01.getValue();
int calculatedNumberOfCodewords = detectionResult.getBarcodeColumnCount() *
detectionResult.getBarcodeRowCount() -
getNumberOfECCodeWords(detectionResult.getBarcodeECLevel());
int calculatedNumberOfCodewords = detectionRXingResult.getBarcodeColumnCount() *
detectionRXingResult.getBarcodeRowCount() -
getNumberOfECCodeWords(detectionRXingResult.getBarcodeECLevel());
if (numberOfCodewords.length == 0) {
if (calculatedNumberOfCodewords < 1 || calculatedNumberOfCodewords > PDF417Common.MAX_CODEWORDS_IN_BARCODE) {
throw NotFoundException.getNotFoundInstance();
@@ -252,18 +252,18 @@ public final class PDF417ScanningDecoder {
}
}
private static DecoderResult createDecoderResult(DetectionResult detectionResult) throws FormatException,
private static DecoderRXingResult createDecoderRXingResult(DetectionRXingResult detectionRXingResult) throws FormatException,
ChecksumException, NotFoundException {
BarcodeValue[][] barcodeMatrix = createBarcodeMatrix(detectionResult);
adjustCodewordCount(detectionResult, barcodeMatrix);
BarcodeValue[][] barcodeMatrix = createBarcodeMatrix(detectionRXingResult);
adjustCodewordCount(detectionRXingResult, barcodeMatrix);
Collection<Integer> erasures = new ArrayList<>();
int[] codewords = new int[detectionResult.getBarcodeRowCount() * detectionResult.getBarcodeColumnCount()];
int[] codewords = new int[detectionRXingResult.getBarcodeRowCount() * detectionRXingResult.getBarcodeColumnCount()];
List<int[]> ambiguousIndexValuesList = new ArrayList<>();
Collection<Integer> ambiguousIndexesList = new ArrayList<>();
for (int row = 0; row < detectionResult.getBarcodeRowCount(); row++) {
for (int column = 0; column < detectionResult.getBarcodeColumnCount(); column++) {
for (int row = 0; row < detectionRXingResult.getBarcodeRowCount(); row++) {
for (int column = 0; column < detectionRXingResult.getBarcodeColumnCount(); column++) {
int[] values = barcodeMatrix[row][column + 1].getValue();
int codewordIndex = row * detectionResult.getBarcodeColumnCount() + column;
int codewordIndex = row * detectionRXingResult.getBarcodeColumnCount() + column;
if (values.length == 0) {
erasures.add(codewordIndex);
} else if (values.length == 1) {
@@ -278,7 +278,7 @@ public final class PDF417ScanningDecoder {
for (int i = 0; i < ambiguousIndexValues.length; i++) {
ambiguousIndexValues[i] = ambiguousIndexValuesList.get(i);
}
return createDecoderResultFromAmbiguousValues(detectionResult.getBarcodeECLevel(), codewords,
return createDecoderRXingResultFromAmbiguousValues(detectionRXingResult.getBarcodeECLevel(), codewords,
PDF417Common.toIntArray(erasures), PDF417Common.toIntArray(ambiguousIndexesList), ambiguousIndexValues);
}
@@ -295,7 +295,7 @@ public final class PDF417ScanningDecoder {
* @param ambiguousIndexValues two dimensional array that contains the ambiguous values. The first dimension must
* be the same length as the ambiguousIndexes array
*/
private static DecoderResult createDecoderResultFromAmbiguousValues(int ecLevel,
private static DecoderRXingResult createDecoderRXingResultFromAmbiguousValues(int ecLevel,
int[] codewords,
int[] erasureArray,
int[] ambiguousIndexes,
@@ -331,9 +331,9 @@ public final class PDF417ScanningDecoder {
throw ChecksumException.getChecksumInstance();
}
private static BarcodeValue[][] createBarcodeMatrix(DetectionResult detectionResult) {
private static BarcodeValue[][] createBarcodeMatrix(DetectionRXingResult detectionRXingResult) {
BarcodeValue[][] barcodeMatrix =
new BarcodeValue[detectionResult.getBarcodeRowCount()][detectionResult.getBarcodeColumnCount() + 2];
new BarcodeValue[detectionRXingResult.getBarcodeRowCount()][detectionRXingResult.getBarcodeColumnCount() + 2];
for (int row = 0; row < barcodeMatrix.length; row++) {
for (int column = 0; column < barcodeMatrix[row].length; column++) {
barcodeMatrix[row][column] = new BarcodeValue();
@@ -341,9 +341,9 @@ public final class PDF417ScanningDecoder {
}
int column = 0;
for (DetectionResultColumn detectionResultColumn : detectionResult.getDetectionResultColumns()) {
if (detectionResultColumn != null) {
for (Codeword codeword : detectionResultColumn.getCodewords()) {
for (DetectionRXingResultColumn detectionRXingResultColumn : detectionRXingResult.getDetectionRXingResultColumns()) {
if (detectionRXingResultColumn != null) {
for (Codeword codeword : detectionRXingResultColumn.getCodewords()) {
if (codeword != null) {
int rowNumber = codeword.getRowNumber();
if (rowNumber >= 0) {
@@ -361,37 +361,37 @@ public final class PDF417ScanningDecoder {
return barcodeMatrix;
}
private static boolean isValidBarcodeColumn(DetectionResult detectionResult, int barcodeColumn) {
return barcodeColumn >= 0 && barcodeColumn <= detectionResult.getBarcodeColumnCount() + 1;
private static boolean isValidBarcodeColumn(DetectionRXingResult detectionRXingResult, int barcodeColumn) {
return barcodeColumn >= 0 && barcodeColumn <= detectionRXingResult.getBarcodeColumnCount() + 1;
}
private static int getStartColumn(DetectionResult detectionResult,
private static int getStartColumn(DetectionRXingResult detectionRXingResult,
int barcodeColumn,
int imageRow,
boolean leftToRight) {
int offset = leftToRight ? 1 : -1;
Codeword codeword = null;
if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
codeword = detectionResult.getDetectionResultColumn(barcodeColumn - offset).getCodeword(imageRow);
if (isValidBarcodeColumn(detectionRXingResult, barcodeColumn - offset)) {
codeword = detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn - offset).getCodeword(imageRow);
}
if (codeword != null) {
return leftToRight ? codeword.getEndX() : codeword.getStartX();
}
codeword = detectionResult.getDetectionResultColumn(barcodeColumn).getCodewordNearby(imageRow);
codeword = detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn).getCodewordNearby(imageRow);
if (codeword != null) {
return leftToRight ? codeword.getStartX() : codeword.getEndX();
}
if (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
codeword = detectionResult.getDetectionResultColumn(barcodeColumn - offset).getCodewordNearby(imageRow);
if (isValidBarcodeColumn(detectionRXingResult, barcodeColumn - offset)) {
codeword = detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn - offset).getCodewordNearby(imageRow);
}
if (codeword != null) {
return leftToRight ? codeword.getEndX() : codeword.getStartX();
}
int skippedColumns = 0;
while (isValidBarcodeColumn(detectionResult, barcodeColumn - offset)) {
while (isValidBarcodeColumn(detectionRXingResult, barcodeColumn - offset)) {
barcodeColumn -= offset;
for (Codeword previousRowCodeword : detectionResult.getDetectionResultColumn(barcodeColumn).getCodewords()) {
for (Codeword previousRowCodeword : detectionRXingResult.getDetectionRXingResultColumn(barcodeColumn).getCodewords()) {
if (previousRowCodeword != null) {
return (leftToRight ? previousRowCodeword.getEndX() : previousRowCodeword.getStartX()) +
offset *
@@ -401,7 +401,7 @@ public final class PDF417ScanningDecoder {
}
skippedColumns++;
}
return leftToRight ? detectionResult.getBoundingBox().getMinX() : detectionResult.getBoundingBox().getMaxX();
return leftToRight ? detectionRXingResult.getBoundingBox().getMinX() : detectionRXingResult.getBoundingBox().getMaxX();
}
private static Codeword detectCodeword(BitMatrix image,
@@ -523,7 +523,7 @@ public final class PDF417ScanningDecoder {
codewordSize <= maxCodewordWidth + CODEWORD_SKEW_SIZE;
}
private static DecoderResult decodeCodewords(int[] codewords, int ecLevel, int[] erasures) throws FormatException,
private static DecoderRXingResult decodeCodewords(int[] codewords, int ecLevel, int[] erasures) throws FormatException,
ChecksumException {
if (codewords.length == 0) {
throw FormatException.getFormatInstance();
@@ -534,10 +534,10 @@ public final class PDF417ScanningDecoder {
verifyCodewordCount(codewords, numECCodewords);
// Decode the codewords
DecoderResult decoderResult = DecodedBitStreamParser.decode(codewords, String.valueOf(ecLevel));
decoderResult.setErrorsCorrected(correctedErrorsCount);
decoderResult.setErasures(erasures.length);
return decoderResult;
DecoderRXingResult decoderRXingResult = DecodedBitStreamParser.decode(codewords, String.valueOf(ecLevel));
decoderRXingResult.setErrorsCorrected(correctedErrorsCount);
decoderRXingResult.setErasures(erasures.length);
return decoderRXingResult;
}
/**