status-im
/
qzxing
mirror of https://github.com/status-im/qzxing.git
2
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

fix compilation errors

This commit is contained in:
Nikolaos Ftylitakis 2021-08-07 13:55:22 +03:00
parent 263a8b61be
commit a36b859df3
6 changed files with 53 additions and 53 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

22
src/zxing/zxing/common/reedsolomon/ReedSolomonEncoder.cpp
View File

@ -9,9 +9,9 @@ namespace zxing {
ReedSolomonEncoder::ReedSolomonEncoder(QSharedPointer<GenericGF> field) :
field_(field), cachedGenerators_()
{
QSharedPointer<std::vector<int>> arrayRef(1); //will this work?
arrayRef[0] = 1;
QSharedPointer< GenericGFPoly > tmpGeneratorRef(new GenericGFPoly(field, arrayRef));
QSharedPointer<std::vector<int>> arrayRef(new std::vector<int>(1));
(*arrayRef)[0] = 1;
QSharedPointer< GenericGFPoly > tmpGeneratorRef(new GenericGFPoly(field.data(), arrayRef)); //TODO: recheck if .data? will work
cachedGenerators_.push_back(tmpGeneratorRef);
}
@ -21,10 +21,10 @@ QSharedPointer<GenericGFPoly> ReedSolomonEncoder::buildGenerator(int degree)
QSharedPointer<GenericGFPoly> lastGenerator = cachedGenerators_.at(cachedGenerators_.size() - 1);
for (int d = int(cachedGenerators_.size()); d <= degree; d++)
{
QSharedPointer<std::vector<int>> arrayRef(2); //will this work?
arrayRef[0] = 1;
arrayRef[1] = field_->exp(d - 1 + field_->getGeneratorBase());
QSharedPointer<GenericGFPoly> tmpGFRef(new GenericGFPoly(field_, arrayRef));
QSharedPointer<std::vector<int>> arrayRef(new std::vector<int>(2));
(*arrayRef)[0] = 1;
(*arrayRef)[1] = field_->exp(d - 1 + field_->getGeneratorBase());
QSharedPointer<GenericGFPoly> tmpGFRef(new GenericGFPoly(field_.data(), arrayRef)); //TODO: recheck if .data? will work
QSharedPointer<GenericGFPoly> nextGenerator = (*lastGenerator).multiply(tmpGFRef);
cachedGenerators_.push_back(nextGenerator);
lastGenerator = nextGenerator;
@ -48,13 +48,13 @@ void ReedSolomonEncoder::encode(std::vector<zxing::byte> &toEncode, int ecBytes)
throw Exception("No data bytes provided");
}
QSharedPointer<GenericGFPoly> generator = buildGenerator(ecBytes);
QSharedPointer<std::vector<int>> infoCoefficients(dataBytes);
QSharedPointer<std::vector<int>> infoCoefficients(new std::vector<int>(dataBytes));
//to-do optimize the following loop
for(int i=0; i< dataBytes; i++)
infoCoefficients[i] = toEncode[size_t(i)];
(*infoCoefficients)[i] = toEncode[size_t(i)];
QSharedPointer<GenericGFPoly> info(new GenericGFPoly(field_, infoCoefficients));
QSharedPointer<GenericGFPoly> info(new GenericGFPoly(field_.data(), infoCoefficients)); //TODO: recheck if .data? will work
info = info->multiplyByMonomial(ecBytes, 1);
QSharedPointer<GenericGFPoly> remainder = info->divide(generator)[1];
QSharedPointer<std::vector<int>> coefficients = remainder->getCoefficients();
@ -64,7 +64,7 @@ void ReedSolomonEncoder::encode(std::vector<zxing::byte> &toEncode, int ecBytes)
}
for (int i = 0; i < coefficients->size(); i++)
toEncode[size_t(dataBytes + numZeroCoefficients + i)] = zxing::byte(coefficients[i]);
toEncode[size_t(dataBytes + numZeroCoefficients + i)] = zxing::byte((*coefficients)[i]);
}
}

26
src/zxing/zxing/datamatrix/detector/DataMatrixDetector.cpp
View File

@ -92,10 +92,10 @@ QSharedPointer<DetectorResult> Detector::detect() {
// as are B and C. Figure out which are the solid black lines
// by counting transitions
std::vector<QSharedPointer<ResultPointsAndTransitions> > transitions(4);
transitions[0].reset(transitionsBetween(pointA, pointB));
transitions[1].reset(transitionsBetween(pointA, pointC));
transitions[2].reset(transitionsBetween(pointB, pointD));
transitions[3].reset(transitionsBetween(pointC, pointD));
transitions[0] = transitionsBetween(pointA, pointB);
transitions[1] = transitionsBetween(pointA, pointC);
transitions[2] = transitionsBetween(pointB, pointD);
transitions[3] = transitionsBetween(pointC, pointD);
insertionSort(transitions);
// Sort by number of transitions. First two will be the two solid sides; last two
@ -138,9 +138,9 @@ QSharedPointer<DetectorResult> Detector::detect() {
// Bottom left is correct but top left and bottom right might be switched
std::vector<QSharedPointer<ResultPoint> > corners(3);
corners[0].reset(maybeTopLeft);
corners[1].reset(bottomLeft);
corners[2].reset(maybeBottomRight);
corners[0] = maybeTopLeft;
corners[1] = bottomLeft;
corners[2] = maybeBottomRight;
// Use the dot product trick to sort them out
ResultPoint::orderBestPatterns(corners);
@ -247,10 +247,10 @@ QSharedPointer<DetectorResult> Detector::detect() {
}
QSharedPointer<std::vector<QSharedPointer<ResultPoint>> > points (new std::vector< QSharedPointer<ResultPoint> >(4));
points[0].reset(topLeft);
points[1].reset(bottomLeft);
points[2].reset(correctedTopRight);
points[3].reset(bottomRight);
(*points)[0] = topLeft;
(*points)[1] = bottomLeft;
(*points)[2] = correctedTopRight;
(*points)[3] = bottomRight;
QSharedPointer<DetectorResult> detectorResult(new DetectorResult(bits, points));
return detectorResult;
}
@ -435,8 +435,8 @@ void Detector::insertionSort(std::vector<QSharedPointer<ResultPointsAndTransitio
value = vector[i - 1];
if (compare(value, (valueB = vector[i])) > 0){
swapped = true;
vector[i - 1].reset(valueB);
vector[i].reset(value);
vector[i - 1] = valueB;
vector[i] = value;
}
}
} while (swapped);

16
src/zxing/zxing/pdf417/PDF417Reader.cpp
View File

@ -52,7 +52,7 @@ QSharedPointer<Result> PDF417Reader::decode(QSharedPointer<BinaryBitmap> image,
{
for (int i = 0; i < points->size(); i++)
{
rpcb->foundPossibleResultPoint(*points[i]);
rpcb->foundPossibleResultPoint(*(*points)[i]);
}
}
}
@ -81,10 +81,10 @@ QSharedPointer<BitMatrix> PDF417Reader::extractPureBits(QSharedPointer<BitMatrix
int nModuleSize = moduleSize(leftTopBlack, image);
int top = leftTopBlack[1];
int bottom = rightBottomBlack[1];
int left = findPatternStart(leftTopBlack[0], top, image);
int right = findPatternEnd(leftTopBlack[0], top, image);
int top = (*leftTopBlack)[1];
int bottom = (*rightBottomBlack)[1];
int left = findPatternStart((*leftTopBlack)[0], top, image);
int right = findPatternEnd((*leftTopBlack)[0], top, image);
int matrixWidth = (right - left + 1) / nModuleSize;
int matrixHeight = (bottom - top + 1) / nModuleSize;
@ -118,8 +118,8 @@ QSharedPointer<BitMatrix> PDF417Reader::extractPureBits(QSharedPointer<BitMatrix
int PDF417Reader::moduleSize(QSharedPointer<std::vector<int>> leftTopBlack, QSharedPointer<BitMatrix> image)
{
int x = leftTopBlack[0];
int y = leftTopBlack[1];
int x = (*leftTopBlack)[0];
int y = (*leftTopBlack)[1];
int width = image->getWidth();
while (x < width && image->get(x, y))
{
@ -130,7 +130,7 @@ int PDF417Reader::moduleSize(QSharedPointer<std::vector<int>> leftTopBlack, QSha
throw NotFoundException("PDF417Reader::moduleSize: not found!");
}
int moduleSize = (int)(((unsigned)(x - leftTopBlack[0])) >> 3); // We've crossed left first bar, which is 8x
int moduleSize = (int)(((unsigned)(x - (*leftTopBlack)[0])) >> 3); // We've crossed left first bar, which is 8x
if (moduleSize == 0)
{
throw NotFoundException("PDF417Reader::moduleSize: is zero!");

6
src/zxing/zxing/pdf417/decoder/PDF417Decoder.cpp
View File

@ -77,14 +77,14 @@ void Decoder::verifyCodewordCount(QSharedPointer<std::vector<int>> codewords, in
// The first codeword, the Symbol Length Descriptor, shall always encode the total number of data
// codewords in the symbol, including the Symbol Length Descriptor itself, data codewords and pad
// codewords, but excluding the number of error correction codewords.
int numberOfCodewords = codewords[0];
int numberOfCodewords = (*codewords)[0];
if (numberOfCodewords > cwsize) {
throw FormatException("PDF:Decoder:verifyCodewordCount: bad codeword number descriptor!");
}
if (numberOfCodewords == 0) {
// Reset to the length of the array - 8 (Allow for at least level 3 Error Correction (8 Error Codewords)
if (numECCodewords < cwsize) {
codewords[0] = cwsize - numECCodewords;
(*codewords)[0] = cwsize - numECCodewords;
} else {
throw FormatException("PDF:Decoder:verifyCodewordCount: bad error correction cw number!");
}
@ -111,7 +111,7 @@ void Decoder::correctErrors(QSharedPointer<std::vector<int>> codewords,
// 2012-06-27 HFN if, despite of error correction, there are still codewords with invalid
// value, throw an exception here:
for (int i = 0; i < codewords->size(); i++) {
if (codewords[i]<0) {
if ((*codewords)[i]<0) {
throw FormatException("PDF:Decoder:correctErrors: Error correction did not succeed!");
}
}

24
src/zxing/zxing/qrcode/encoder/QREncoder.cpp
View File

@ -376,14 +376,14 @@ BitArray* Encoder::interleaveWithECBytes(const BitArray& bits,
numDataBytesInBlock, numEcBytesInBlock);
int size = numDataBytesInBlock[0];
std::vector<zxing::byte> dataBytes;
dataBytes.resize(size_t(size));
bits.toBytes(8*dataBytesOffset, dataBytes, 0, size);
QSharedPointer<std::vector<zxing::byte>> ecBytes = generateECBytes(dataBytes, numEcBytesInBlock[0]);
blocks.push_back(BlockPair(QSharedPointer<std::vector<zxing::byte>>(dataBytes.data(), int(dataBytes.size())), ecBytes)); //?? please revisit
QSharedPointer<std::vector<zxing::byte>> dataBytes(new std::vector<zxing::byte>());
dataBytes->resize(size_t(size));
bits.toBytes(8*dataBytesOffset, (*dataBytes), 0, size);
QSharedPointer<std::vector<zxing::byte>> ecBytes = generateECBytes((*dataBytes), numEcBytesInBlock[0]);
blocks.push_back(BlockPair(dataBytes, ecBytes)); //?? please revisit
maxNumDataBytes = max(maxNumDataBytes, size);
maxNumEcBytes = max(maxNumEcBytes, ecBytes->size());
maxNumEcBytes = max(maxNumEcBytes, int(ecBytes->size()));
dataBytesOffset += numDataBytesInBlock[0];
}
if (numDataBytes != dataBytesOffset) {
@ -396,8 +396,8 @@ BitArray* Encoder::interleaveWithECBytes(const BitArray& bits,
for (int i = 0; i < maxNumDataBytes; ++i) {
for (std::vector< BlockPair >::iterator it=blocks.begin(); it != blocks.end(); it++) {
QSharedPointer<std::vector<zxing::byte>> dataBytes = it->getDataBytes();
if (i < dataBytes.array_->size()) {
result->appendBits(dataBytes[i], 8); ///????? are we sure?
if (i < dataBytes->size()) {
result->appendBits((*dataBytes)[i], 8); ///????? are we sure?
}
}
}
@ -405,8 +405,8 @@ BitArray* Encoder::interleaveWithECBytes(const BitArray& bits,
for (int i = 0; i < maxNumEcBytes; ++i) {
for (std::vector< BlockPair >::iterator it=blocks.begin(); it != blocks.end(); it++) {
QSharedPointer<std::vector<zxing::byte>> ecBytes = it->getErrorCorrectionBytes();
if (i < ecBytes.array_->size()) {
result->appendBits(ecBytes[i], 8);
if (i < ecBytes->size()) {
result->appendBits((*ecBytes)[i], 8);
}
}
}
@ -431,9 +431,9 @@ QSharedPointer<std::vector<zxing::byte>> Encoder::generateECBytes(const std::vec
zxing::ReedSolomonEncoder encoder(GenericGF::QR_CODE_FIELD_256);
encoder.encode(dataBytesCopy, numEcBytesInBlock);
QSharedPointer<std::vector<zxing::byte>> ecBytes(numEcBytesInBlock);
QSharedPointer<std::vector<zxing::byte>> ecBytes(new std::vector<zxing::byte>(numEcBytesInBlock));
for (int i = 0; i < numEcBytesInBlock; i++) {
ecBytes[i] = dataBytesCopy[numDataBytes + size_t(i)];
(*ecBytes)[i] = dataBytesCopy[numDataBytes + size_t(i)];
}
return ecBytes;
}

12
tests/src/QZXingTests/zxing/qrcode/encoder/EncoderTests.cpp
View File

@ -398,9 +398,9 @@ void EncoderTests::testGenerateECBytes()
byte expected[] = {
42, 159, 74, 221, 244, 169, 239, 150, 138, 70, 237, 85, 224, 96, 74, 219, 61
};
assertEquals( getArrayLength(expected), ecBytes->size());
assertEquals( getArrayLength(expected), int(ecBytes->size()));
for (int x = 0; x < getArrayLength(expected); x++) {
assertEquals(expected[x], ecBytes[x]);
assertEquals(expected[x], (*ecBytes)[x]);
}
/////////////////////////////////////////////////////////////////////////////
@ -412,9 +412,9 @@ void EncoderTests::testGenerateECBytes()
175, 80, 155, 64, 178, 45, 214, 233, 65, 209, 12, 155, 117, 31, 140, 214, 27, 187
};
assertEquals(getArrayLength(expected2), ecBytes->size());
assertEquals(getArrayLength(expected2), int(ecBytes->size()));
for (int x = 0; x < getArrayLength(expected2); x++) {
assertEquals(expected2[x], ecBytes[x] );
assertEquals(expected2[x], (*ecBytes)[x] );
}
/////////////////////////////////////////////////////////////////////////////
@ -425,9 +425,9 @@ void EncoderTests::testGenerateECBytes()
byte expected3[] = {
0, 3, 130, 179, 194, 0, 55, 211, 110, 79, 98, 72, 170, 96, 211, 137, 213
};
assertEquals(getArrayLength(expected3), ecBytes->size());
assertEquals(getArrayLength(expected3), int(ecBytes->size()));
for (int x = 0; x < getArrayLength(expected3); x++) {
assertEquals(expected3[x], ecBytes[x]);
assertEquals(expected3[x], (*ecBytes)[x]);
}
}