mirror of
https://github.com/zxing/zxing.git
synced 2025-03-05 20:48:51 -08:00
make VC++ happy with pdf417
git-svn-id: https://zxing.googlecode.com/svn/trunk@2667 59b500cc-1b3d-0410-9834-0bbf25fbcc57
This commit is contained in:
smparkes@smparkes.net
parent
f4ae6f0631
commit
6a59c77f25
|
|
@ -39,6 +39,8 @@ endif()
|
|||
file(GLOB_RECURSE LIBZXING_FILES
|
||||
"./core/src/*.cpp"
|
||||
"./core/src/*.h"
|
||||
"./core/src/*.cc"
|
||||
"./core/src/*.hh"
|
||||
)
|
||||
if(WIN32)
|
||||
file(GLOB LIBZXING_WIN32_FILES
|
||||
|
|
|
|||
|
|
@ -1,37 +0,0 @@
|
|||
#!/bin/bash
|
||||
|
||||
bad=
|
||||
|
||||
# If you encounter the following problem with Valgrind like I did:
|
||||
# https://bugzilla.redhat.com/show_bug.cgi?id=455644
|
||||
# you can pass the environment variable NO_VALGRIND=1 to run the testsuite
|
||||
# without it.
|
||||
if [ "$NO_VALGRIND" ]; then
|
||||
cmd=(./testsuite)
|
||||
else
|
||||
cmd=(valgrind --error-exitcode=1 --leak-check=full ./testsuite)
|
||||
fi
|
||||
|
||||
set -o pipefail
|
||||
# Stdout goes directly to testsuite.out; stderr goes down the pipe.
|
||||
if ! "${cmd[@]}" 2>&1 >testsuite.out | tee testsuite.err; then
|
||||
echo >&2 'Memory errors!'
|
||||
bad=1
|
||||
fi
|
||||
|
||||
if grep 'LEAK SUMMARY' testsuite.err >/dev/null; then
|
||||
echo >&2 'Memory leaks!'
|
||||
bad=1
|
||||
fi
|
||||
|
||||
if ! diff -u testsuite.expected testsuite.out; then
|
||||
echo >&2 'Output is incorrect!'
|
||||
bad=1
|
||||
fi
|
||||
|
||||
if [ $bad ]; then
|
||||
echo >&2 'Test suite failed!'
|
||||
exit 1
|
||||
else
|
||||
echo 'Test suite passed.'
|
||||
fi
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
// Sample program demonstrating the use of the Big Integer Library.
|
||||
|
||||
// Standard libraries
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
|
||||
// `BigIntegerLibrary.hh' includes all of the library headers.
|
||||
#include "BigIntegerLibrary.hh"
|
||||
|
||||
int main() {
|
||||
/* The library throws `const char *' error messages when things go
|
||||
* wrong. It's a good idea to catch them using a `try' block like this
|
||||
* one. Your C++ compiler might need a command-line option to compile
|
||||
* code that uses exceptions. */
|
||||
try {
|
||||
BigInteger a; // a is 0
|
||||
int b = 535;
|
||||
|
||||
/* Any primitive integer can be converted implicitly to a
|
||||
* BigInteger. */
|
||||
a = b;
|
||||
|
||||
/* The reverse conversion requires a method call (implicit
|
||||
* conversions were previously supported but caused trouble).
|
||||
* If a were too big for an int, the library would throw an
|
||||
* exception. */
|
||||
b = a.toInt();
|
||||
|
||||
BigInteger c(a); // Copy a BigInteger.
|
||||
|
||||
// The int literal is converted to a BigInteger.
|
||||
BigInteger d(-314159265);
|
||||
|
||||
/* This won't compile (at least on 32-bit machines) because the
|
||||
* number is too big to be a primitive integer literal, and
|
||||
* there's no such thing as a BigInteger literal. */
|
||||
//BigInteger e(3141592653589793238462643383279);
|
||||
|
||||
// Instead you can convert the number from a string.
|
||||
std::string s("3141592653589793238462643383279");
|
||||
BigInteger f = stringToBigInteger(s);
|
||||
|
||||
// You can convert the other way too.
|
||||
std::string s2 = bigIntegerToString(f);
|
||||
|
||||
// f is implicitly stringified and sent to std::cout.
|
||||
std::cout << f << std::endl;
|
||||
|
||||
/* Let's do some math! The library overloads most of the
|
||||
* mathematical operators (including assignment operators) to
|
||||
* work on BigIntegers. There are also ``copy-less''
|
||||
* operations; see `BigUnsigned.hh' for details. */
|
||||
|
||||
// Arithmetic operators
|
||||
BigInteger g(314159), h(265);
|
||||
std::cout << (g + h) << '\n'
|
||||
<< (g - h) << '\n'
|
||||
<< (g * h) << '\n'
|
||||
<< (g / h) << '\n'
|
||||
<< (g % h) << std::endl;
|
||||
|
||||
// Bitwise operators
|
||||
BigUnsigned i(0xFF0000FF), j(0x0000FFFF);
|
||||
// The library's << operator recognizes base flags.
|
||||
std::cout.flags(std::ios::hex | std::ios::showbase);
|
||||
std::cout << (i & j) << '\n'
|
||||
<< (i | j) << '\n'
|
||||
<< (i ^ j) << '\n'
|
||||
// Shift distances are ordinary unsigned ints.
|
||||
<< (j << 21) << '\n'
|
||||
<< (j >> 10) << '\n';
|
||||
std::cout.flags(std::ios::dec);
|
||||
|
||||
// Let's do some heavy lifting and calculate powers of 314.
|
||||
int maxPower = 10;
|
||||
BigUnsigned x(1), big314(314);
|
||||
for (int power = 0; power <= maxPower; power++) {
|
||||
std::cout << "314^" << power << " = " << x << std::endl;
|
||||
x *= big314; // A BigInteger assignment operator
|
||||
}
|
||||
|
||||
// Some big-integer algorithms (albeit on small integers).
|
||||
std::cout << gcd(BigUnsigned(60), 72) << '\n'
|
||||
<< modinv(BigUnsigned(7), 11) << '\n'
|
||||
<< modexp(BigUnsigned(314), 159, 2653) << std::endl;
|
||||
|
||||
// Add your own code here to experiment with the library.
|
||||
} catch(char const* err) {
|
||||
std::cout << "The library threw an exception:\n"
|
||||
<< err << std::endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
||||
/*
|
||||
The original sample program produces this output:
|
||||
|
||||
3141592653589793238462643383279
|
||||
314424
|
||||
313894
|
||||
83252135
|
||||
1185
|
||||
134
|
||||
0xFF
|
||||
0xFF00FFFF
|
||||
0xFF00FF00
|
||||
0x1FFFE00000
|
||||
0x3F
|
||||
314^0 = 1
|
||||
314^1 = 314
|
||||
314^2 = 98596
|
||||
314^3 = 30959144
|
||||
314^4 = 9721171216
|
||||
314^5 = 3052447761824
|
||||
314^6 = 958468597212736
|
||||
314^7 = 300959139524799104
|
||||
314^8 = 94501169810786918656
|
||||
314^9 = 29673367320587092457984
|
||||
314^10 = 9317437338664347031806976
|
||||
12
|
||||
8
|
||||
1931
|
||||
|
||||
*/
|
||||
|
|
@ -1,326 +0,0 @@
|
|||
/* Test suite for the library. First, it ``tests'' that all the constructs it
|
||||
* uses compile successfully. Then, its output to stdout is compared to the
|
||||
* expected output automatically extracted from slash-slash comments below.
|
||||
*
|
||||
* NOTE: For now, the test suite expects a 32-bit system. On others, some tests
|
||||
* may fail, and it may be ineffective at catching bugs. TODO: Remedy this. */
|
||||
|
||||
#include "BigIntegerLibrary.hh"
|
||||
|
||||
#include <string>
|
||||
#include <iostream>
|
||||
using namespace std;
|
||||
|
||||
// Evaluate expr and print the result or "error" as appropriate.
|
||||
#define TEST(expr) do {\
|
||||
cout << "Line " << __LINE__ << ": ";\
|
||||
try {\
|
||||
cout << (expr);\
|
||||
} catch (const char *err) {\
|
||||
cout << "error";\
|
||||
}\
|
||||
cout << endl;\
|
||||
} while (0)
|
||||
|
||||
const BigUnsigned &check(const BigUnsigned &x) {
|
||||
unsigned int l = x.getLength();
|
||||
if (l != 0 && x.getBlock(l-1) == 0)
|
||||
cout << "check: Unzapped number!" << endl;
|
||||
if (l > x.getCapacity())
|
||||
cout << "check: Capacity inconsistent with length!" << endl;
|
||||
return x;
|
||||
}
|
||||
|
||||
const BigInteger &check(const BigInteger &x) {
|
||||
if (x.getSign() == 0 && !x.getMagnitude().isZero())
|
||||
cout << "check: Sign should not be zero!" << endl;
|
||||
if (x.getSign() != 0 && x.getMagnitude().isZero())
|
||||
cout << "check: Sign should be zero!" << endl;
|
||||
check(x.getMagnitude());
|
||||
return x;
|
||||
}
|
||||
|
||||
short pathologicalShort = ~((unsigned short)(~0) >> 1);
|
||||
int pathologicalInt = ~((unsigned int)(~0) >> 1);
|
||||
long pathologicalLong = ~((unsigned long)(~0) >> 1);
|
||||
|
||||
int main() {
|
||||
|
||||
try {
|
||||
|
||||
BigUnsigned z(0), one(1), ten(10);
|
||||
TEST(z); //0
|
||||
TEST(1); //1
|
||||
TEST(10); //10
|
||||
|
||||
// TODO: Comprehensively test the general and special cases of each function.
|
||||
|
||||
// === Default constructors ===
|
||||
|
||||
TEST(check(BigUnsigned())); //0
|
||||
TEST(check(BigInteger())); //0
|
||||
|
||||
// === Block-array constructors ===
|
||||
|
||||
BigUnsigned::Blk myBlocks[3];
|
||||
myBlocks[0] = 3;
|
||||
myBlocks[1] = 4;
|
||||
myBlocks[2] = 0;
|
||||
BigUnsigned bu(myBlocks, 3);
|
||||
TEST(check(bu)); //17179869187
|
||||
TEST(check(BigInteger(myBlocks, 3))); //17179869187
|
||||
TEST(check(BigInteger(bu ))); //17179869187
|
||||
|
||||
// For nonzero magnitude, reject zero and invalid signs.
|
||||
TEST(check(BigInteger(myBlocks, 3, BigInteger::positive))); //17179869187
|
||||
TEST(check(BigInteger(myBlocks, 3, BigInteger::negative))); //-17179869187
|
||||
TEST(check(BigInteger(myBlocks, 3, BigInteger::zero ))); //error
|
||||
TEST(check(BigInteger(bu, BigInteger::positive))); //17179869187
|
||||
TEST(check(BigInteger(bu, BigInteger::negative))); //-17179869187
|
||||
TEST(check(BigInteger(bu, BigInteger::zero ))); //error
|
||||
|
||||
// For zero magnitude, force the sign to zero without error.
|
||||
BigUnsigned::Blk myZeroBlocks[1];
|
||||
myZeroBlocks[0] = 0;
|
||||
TEST(check(BigInteger(myZeroBlocks, 1, BigInteger::positive))); //0
|
||||
TEST(check(BigInteger(myZeroBlocks, 1, BigInteger::negative))); //0
|
||||
TEST(check(BigInteger(myZeroBlocks, 1, BigInteger::zero ))); //0
|
||||
|
||||
// === BigUnsigned conversion limits ===
|
||||
|
||||
TEST(BigUnsigned(0).toUnsignedLong()); //0
|
||||
TEST(BigUnsigned(4294967295U).toUnsignedLong()); //4294967295
|
||||
TEST(stringToBigUnsigned("4294967296").toUnsignedLong()); //error
|
||||
|
||||
TEST(BigUnsigned(0).toLong()); //0
|
||||
TEST(BigUnsigned(2147483647).toLong()); //2147483647
|
||||
TEST(BigUnsigned(2147483648U).toLong()); //error
|
||||
|
||||
// int is the same as long on a 32-bit system
|
||||
TEST(BigUnsigned(0).toUnsignedInt()); //0
|
||||
TEST(BigUnsigned(4294967295U).toUnsignedInt()); //4294967295
|
||||
TEST(stringToBigUnsigned("4294967296").toUnsignedInt()); //error
|
||||
|
||||
TEST(BigUnsigned(0).toInt()); //0
|
||||
TEST(BigUnsigned(2147483647).toInt()); //2147483647
|
||||
TEST(BigUnsigned(2147483648U).toInt()); //error
|
||||
|
||||
TEST(BigUnsigned(0).toUnsignedShort()); //0
|
||||
TEST(BigUnsigned(65535).toUnsignedShort()); //65535
|
||||
TEST(BigUnsigned(65536).toUnsignedShort()); //error
|
||||
|
||||
TEST(BigUnsigned(0).toShort()); //0
|
||||
TEST(BigUnsigned(32767).toShort()); //32767
|
||||
TEST(BigUnsigned(32768).toShort()); //error
|
||||
|
||||
// === BigInteger conversion limits ===
|
||||
|
||||
TEST(BigInteger(-1).toUnsignedLong()); //error
|
||||
TEST(BigInteger(0).toUnsignedLong()); //0
|
||||
TEST(BigInteger(4294967295U).toUnsignedLong()); //4294967295
|
||||
TEST(stringToBigInteger("4294967296").toUnsignedLong()); //error
|
||||
|
||||
TEST(stringToBigInteger("-2147483649").toLong()); //error
|
||||
TEST(stringToBigInteger("-2147483648").toLong()); //-2147483648
|
||||
TEST(BigInteger(-2147483647).toLong()); //-2147483647
|
||||
TEST(BigInteger(0).toLong()); //0
|
||||
TEST(BigInteger(2147483647).toLong()); //2147483647
|
||||
TEST(BigInteger(2147483648U).toLong()); //error
|
||||
|
||||
// int is the same as long on a 32-bit system
|
||||
TEST(BigInteger(-1).toUnsignedInt()); //error
|
||||
TEST(BigInteger(0).toUnsignedInt()); //0
|
||||
TEST(BigInteger(4294967295U).toUnsignedInt()); //4294967295
|
||||
TEST(stringToBigInteger("4294967296").toUnsignedInt()); //error
|
||||
|
||||
TEST(stringToBigInteger("-2147483649").toInt()); //error
|
||||
TEST(stringToBigInteger("-2147483648").toInt()); //-2147483648
|
||||
TEST(BigInteger(-2147483647).toInt()); //-2147483647
|
||||
TEST(BigInteger(0).toInt()); //0
|
||||
TEST(BigInteger(2147483647).toInt()); //2147483647
|
||||
TEST(BigInteger(2147483648U).toInt()); //error
|
||||
|
||||
TEST(BigInteger(-1).toUnsignedShort()); //error
|
||||
TEST(BigInteger(0).toUnsignedShort()); //0
|
||||
TEST(BigInteger(65535).toUnsignedShort()); //65535
|
||||
TEST(BigInteger(65536).toUnsignedShort()); //error
|
||||
|
||||
TEST(BigInteger(-32769).toShort()); //error
|
||||
TEST(BigInteger(-32768).toShort()); //-32768
|
||||
TEST(BigInteger(-32767).toShort()); //-32767
|
||||
TEST(BigInteger(0).toShort()); //0
|
||||
TEST(BigInteger(32767).toShort()); //32767
|
||||
TEST(BigInteger(32768).toShort()); //error
|
||||
|
||||
// === Negative BigUnsigneds ===
|
||||
|
||||
// ...during construction
|
||||
TEST(BigUnsigned(short(-1))); //error
|
||||
TEST(BigUnsigned(pathologicalShort)); //error
|
||||
TEST(BigUnsigned(-1)); //error
|
||||
TEST(BigUnsigned(pathologicalInt)); //error
|
||||
TEST(BigUnsigned(long(-1))); //error
|
||||
TEST(BigUnsigned(pathologicalLong)); //error
|
||||
|
||||
// ...during subtraction
|
||||
TEST(BigUnsigned(5) - BigUnsigned(6)); //error
|
||||
TEST(stringToBigUnsigned("314159265358979323") - stringToBigUnsigned("314159265358979324")); //error
|
||||
TEST(check(BigUnsigned(5) - BigUnsigned(5))); //0
|
||||
TEST(check(stringToBigUnsigned("314159265358979323") - stringToBigUnsigned("314159265358979323"))); //0
|
||||
TEST(check(stringToBigUnsigned("4294967296") - BigUnsigned(1))); //4294967295
|
||||
|
||||
// === BigUnsigned addition ===
|
||||
|
||||
TEST(check(BigUnsigned(0) + 0)); //0
|
||||
TEST(check(BigUnsigned(0) + 1)); //1
|
||||
// Ordinary carry
|
||||
TEST(check(stringToBigUnsigned("8589934591" /* 2^33 - 1*/)
|
||||
+ stringToBigUnsigned("4294967298" /* 2^32 + 2 */))); //12884901889
|
||||
// Creation of a new block
|
||||
TEST(check(BigUnsigned(0xFFFFFFFFU) + 1)); //4294967296
|
||||
|
||||
// === BigUnsigned subtraction ===
|
||||
|
||||
TEST(check(BigUnsigned(1) - 0)); //1
|
||||
TEST(check(BigUnsigned(1) - 1)); //0
|
||||
TEST(check(BigUnsigned(2) - 1)); //1
|
||||
// Ordinary borrow
|
||||
TEST(check(stringToBigUnsigned("12884901889")
|
||||
- stringToBigUnsigned("4294967298"))); //8589934591
|
||||
// Borrow that removes a block
|
||||
TEST(check(stringToBigUnsigned("4294967296") - 1)); //4294967295
|
||||
|
||||
// === BigUnsigned multiplication and division ===
|
||||
|
||||
BigUnsigned a = check(BigUnsigned(314159265) * 358979323);
|
||||
TEST(a); //112776680263877595
|
||||
TEST(a / 123); //916883579381118
|
||||
TEST(a % 123); //81
|
||||
|
||||
TEST(BigUnsigned(5) / 0); //error
|
||||
|
||||
// === Block accessors ===
|
||||
|
||||
BigUnsigned b;
|
||||
TEST(b); //0
|
||||
TEST(b.getBlock(0)); //0
|
||||
b.setBlock(1, 314);
|
||||
// Did b grow properly? And did we zero intermediate blocks?
|
||||
TEST(check(b)); //1348619730944
|
||||
TEST(b.getLength()); //2
|
||||
TEST(b.getBlock(0)); //0
|
||||
TEST(b.getBlock(1)); //314
|
||||
// Did b shrink properly?
|
||||
b.setBlock(1, 0);
|
||||
TEST(check(b)); //0
|
||||
|
||||
BigUnsigned bb(314);
|
||||
bb.setBlock(1, 159);
|
||||
// Make sure we used allocateAndCopy, not allocate
|
||||
TEST(bb.getBlock(0)); //314
|
||||
TEST(bb.getBlock(1)); //159
|
||||
// Blocks beyond the number should be zero regardless of whether they are
|
||||
// within the capacity.
|
||||
bb.add(1, 2);
|
||||
TEST(bb.getBlock(0)); //3
|
||||
TEST(bb.getBlock(1)); //0
|
||||
TEST(bb.getBlock(2)); //0
|
||||
TEST(bb.getBlock(314159)); //0
|
||||
|
||||
// === Bit accessors ===
|
||||
|
||||
TEST(BigUnsigned(0).bitLength()); //0
|
||||
TEST(BigUnsigned(1).bitLength()); //1
|
||||
TEST(BigUnsigned(4095).bitLength()); //12
|
||||
TEST(BigUnsigned(4096).bitLength()); //13
|
||||
// 5 billion is between 2^32 (about 4 billion) and 2^33 (about 8 billion).
|
||||
TEST(stringToBigUnsigned("5000000000").bitLength()); //33
|
||||
|
||||
// 25 is binary 11001.
|
||||
BigUnsigned bbb(25);
|
||||
TEST(bbb.getBit(4)); //1
|
||||
TEST(bbb.getBit(3)); //1
|
||||
TEST(bbb.getBit(2)); //0
|
||||
TEST(bbb.getBit(1)); //0
|
||||
TEST(bbb.getBit(0)); //1
|
||||
TEST(bbb.bitLength()); //5
|
||||
// Effectively add 2^32.
|
||||
bbb.setBit(32, true);
|
||||
TEST(bbb); //4294967321
|
||||
bbb.setBit(31, true);
|
||||
bbb.setBit(32, false);
|
||||
TEST(check(bbb)); //2147483673
|
||||
|
||||
// === Combining BigUnsigned, BigInteger, and primitive integers ===
|
||||
|
||||
BigUnsigned p1 = BigUnsigned(3) * 5;
|
||||
TEST(p1); //15
|
||||
/* In this case, we would like g++ to implicitly promote the BigUnsigned to a
|
||||
* BigInteger, but it seems to prefer converting the -5 to a BigUnsigned, which
|
||||
* causes an error. If I take out constructors for BigUnsigned from signed
|
||||
* primitive integers, the BigUnsigned(3) becomes ambiguous, and if I take out
|
||||
* all the constructors but BigUnsigned(unsigned long), g++ uses that
|
||||
* constructor and gets a wrong (positive) answer. Thus, I think we'll just
|
||||
* have to live with this cast. */
|
||||
BigInteger p2 = BigInteger(BigUnsigned(3)) * -5;
|
||||
TEST(p2); //-15
|
||||
|
||||
// === Test some previous bugs ===
|
||||
|
||||
{
|
||||
/* Test that BigInteger division sets the sign to zero.
|
||||
* Bug reported by David Allen. */
|
||||
BigInteger num(3), denom(5), quotient;
|
||||
num.divideWithRemainder(denom, quotient);
|
||||
check(quotient);
|
||||
num = 5;
|
||||
num.divideWithRemainder(denom, quotient);
|
||||
check(num);
|
||||
}
|
||||
|
||||
{
|
||||
/* Test that BigInteger subtraction sets the sign properly.
|
||||
* Bug reported by Samuel Larkin. */
|
||||
BigInteger zero(0), three(3), ans;
|
||||
ans = zero - three;
|
||||
TEST(check(ans).getSign()); //-1
|
||||
}
|
||||
|
||||
{
|
||||
/* Test that BigInteger multiplication shifts bits properly on systems
|
||||
* where long is bigger than int. (Obviously, this would only catch the
|
||||
* bug when run on such a system.)
|
||||
* Bug reported by Mohand Mezmaz. */
|
||||
BigInteger f=4; f*=3;
|
||||
TEST(check(f)); //12
|
||||
}
|
||||
|
||||
{
|
||||
/* Test that bitwise XOR allocates the larger length.
|
||||
* Bug reported by Sriram Sankararaman. */
|
||||
BigUnsigned a(0), b(3), ans;
|
||||
ans = a ^ b;
|
||||
TEST(ans); //3
|
||||
}
|
||||
|
||||
{
|
||||
/* Test that an aliased multiplication works.
|
||||
* Bug reported by Boris Dessy. */
|
||||
BigInteger num(5);
|
||||
num *= num;
|
||||
TEST(check(num)); //25
|
||||
}
|
||||
|
||||
{
|
||||
/* Test that BigUnsignedInABase(std::string) constructor rejects digits
|
||||
* too big for the specified base.
|
||||
* Bug reported by Niakam Kazemi. */
|
||||
TEST(BigUnsignedInABase("f", 10)); //error
|
||||
}
|
||||
|
||||
} catch (const char *err) {
|
||||
cout << "UNCAUGHT ERROR: " << err << endl;
|
||||
}
|
||||
|
||||
return 0;
|
||||
}
|
||||
|
|
@ -24,6 +24,11 @@ using zxing::BitMatrix;
|
|||
using zxing::pdf417::PDF417Reader;
|
||||
using zxing::pdf417::detector::Detector;
|
||||
|
||||
// VC++
|
||||
using zxing::ArrayRef;
|
||||
using zxing::BinaryBitmap;
|
||||
using zxing::DecodeHints;
|
||||
|
||||
Ref<Result> PDF417Reader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
|
||||
Ref<DecoderResult> decoderResult;
|
||||
/* 2012-05-30 hfn C++ DecodeHintType does not yet know a type "PURE_BARCODE", */
|
||||
|
|
|
|||
|
|
@ -28,6 +28,11 @@
|
|||
using zxing::pdf417::decoder::BitMatrixParser;
|
||||
using zxing::ArrayRef;
|
||||
|
||||
// VC++
|
||||
|
||||
using zxing::Ref;
|
||||
using zxing::BitMatrix;
|
||||
|
||||
const int BitMatrixParser::MAX_ROWS = 90;
|
||||
// Maximum Codewords (Data + Error)
|
||||
const int BitMatrixParser::MAX_CW_CAPACITY = 929;
|
||||
|
|
@ -98,8 +103,7 @@ ArrayRef<int> BitMatrixParser::readCodewords()
|
|||
* @return the next available index into the codeword array after processing
|
||||
* this row.
|
||||
*/
|
||||
int BitMatrixParser::processRow(int rowNumber, ArrayRef<int> codewords, int next)
|
||||
{
|
||||
int BitMatrixParser::processRow(int rowNumber, ArrayRef<int> codewords, int next) {
|
||||
int width = bitMatrix_->getWidth();
|
||||
int columnNumber = 0;
|
||||
int cwClusterNumber = -1;
|
||||
|
|
@ -107,7 +111,7 @@ int BitMatrixParser::processRow(int rowNumber, ArrayRef<int> codewords, int next
|
|||
for (int i = 0; i < width; i += MODULES_IN_SYMBOL) {
|
||||
for (int mask = MODULES_IN_SYMBOL - 1; mask >= 0; mask--) {
|
||||
if (bitMatrix_->get(i + (MODULES_IN_SYMBOL - 1 - mask), rowNumber)) {
|
||||
symbol |= 1L << mask;
|
||||
symbol |= int64_t(1) << mask;
|
||||
}
|
||||
}
|
||||
if (columnNumber > 0) {
|
||||
|
|
|
|||
|
|
@ -15,6 +15,7 @@
|
|||
* limitations under the License.
|
||||
*/
|
||||
|
||||
#include <stdint.h>
|
||||
#include <bigint/BigIntegerUtils.hh>
|
||||
#include <zxing/FormatException.h>
|
||||
#include <zxing/pdf417/decoder/DecodedBitStreamParser.h>
|
||||
|
|
@ -27,6 +28,8 @@ using zxing::Ref;
|
|||
using zxing::DecoderResult;
|
||||
using zxing::String;
|
||||
|
||||
// VC++
|
||||
|
||||
const int DecodedBitStreamParser::TEXT_COMPACTION_MODE_LATCH = 900;
|
||||
const int DecodedBitStreamParser::BYTE_COMPACTION_MODE_LATCH = 901;
|
||||
const int DecodedBitStreamParser::NUMERIC_COMPACTION_MODE_LATCH = 902;
|
||||
|
|
|
|||
|
|
@ -31,6 +31,12 @@ using zxing::pdf417::decoder::ec::ErrorCorrection;
|
|||
using zxing::Ref;
|
||||
using zxing::DecoderResult;
|
||||
|
||||
// VC++
|
||||
|
||||
using zxing::BitMatrix;
|
||||
using zxing::DecodeHints;
|
||||
using zxing::ArrayRef;
|
||||
|
||||
const int Decoder::MAX_ERRORS = 3;
|
||||
const int Decoder::MAX_EC_CODEWORDS = 512;
|
||||
|
||||
|
|
|
|||
|
|
@ -21,18 +21,6 @@
|
|||
#include <zxing/pdf417/detector/LinesSampler.h>
|
||||
#include <zxing/common/GridSampler.h>
|
||||
|
||||
/*
|
||||
#include <zxing/ResultPoint.h>
|
||||
#include <zxing/common/Point.h>
|
||||
#include <zxing/pdf417/PDF417Reader.h>
|
||||
#include <zxing/pdf417/decoder/BitMatrixParser.h>
|
||||
#include <cmath>
|
||||
#include <sstream>
|
||||
#include <cstdlib>
|
||||
#include <cfloat>
|
||||
#include <map>
|
||||
*/
|
||||
|
||||
using std::vector;
|
||||
using std::max;
|
||||
using std::numeric_limits;
|
||||
|
|
@ -45,6 +33,12 @@ using zxing::Point;
|
|||
using zxing::BitMatrix;
|
||||
using zxing::GridSampler;
|
||||
|
||||
// VC++
|
||||
|
||||
using zxing::BinaryBitmap;
|
||||
using zxing::DecodeHints;
|
||||
using zxing::Line;
|
||||
|
||||
/**
|
||||
* <p>Encapsulates logic that can detect a PDF417 Code in an image, even if the
|
||||
* PDF417 Code is rotated or skewed, or partially obscured.</p>
|
||||
|
|
@ -515,7 +509,7 @@ void Detector::findWideBarTopBottom(Ref<BitMatrix> matrix,
|
|||
int y = yStart;
|
||||
|
||||
// Find offset of thin bar to the right as additional safeguard.
|
||||
int nextBarX = max(barStart, barEnd) + 1;
|
||||
int nextBarX = int(max(barStart, barEnd) + 1);
|
||||
for (; nextBarX < matrix->getWidth(); nextBarX++)
|
||||
if (!matrix->get(nextBarX - 1, y) && matrix->get(nextBarX, y)) break;
|
||||
nextBarX -= x;
|
||||
|
|
|
|||
|
|
@ -31,6 +31,9 @@ using zxing::BitMatrix;
|
|||
using zxing::NotFoundException;
|
||||
using zxing::Point;
|
||||
|
||||
// VC++
|
||||
using zxing::Line;
|
||||
|
||||
const int LinesSampler::MODULES_IN_SYMBOL;
|
||||
const int LinesSampler::BARS_IN_SYMBOL;
|
||||
const int LinesSampler::POSSIBLE_SYMBOLS;
|
||||
|
|
|
|||
Loading…
Reference in a new issue