mirror of
https://github.com/zxing/zxing.git
synced 2024-09-20 21:47:32 -07:00
d4efd44fb0
git-svn-id: https://zxing.googlecode.com/svn/trunk@1202 59b500cc-1b3d-0410-9834-0bbf25fbcc57
382 lines
14 KiB
C#
Executable file
382 lines
14 KiB
C#
Executable file
/*
|
|
* 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.
|
|
*/
|
|
using System;
|
|
using BarcodeFormat = com.google.zxing.BarcodeFormat;
|
|
using DecodeHintType = com.google.zxing.DecodeHintType;
|
|
using ReaderException = com.google.zxing.ReaderException;
|
|
using Result = com.google.zxing.Result;
|
|
using ResultPoint = com.google.zxing.ResultPoint;
|
|
using BitArray = com.google.zxing.common.BitArray;
|
|
namespace com.google.zxing.oned
|
|
{
|
|
|
|
/// <summary> <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><a href="http://en.wikipedia.org/wiki/Interleaved_2_of_5">http://en.wikipedia.org/wiki/Interleaved_2_of_5</a>
|
|
/// is a great reference for Interleaved 2 of 5 information.</p>
|
|
///
|
|
/// </summary>
|
|
/// <author> kevin.osullivan@sita.aero, SITA Lab.
|
|
/// </author>
|
|
/// <author>www.Redivivus.in (suraj.supekar@redivivus.in) - Ported from ZXING Java Source
|
|
/// </author>
|
|
public sealed class ITFReader:OneDReader
|
|
{
|
|
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'MAX_AVG_VARIANCE '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
|
|
private static readonly int MAX_AVG_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.42f);
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'MAX_INDIVIDUAL_VARIANCE '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
|
|
private static readonly int MAX_INDIVIDUAL_VARIANCE = (int) (PATTERN_MATCH_RESULT_SCALE_FACTOR * 0.8f);
|
|
|
|
private const int W = 3; // Pixel width of a wide line
|
|
private const int N = 1; // Pixed width of a narrow line
|
|
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'DEFAULT_ALLOWED_LENGTHS'. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
private static readonly int[] DEFAULT_ALLOWED_LENGTHS = new int[]{6, 10, 14, 44};
|
|
|
|
// Stores the actual narrow line width of the image being decoded.
|
|
private int narrowLineWidth = - 1;
|
|
|
|
/// <summary> Start/end guard pattern.
|
|
///
|
|
/// Note: The end pattern is reversed because the row is reversed before
|
|
/// searching for the END_PATTERN
|
|
/// </summary>
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'START_PATTERN '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
private static readonly int[] START_PATTERN = new int[]{N, N, N, N};
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'END_PATTERN_REVERSED '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
private static readonly int[] END_PATTERN_REVERSED = new int[]{N, N, W};
|
|
|
|
/// <summary> Patterns of Wide / Narrow lines to indicate each digit</summary>
|
|
//UPGRADE_NOTE: Final was removed from the declaration of 'PATTERNS '. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1003'"
|
|
private static readonly int[][] PATTERNS = new int[][]{new int[]{N, N, W, W, N}, new int[]{W, N, N, N, W}, new int[]{N, W, N, N, W}, new int[]{W, W, N, N, N}, new int[]{N, N, W, N, W}, new int[]{W, N, W, N, N}, new int[]{N, W, W, N, N}, new int[]{N, N, N, W, W}, new int[]{W, N, N, W, N}, new int[]{N, W, N, W, N}};
|
|
|
|
public override Result decodeRow(int rowNumber, BitArray row, System.Collections.Hashtable hints)
|
|
{
|
|
|
|
// Find out where the Middle section (payload) starts & ends
|
|
int[] startRange = decodeStart(row);
|
|
int[] endRange = decodeEnd(row);
|
|
|
|
System.Text.StringBuilder result = new System.Text.StringBuilder(20);
|
|
decodeMiddle(row, startRange[1], endRange[0], result);
|
|
System.String resultString = result.ToString();
|
|
|
|
int[] allowedLengths = null;
|
|
if (hints != null)
|
|
{
|
|
allowedLengths = (int[]) hints[DecodeHintType.ALLOWED_LENGTHS];
|
|
}
|
|
if (allowedLengths == null)
|
|
{
|
|
allowedLengths = DEFAULT_ALLOWED_LENGTHS;
|
|
}
|
|
|
|
// 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;
|
|
bool lengthOK = false;
|
|
for (int i = 0; i < allowedLengths.Length; i++)
|
|
{
|
|
if (length == allowedLengths[i])
|
|
{
|
|
lengthOK = true;
|
|
break;
|
|
}
|
|
}
|
|
if (!lengthOK)
|
|
{
|
|
throw ReaderException.Instance;
|
|
}
|
|
|
|
//UPGRADE_WARNING: Data types in Visual C# might be different. Verify the accuracy of narrowing conversions. "ms-help://MS.VSCC.v80/dv_commoner/local/redirect.htm?index='!DefaultContextWindowIndex'&keyword='jlca1042'"
|
|
return new Result(resultString, null, new ResultPoint[]{new ResultPoint(startRange[1], (float) rowNumber), new ResultPoint(endRange[0], (float) rowNumber)}, BarcodeFormat.ITF);
|
|
}
|
|
|
|
/// <param name="row"> row of black/white values to search
|
|
/// </param>
|
|
/// <param name="payloadStart">offset of start pattern
|
|
/// </param>
|
|
/// <param name="resultString">{@link StringBuffer} to append decoded chars to
|
|
/// </param>
|
|
/// <throws> ReaderException if decoding could not complete successfully </throws>
|
|
private static void decodeMiddle(BitArray row, int payloadStart, int payloadEnd, System.Text.StringBuilder resultString)
|
|
{
|
|
|
|
// Digits are interleaved in pairs - 5 black lines for one digit, and the
|
|
// 5
|
|
// interleaved white lines for the second digit.
|
|
// Therefore, need to scan 10 lines and then
|
|
// split these into two arrays
|
|
int[] counterDigitPair = new int[10];
|
|
int[] counterBlack = new int[5];
|
|
int[] counterWhite = new int[5];
|
|
|
|
while (payloadStart < payloadEnd)
|
|
{
|
|
|
|
// Get 10 runs of black/white.
|
|
recordPattern(row, payloadStart, counterDigitPair);
|
|
// Split them into each array
|
|
for (int k = 0; k < 5; k++)
|
|
{
|
|
int twoK = k << 1;
|
|
counterBlack[k] = counterDigitPair[twoK];
|
|
counterWhite[k] = counterDigitPair[twoK + 1];
|
|
}
|
|
|
|
int bestMatch = decodeDigit(counterBlack);
|
|
resultString.Append((char) ('0' + bestMatch));
|
|
bestMatch = decodeDigit(counterWhite);
|
|
resultString.Append((char) ('0' + bestMatch));
|
|
|
|
for (int i = 0; i < counterDigitPair.Length; i++)
|
|
{
|
|
payloadStart += counterDigitPair[i];
|
|
}
|
|
}
|
|
}
|
|
|
|
/// <summary> Identify where the start of the middle / payload section starts.
|
|
///
|
|
/// </summary>
|
|
/// <param name="row">row of black/white values to search
|
|
/// </param>
|
|
/// <returns> Array, containing index of start of 'start block' and end of
|
|
/// 'start block'
|
|
/// </returns>
|
|
/// <throws> ReaderException </throws>
|
|
internal int[] decodeStart(BitArray row)
|
|
{
|
|
int endStart = skipWhiteSpace(row);
|
|
int[] startPattern = findGuardPattern(row, endStart, START_PATTERN);
|
|
|
|
// 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
|
|
// made up of 4 narrow lines.
|
|
this.narrowLineWidth = (startPattern[1] - startPattern[0]) >> 2;
|
|
|
|
validateQuietZone(row, startPattern[0]);
|
|
|
|
return startPattern;
|
|
}
|
|
|
|
/// <summary> 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
|
|
/// we either get to the start of the barcode or match the necessary number of
|
|
/// quiet zone pixels.
|
|
///
|
|
/// Note: Its assumed the row is reversed when using this method to find
|
|
/// quiet zone after the end pattern.
|
|
///
|
|
/// ref: http://www.barcode-1.net/i25code.html
|
|
///
|
|
/// </summary>
|
|
/// <param name="row">bit array representing the scanned barcode.
|
|
/// </param>
|
|
/// <param name="startPattern">index into row of the start or end pattern.
|
|
/// </param>
|
|
/// <throws> ReaderException if the quiet zone cannot be found, a ReaderException is thrown. </throws>
|
|
private void validateQuietZone(BitArray row, int startPattern)
|
|
{
|
|
|
|
int quietCount = this.narrowLineWidth * 10; // expect to find this many pixels of quiet zone
|
|
|
|
for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--)
|
|
{
|
|
if (row.get_Renamed(i))
|
|
{
|
|
break;
|
|
}
|
|
quietCount--;
|
|
}
|
|
if (quietCount != 0)
|
|
{
|
|
// Unable to find the necessary number of quiet zone pixels.
|
|
throw ReaderException.Instance;
|
|
}
|
|
}
|
|
|
|
/// <summary> Skip all whitespace until we get to the first black line.
|
|
///
|
|
/// </summary>
|
|
/// <param name="row">row of black/white values to search
|
|
/// </param>
|
|
/// <returns> index of the first black line.
|
|
/// </returns>
|
|
/// <throws> ReaderException Throws exception if no black lines are found in the row </throws>
|
|
private static int skipWhiteSpace(BitArray row)
|
|
{
|
|
int width = row.Size;
|
|
int endStart = 0;
|
|
while (endStart < width)
|
|
{
|
|
if (row.get_Renamed(endStart))
|
|
{
|
|
break;
|
|
}
|
|
endStart++;
|
|
}
|
|
if (endStart == width)
|
|
{
|
|
throw ReaderException.Instance;
|
|
}
|
|
|
|
return endStart;
|
|
}
|
|
|
|
/// <summary> Identify where the end of the middle / payload section ends.
|
|
///
|
|
/// </summary>
|
|
/// <param name="row">row of black/white values to search
|
|
/// </param>
|
|
/// <returns> Array, containing index of start of 'end block' and end of 'end
|
|
/// block'
|
|
/// </returns>
|
|
/// <throws> ReaderException </throws>
|
|
|
|
internal int[] decodeEnd(BitArray row)
|
|
{
|
|
|
|
// For convenience, reverse the row and then
|
|
// search from 'the start' for the end block
|
|
row.reverse();
|
|
try
|
|
{
|
|
int endStart = skipWhiteSpace(row);
|
|
int[] endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);
|
|
|
|
// 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.
|
|
// ref: http://www.barcode-1.net/i25code.html
|
|
validateQuietZone(row, endPattern[0]);
|
|
|
|
// Now recalculate the indices of where the 'endblock' starts & stops to
|
|
// accommodate
|
|
// the reversed nature of the search
|
|
int temp = endPattern[0];
|
|
endPattern[0] = row.Size - endPattern[1];
|
|
endPattern[1] = row.Size - temp;
|
|
|
|
return endPattern;
|
|
}
|
|
finally
|
|
{
|
|
// Put the row back the right way.
|
|
row.reverse();
|
|
}
|
|
}
|
|
|
|
/// <param name="row"> row of black/white values to search
|
|
/// </param>
|
|
/// <param name="rowOffset">position to start search
|
|
/// </param>
|
|
/// <param name="pattern"> pattern of counts of number of black and white pixels that are
|
|
/// being searched for as a pattern
|
|
/// </param>
|
|
/// <returns> start/end horizontal offset of guard pattern, as an array of two
|
|
/// ints
|
|
/// </returns>
|
|
/// <throws> ReaderException if pattern is not found </throws>
|
|
private static int[] findGuardPattern(BitArray row, int rowOffset, int[] pattern)
|
|
{
|
|
|
|
// TODO: This is very similar to implementation in UPCEANReader. Consider if they can be
|
|
// merged to a single method.
|
|
int patternLength = pattern.Length;
|
|
int[] counters = new int[patternLength];
|
|
int width = row.Size;
|
|
bool isWhite = false;
|
|
|
|
int counterPosition = 0;
|
|
int patternStart = rowOffset;
|
|
for (int x = rowOffset; x < width; x++)
|
|
{
|
|
bool pixel = row.get_Renamed(x);
|
|
if (pixel ^ isWhite)
|
|
{
|
|
counters[counterPosition]++;
|
|
}
|
|
else
|
|
{
|
|
if (counterPosition == patternLength - 1)
|
|
{
|
|
if (patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE)
|
|
{
|
|
return new int[]{patternStart, x};
|
|
}
|
|
patternStart += counters[0] + counters[1];
|
|
for (int y = 2; y < patternLength; y++)
|
|
{
|
|
counters[y - 2] = counters[y];
|
|
}
|
|
counters[patternLength - 2] = 0;
|
|
counters[patternLength - 1] = 0;
|
|
counterPosition--;
|
|
}
|
|
else
|
|
{
|
|
counterPosition++;
|
|
}
|
|
counters[counterPosition] = 1;
|
|
isWhite = !isWhite;
|
|
}
|
|
}
|
|
throw ReaderException.Instance;
|
|
}
|
|
|
|
/// <summary> Attempts to decode a sequence of ITF black/white lines into single
|
|
/// digit.
|
|
///
|
|
/// </summary>
|
|
/// <param name="counters">the counts of runs of observed black/white/black/... values
|
|
/// </param>
|
|
/// <returns> The decoded digit
|
|
/// </returns>
|
|
/// <throws> ReaderException if digit cannot be decoded </throws>
|
|
private static int decodeDigit(int[] counters)
|
|
{
|
|
|
|
int bestVariance = MAX_AVG_VARIANCE; // worst variance we'll accept
|
|
int bestMatch = - 1;
|
|
int max = PATTERNS.Length;
|
|
for (int i = 0; i < max; i++)
|
|
{
|
|
int[] pattern = PATTERNS[i];
|
|
int variance = patternMatchVariance(counters, pattern, MAX_INDIVIDUAL_VARIANCE);
|
|
if (variance < bestVariance)
|
|
{
|
|
bestVariance = variance;
|
|
bestMatch = i;
|
|
}
|
|
}
|
|
if (bestMatch >= 0)
|
|
{
|
|
return bestMatch;
|
|
}
|
|
else
|
|
{
|
|
throw ReaderException.Instance;
|
|
}
|
|
}
|
|
}
|
|
} |