#include <zxing/ZXing.h>
#include <zxing/oned/ITFReader.h>
#include <zxing/oned/OneDResultPoint.h>
#include <zxing/common/Array.h>
#include <zxing/ReaderException.h>
#include <zxing/FormatException.h>
#include <zxing/NotFoundException.h>
#include <math.h>
using std::vector;
using zxing::Ref;
using zxing::ArrayRef;
using zxing::Array;
using zxing::Result;
using zxing::FormatException;
using zxing::NotFoundException;
using zxing::oned::ITFReader;
using zxing::BitArray;
#define VECTOR_INIT(v) v, v + sizeof(v)/sizeof(v[0])
namespace {
const int W = 3;
const int N = 1;
const int DEFAULT_ALLOWED_LENGTHS_[] =
{ 48, 44, 24, 20, 18, 16, 14, 12, 10, 8, 6 };
const ArrayRef<int> DEFAULT_ALLOWED_LENGTHS (new Array<int>(VECTOR_INIT(DEFAULT_ALLOWED_LENGTHS_)));
const int START_PATTERN_[] = {N, N, N, N};
const vector<int> START_PATTERN (VECTOR_INIT(START_PATTERN_));
const int END_PATTERN_REVERSED_[] = {N, N, W};
const vector<int> END_PATTERN_REVERSED (VECTOR_INIT(END_PATTERN_REVERSED_));
const int PATTERNS[][5] = {
{N, N, W, W, N},
{W, N, N, N, W},
{N, W, N, N, W},
{W, W, N, N, N},
{N, N, W, N, W},
{W, N, W, N, N},
{N, W, W, N, N},
{N, N, N, W, W},
{W, N, N, W, N},
{N, W, N, W, N}
};
}
ITFReader::ITFReader() : narrowLineWidth(-1) {
}
Ref<Result> ITFReader::decodeRow(int rowNumber, Ref<BitArray> row, zxing::DecodeHints ) {
Range startRange = decodeStart(row);
Range endRange = decodeEnd(row);
std::string result;
decodeMiddle(row, startRange[1], endRange[0], result);
Ref<String> resultString(new String(result));
ArrayRef<int> allowedLengths;
if (!allowedLengths) {
allowedLengths = DEFAULT_ALLOWED_LENGTHS;
}
int length = resultString->size();
bool lengthOK = false;
for (int i = 0, e = allowedLengths->size(); i < e; i++) {
if (length == allowedLengths[i]) {
lengthOK = true;
break;
}
}
if (!lengthOK) {
throw FormatException();
}
ArrayRef< Ref<ResultPoint> > resultPoints(2);
resultPoints[0] =
Ref<OneDResultPoint>(new OneDResultPoint(float(startRange[1]), float(rowNumber)));
resultPoints[1] =
Ref<OneDResultPoint>(new OneDResultPoint(float(endRange[0]), float(rowNumber)));
return Ref<Result>(new Result(resultString, ArrayRef<byte>(), resultPoints, BarcodeFormat::ITF));
}
void ITFReader::decodeMiddle(Ref<BitArray> row,
int payloadStart,
int payloadEnd,
std::string& resultString) {
vector<int> counterDigitPair(10, 0);
vector<int> counterBlack(5, 0);
vector<int> counterWhite(5, 0);
while (payloadStart < payloadEnd) {
recordPattern(row, payloadStart, counterDigitPair);
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(1, (byte) ('0' + bestMatch));
bestMatch = decodeDigit(counterWhite);
resultString.append(1, (byte) ('0' + bestMatch));
for (int i = 0, e = counterDigitPair.size(); i < e; i++) {
payloadStart += counterDigitPair[i];
}
}
}
ITFReader::Range ITFReader::decodeStart(Ref<BitArray> row) {
int endStart = skipWhiteSpace(row);
Range startPattern = findGuardPattern(row, endStart, START_PATTERN);
narrowLineWidth = (startPattern[1] - startPattern[0]) >> 2;
validateQuietZone(row, startPattern[0]);
return startPattern;
}
ITFReader::Range ITFReader::decodeEnd(Ref<BitArray> row) {
BitArray::Reverse r (row);
int endStart = skipWhiteSpace(row);
Range endPattern = findGuardPattern(row, endStart, END_PATTERN_REVERSED);
validateQuietZone(row, endPattern[0]);
int temp = endPattern[0];
endPattern[0] = row->getSize() - endPattern[1];
endPattern[1] = row->getSize() - temp;
return endPattern;
}
void ITFReader::validateQuietZone(Ref<BitArray> row, int startPattern) {
int quietCount = this->narrowLineWidth * 10;
for (int i = startPattern - 1; quietCount > 0 && i >= 0; i--) {
if (row->get(i)) {
break;
}
quietCount--;
}
if (quietCount != 0) {
throw NotFoundException();
}
}
int ITFReader::skipWhiteSpace(Ref<BitArray> row) {
int width = row->getSize();
int endStart = row->getNextSet(0);
if (endStart == width) {
throw NotFoundException();
}
return endStart;
}
ITFReader::Range ITFReader::findGuardPattern(Ref<BitArray> row,
int rowOffset,
vector<int> const& pattern) {
int patternLength = pattern.size();
vector<int> counters(patternLength);
int width = row->getSize();
bool isWhite = false;
int counterPosition = 0;
int patternStart = rowOffset;
for (int x = rowOffset; x < width; x++) {
if (row->get(x) ^ isWhite) {
counters[counterPosition]++;
} else {
if (counterPosition == patternLength - 1) {
if (patternMatchVariance(counters, &pattern[0], MAX_INDIVIDUAL_VARIANCE) < MAX_AVG_VARIANCE) {
return Range(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 NotFoundException();
}
int ITFReader::decodeDigit(vector<int>& counters){
int bestVariance = MAX_AVG_VARIANCE;
int bestMatch = -1;
int max = sizeof(PATTERNS)/sizeof(PATTERNS[0]);
for (int i = 0; i < max; i++) {
int const* 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 NotFoundException();
}
}
ITFReader::~ITFReader(){}