mudhorn/zxing
1
0
Fork 0
mirror of https://github.com/zxing/zxing.git synced 2025-03-05 20:48:51 -08:00
Code Issues Actions Packages Projects Releases Wiki Activity

Some formatting changes, and a few tiny optimizations

Browse source 
git-svn-id: https://zxing.googlecode.com/svn/trunk@767 59b500cc-1b3d-0410-9834-0bbf25fbcc57
This commit is contained in:
srowen 2008-12-01 21:36:58 +00:00
parent 7f5c93a71d
commit 36e9361184
1 changed files with 263 additions and 291 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

176
core/src/com/google/zxing/oned/ITFReader.java
View file

@ -26,25 +26,18 @@ import com.google.zxing.common.GenericResultPoint;
import java.util.Hashtable; import java.util.Hashtable;
/** /**
*<p> * <p>Implements decoding of the ITF format.</p>
* Implements decoding of the ITF format.
* </p>
*<p>
* "ITF" stands for Interleaved Two of Five. This Reader will scan ITF barcode with 6, 10 or 14 digits.
* The checksum is optional and is not applied by this Reader. The consumer of the decoded value will have to apply a checksum if
* required.
* </p>
* *
*<p> * <p>"ITF" stands for Interleaved Two of Five. This Reader will scan ITF barcode with 6, 10 or 14 digits.
* <a * The checksum is optional and is not applied by this Reader. The consumer of the decoded value
* href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia. * will have to apply a checksum if required.</p>
* org/wiki/Interleaved_2_of_5</a> is a great reference for Interleaved 2 of 5 *
* information. * <p><a href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia.org/wiki/Interleaved_2_of_5</a>
* </p> * is a great reference for Interleaved 2 of 5 information.</p>
* *
* @author kevin.osullivan@sita.aero, SITA Lab. * @author kevin.osullivan@sita.aero, SITA Lab.
*/ */
public class ITFReader extends AbstractOneDReader { public final class ITFReader extends AbstractOneDReader {
private static final int MAX_AVG_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f); private static final int MAX_AVG_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
private static final int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f); private static final int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
@ -61,60 +54,57 @@ public class ITFReader extends AbstractOneDReader {
* Note: The end pattern is reversed because the row is reversed before * Note: The end pattern is reversed because the row is reversed before
* searching for the END_PATTERN * searching for the END_PATTERN
*/ */
private static final int[] START_PATTERN = { N, N, N, N }; private static final int[] START_PATTERN = {N, N, N, N};
private static final int[] END_PATTERN_REVERSED = { N, N, W }; private static final int[] END_PATTERN_REVERSED = {N, N, W};
/** /**
* Patterns of Wide / Narrow lines to indicate each digit * Patterns of Wide / Narrow lines to indicate each digit
*/ */
static final int[][] PATTERNS = { { N, N, W, W, N }, // 0 static final int[][] PATTERNS = {
{ W, N, N, N, W }, // 1 {N, N, W, W, N}, // 0
{ N, W, N, N, W }, // 2 {W, N, N, N, W}, // 1
{ W, W, N, N, N }, // 3 {N, W, N, N, W}, // 2
{ N, N, W, N, W }, // 4 {W, W, N, N, N}, // 3
{ W, N, W, N, N }, // 5 {N, N, W, N, W}, // 4
{ N, W, W, N, N }, // 6 {W, N, W, N, N}, // 5
{ N, N, N, W, W }, // 7 {N, W, W, N, N}, // 6
{ W, N, N, W, N }, // 8 {N, N, N, W, W}, // 7
{ N, W, N, W, N } // 9 {W, N, N, W, N}, // 8
{N, W, N, W, N} // 9
}; };
public final Result decodeRow(int rowNumber, BitArray row, Hashtable hints) throws ReaderException { public final Result decodeRow(int rowNumber, BitArray row, Hashtable hints) throws ReaderException {
StringBuffer result = new StringBuffer(20); StringBuffer result = new StringBuffer(20);
/** // Find out where the Middle section (payload) starts & ends
* Find out where the Middle section (payload) starts & ends
*/
int[] startRange = decodeStart(row); int[] startRange = decodeStart(row);
int[] endRange = decodeEnd(row); int[] endRange = decodeEnd(row);
decodeMiddle(row, startRange[1], endRange[0], result); decodeMiddle(row, startRange[1], endRange[0], result);
String resultString = result.toString(); String resultString = result.toString();
/**
* To avoid false positives with 2D barcodes (and other patterns), make
* an assumption that the decoded string must be 6, 10 or 14 digits.
*/
if ((resultString.length() != 6 && resultString.length() != 10 && resultString.length() != 14) ||
resultString.length() % 2 == 1)
throw ReaderException.getInstance();
return new Result(resultString, // To avoid false positives with 2D barcodes (and other patterns), make
// an assumption that the decoded string must be 6, 10 or 14 digits.
int length = resultString.length();
if (length != 6 && length != 10 && length != 14) {
throw ReaderException.getInstance();
}
return new Result(
resultString,
null, // no natural byte representation for these barcodes null, // no natural byte representation for these barcodes
new ResultPoint[] { new GenericResultPoint(startRange[1], (float) rowNumber), new GenericResultPoint(startRange[0], (float) rowNumber) }, new ResultPoint[] { new GenericResultPoint(startRange[1], (float) rowNumber),
new GenericResultPoint(startRange[0], (float) rowNumber)},
BarcodeFormat.ITF); BarcodeFormat.ITF);
} }
/** /**
* @param row * @param row row of black/white values to search
* row of black/white values to search * @param payloadStart offset of start pattern
* @param payloadStart * @param resultString {@link StringBuffer} to append decoded chars to
* offset of start pattern * @throws ReaderException if decoding could not complete successfully
* @param resultString
* {@link StringBuffer} to append decoded chars to
* @throws ReaderException
* if decoding could not complete successfully
*/ */
protected void decodeMiddle(BitArray row, int payloadStart, int payloadEnd, StringBuffer resultString) throws ReaderException { protected void decodeMiddle(BitArray row, int payloadStart, int payloadEnd, StringBuffer resultString) throws ReaderException {
@ -127,14 +117,15 @@ public class ITFReader extends AbstractOneDReader {
int[] counterBlack = new int[5]; int[] counterBlack = new int[5];
int[] counterWhite = new int[5]; int[] counterWhite = new int[5];
for (int x = 0; payloadStart < payloadEnd; x++) { while (payloadStart < payloadEnd) {
// Get 10 runs of black/white. // Get 10 runs of black/white.
recordPattern(row, payloadStart, counterDigitPair); recordPattern(row, payloadStart, counterDigitPair);
// Split them into each array // Split them into each array
for (int k = 0; k < 5; k++) { for (int k = 0; k < 5; k++) {
counterBlack[k] = counterDigitPair[k * 2]; int twoK = k << 1;
counterWhite[k] = counterDigitPair[(k * 2) + 1]; counterBlack[k] = counterDigitPair[twoK];
counterWhite[k] = counterDigitPair[twoK + 1];
} }
int bestMatch = decodeDigit(counterBlack); int bestMatch = decodeDigit(counterBlack);
@ -151,8 +142,7 @@ public class ITFReader extends AbstractOneDReader {
/** /**
* Identify where the start of the middle / payload section starts. * Identify where the start of the middle / payload section starts.
* *
* @param row * @param row row of black/white values to search
* row of black/white values to search
* @return Array, containing index of start of 'start block' and end of * @return Array, containing index of start of 'start block' and end of
* 'start block' * 'start block'
* @throws ReaderException * @throws ReaderException
@ -161,12 +151,10 @@ public class ITFReader extends AbstractOneDReader {
int endStart = skipWhiteSpace(row); int endStart = skipWhiteSpace(row);
int startPattern[] = findGuardPattern(row, endStart, START_PATTERN); int startPattern[] = findGuardPattern(row, endStart, START_PATTERN);
/** // Determine the width of a narrow line in pixels. We can do this by
* Determine the width of a narrow line in pixels. We can do this by // getting the width of the start pattern and dividing by 4 because its
* getting the width of the start pattern and dividing by 4 because its // made up of 4 narrow lines.
* made up of 4 narrow lines. this.narrowLineWidth = (startPattern[1] - startPattern[0]) >> 2;
*/
this.narrowLineWidth = (startPattern[1] - startPattern[0]) / 4;
validateQuietZone(row, startPattern[0]); validateQuietZone(row, startPattern[0]);
@ -174,7 +162,6 @@ public class ITFReader extends AbstractOneDReader {
} }
/** /**
*
* The start & end patterns must be pre/post fixed by a quiet zone. This * The start & end patterns must be pre/post fixed by a quiet zone. This
* zone must be at least 10 times the width of a narrow line. Scan back until * zone must be at least 10 times the width of a narrow line. Scan back until
* we either get to the start of the barcode or match the necessary number of * we either get to the start of the barcode or match the necessary number of
@ -185,23 +172,21 @@ public class ITFReader extends AbstractOneDReader {
* *
* ref: http://www.barcode-1.net/i25code.html * ref: http://www.barcode-1.net/i25code.html
* *
* @param row - The bit array representing the scanned barcode. * @param row bit array representing the scanned barcode.
* @param startPattern - The index into row of the start or end pattern. * @param startPattern index into row of the start or end pattern.
* @throws ReaderException - If the quiet zone cannot be found, a ReaderException is thrown. * @throws ReaderException if the quiet zone cannot be found, a ReaderException is thrown.
*/ */
private void validateQuietZone(BitArray row, int startPattern) throws ReaderException { private void validateQuietZone(BitArray row, int startPattern) throws ReaderException {
int quietCount=this.narrowLineWidth * 10; // expect to find this many pixels of quiet zone int quietCount = this.narrowLineWidth * 10; // expect to find this many pixels of quiet zone
int i=0; for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
for (i=startPattern-1; quietCount>0 && i>=0; i--) if (row.get(i)) {
{
if (row.get(i)==true)
break; break;
}
quietCount--; quietCount--;
} }
if (quietCount!=0) if (quietCount != 0) {
{
// Unable to find the necessary number of quiet zone pixels. // Unable to find the necessary number of quiet zone pixels.
throw ReaderException.getInstance(); throw ReaderException.getInstance();
} }
@ -210,11 +195,9 @@ public class ITFReader extends AbstractOneDReader {
/** /**
* Skip all whitespace until we get to the first black line. * Skip all whitespace until we get to the first black line.
* *
* @param row * @param row row of black/white values to search
* row of black/white values to search
* @return index of the first black line. * @return index of the first black line.
* @throws ReaderException * @throws ReaderException Throws exception if no black lines are found in the row
* Throws exception if no black lines are found in the row
*/ */
private int skipWhiteSpace(BitArray row) throws ReaderException { private int skipWhiteSpace(BitArray row) throws ReaderException {
int width = row.getSize(); int width = row.getSize();
@ -225,8 +208,9 @@ public class ITFReader extends AbstractOneDReader {
} }
endStart++; endStart++;
} }
if (endStart == width) if (endStart == width) {
throw ReaderException.getInstance(); throw ReaderException.getInstance();
}
return endStart; return endStart;
} }
@ -234,8 +218,7 @@ public class ITFReader extends AbstractOneDReader {
/** /**
* Identify where the end of the middle / payload section ends. * Identify where the end of the middle / payload section ends.
* *
* @param row * @param row row of black/white values to search
* row of black/white values to search
* @return Array, containing index of start of 'end block' and end of 'end * @return Array, containing index of start of 'end block' and end of 'end
* block' * block'
* @throws ReaderException * @throws ReaderException
@ -248,7 +231,7 @@ public class ITFReader extends AbstractOneDReader {
row.reverse(); row.reverse();
int endStart = skipWhiteSpace(row); int endStart = skipWhiteSpace(row);
int endPattern[] = null; int endPattern[];
try { try {
endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED); endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);
} catch (ReaderException e) { } catch (ReaderException e) {
@ -257,13 +240,9 @@ public class ITFReader extends AbstractOneDReader {
throw e; throw e;
} }
/** // The start & end patterns must be pre/post fixed by a quiet zone. This
* The start & end patterns must be pre/post fixed by a quiet zone. This // zone must be at least 10 times the width of a narrow line.
* zone must be at least 10 times the width of a narrow line. // ref: http://www.barcode-1.net/i25code.html
*
* ref: http://www.barcode-1.net/i25code.html
*/
validateQuietZone(row, endPattern[0]); validateQuietZone(row, endPattern[0]);
// Now recalc the indicies of where the 'endblock' starts & stops to // Now recalc the indicies of where the 'endblock' starts & stops to
@ -279,22 +258,19 @@ public class ITFReader extends AbstractOneDReader {
} }
/** /**
* @param row * @param row row of black/white values to search
* row of black/white values to search * @param rowOffset position to start search
* @param rowOffset * @param pattern pattern of counts of number of black and white pixels that are
* position to start search
* @param pattern
* pattern of counts of number of black and white pixels that are
* being searched for as a pattern * being searched for as a pattern
* @return start/end horizontal offset of guard pattern, as an array of two * @return start/end horizontal offset of guard pattern, as an array of two
* ints * ints
* @throws ReaderException * @throws ReaderException if pattern is not found
* if pattern is not found
*
* TODO: This is very similar to implementation in AbstractUPCEANReader. Consider if they can be merged to
* a single method.
*/ */
int[] findGuardPattern(BitArray row, int rowOffset, int[] pattern) throws ReaderException { int[] findGuardPattern(BitArray row, int rowOffset, int[] pattern) throws ReaderException {
// TODO: This is very similar to implementation in AbstractUPCEANReader. Consider if they can be merged to
// a single method.
int patternLength = pattern.length; int patternLength = pattern.length;
int[] counters = new int[patternLength]; int[] counters = new int[patternLength];
int width = row.getSize(); int width = row.getSize();
@ -309,7 +285,7 @@ public class ITFReader extends AbstractOneDReader {
} else { } else {
if (counterPosition == patternLength - 1) { if (counterPosition == patternLength - 1) {
if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) { if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
return new int[] { patternStart, x }; return new int[]{patternStart, x};
} }
patternStart += counters[0] + counters[1]; patternStart += counters[0] + counters[1];
for (int y = 2; y < patternLength; y++) { for (int y = 2; y < patternLength; y++) {
@ -332,13 +308,9 @@ public class ITFReader extends AbstractOneDReader {
* Attempts to decode a sequence of ITF black/white lines into single * Attempts to decode a sequence of ITF black/white lines into single
* digit. * digit.
* *
* @param counters * @param counters the counts of runs of observed black/white/black/... values
* the counts of runs of observed black/white/black/... values
*
* @return The decoded digit * @return The decoded digit
* * @throws ReaderException if digit cannot be decoded
* @throws ReaderException
* if digit cannot be decoded
*/ */
static int decodeDigit(int[] counters) throws ReaderException { static int decodeDigit(int[] counters) throws ReaderException {