rhodes 5.5.15 → 5.5.17

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/pdf417/decoder/PDF417Decoder.cpp

@@ -0,0 +1,118 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 2010, 2012 ZXing authors All rights reserved.
+ *
+ * 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.
+ *
+ * 2012-06-27 hfn: PDF417 Reed-Solomon error correction, using following Java
+ * source code:
+ * http://code.google.com/p/zxing/issues/attachmentText?id=817&aid=8170033000&name=pdf417-java-reed-solomon-error-correction-2.patch&token=0819f5d7446ae2814fd91385eeec6a11
+ */
+
+#include <zxing/pdf417/PDF417Reader.h>
+#include <zxing/pdf417/decoder/Decoder.h>
+#include <zxing/pdf417/decoder/BitMatrixParser.h>
+#include <zxing/pdf417/decoder/DecodedBitStreamParser.h>
+#include <zxing/ReaderException.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+
+using zxing::pdf417::decoder::Decoder;
+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;
+
+Ref<DecoderResult> Decoder::decode(Ref<BitMatrix> bits, DecodeHints const& hints) {
+  (void)hints;
+  // Construct a parser to read the data codewords and error-correction level
+  BitMatrixParser parser(bits);
+  ArrayRef<int> codewords(parser.readCodewords());
+  if (codewords->size() == 0) {
+    throw FormatException("PDF:Decoder:decode: cannot read codewords");
+  }
+
+  int ecLevel = parser.getECLevel();
+  int numECCodewords = 1 << (ecLevel + 1);
+  ArrayRef<int> erasures = parser.getErasures();
+
+  correctErrors(codewords, erasures, numECCodewords);
+  verifyCodewordCount(codewords, numECCodewords);
+
+  // Decode the codewords
+  return DecodedBitStreamParser::decode(codewords);
+}
+
+/**
+ * Verify that all is OK with the codeword array.
+ *
+ * @param codewords
+ * @return an index to the first data codeword.
+ * @throws FormatException
+ */
+void Decoder::verifyCodewordCount(ArrayRef<int> codewords, int numECCodewords) {
+  int cwsize = codewords->size();
+  if (cwsize < 4) {
+    // Codeword array size should be at least 4 allowing for
+    // Count CW, At least one Data CW, Error Correction CW, Error Correction CW
+    throw FormatException("PDF:Decoder:verifyCodewordCount: codeword array too small!");
+  }
+  // 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];
+  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;
+    } else {
+      throw FormatException("PDF:Decoder:verifyCodewordCount: bad error correction cw number!");
+    }
+  }
+}
+
+/**
+ * Correct errors whenever it is possible using Reed-Solomom algorithm
+ *
+ * @param codewords, erasures, numECCodewords
+ * @return 0.
+ * @throws FormatException
+ */
+void Decoder::correctErrors(ArrayRef<int> codewords,
+                            ArrayRef<int> erasures, int numECCodewords) {
+  if (erasures->size() > numECCodewords / 2 + MAX_ERRORS ||
+      numECCodewords < 0 || numECCodewords > MAX_EC_CODEWORDS) {
+    throw FormatException("PDF:Decoder:correctErrors: Too many errors or EC Codewords corrupted");
+  }
+
+  Ref<ErrorCorrection> errorCorrection(new ErrorCorrection);
+  errorCorrection->decode(codewords, numECCodewords, erasures);
+
+  // 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) {
+      throw FormatException("PDF:Decoder:correctErrors: Error correction did not succeed!");
+    }
+  }
+}

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/pdf417/decoder/ec/ErrorCorrection.cpp

@@ -0,0 +1,214 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 2012 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.
+ *
+ * 2012-09-19 HFN translation from Java into C++
+ */
+
+#include <zxing/pdf417/decoder/ec/ErrorCorrection.h>
+#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
+#include <zxing/pdf417/decoder/ec/ModulusGF.h>
+
+using std::vector;
+using zxing::Ref;
+using zxing::ArrayRef;
+using zxing::pdf417::decoder::ec::ErrorCorrection;
+using zxing::pdf417::decoder::ec::ModulusPoly;
+using zxing::pdf417::decoder::ec::ModulusGF;
+
+/**
+ * <p>PDF417 error correction implementation.</p>
+ *
+ * <p>This <a href="http://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction#Example">example</a>
+ * is quite useful in understanding the algorithm.</p>
+ *
+ * @author Sean Owen
+ * @see com.google.zxing.common.reedsolomon.ReedSolomonDecoder
+ */
+ 
+
+ErrorCorrection::ErrorCorrection()
+    : field_(ModulusGF::PDF417_GF)
+{
+}
+
+void ErrorCorrection::decode(ArrayRef<int> received,
+                             int numECCodewords,
+                             ArrayRef<int> erasures)
+{
+  Ref<ModulusPoly> poly (new ModulusPoly(field_, received));
+  ArrayRef<int> S( new Array<int>(numECCodewords));
+  bool error = false;
+  for (int i = numECCodewords; i > 0; i--) {
+    int eval = poly->evaluateAt(field_.exp(i));
+    S[numECCodewords - i] = eval;
+    if (eval != 0) {
+      error = true;
+    }
+  }
+
+  if (error) {
+
+    Ref<ModulusPoly> knownErrors = field_.getOne();
+    for (int i=0;i<erasures->size();i++) {
+      int b = field_.exp(received->size() - 1 - erasures[i]);
+      // Add (1 - bx) term:
+      ArrayRef<int> one_minus_b_x(new Array<int>(2));
+      one_minus_b_x[1]=field_.subtract(0,b);
+      one_minus_b_x[0]=1;
+      Ref<ModulusPoly> term (new ModulusPoly(field_,one_minus_b_x));
+      knownErrors = knownErrors->multiply(term);
+    }
+
+    Ref<ModulusPoly> syndrome (new ModulusPoly(field_, S));
+    //syndrome = syndrome.multiply(knownErrors);
+
+    vector<Ref<ModulusPoly> > sigmaOmega (
+        runEuclideanAlgorithm(field_.buildMonomial(numECCodewords, 1), syndrome, numECCodewords));
+    Ref<ModulusPoly> sigma = sigmaOmega[0];
+    Ref<ModulusPoly> omega = sigmaOmega[1];
+
+    //sigma = sigma.multiply(knownErrors);
+
+    ArrayRef<int> errorLocations = findErrorLocations(sigma);
+    ArrayRef<int> errorMagnitudes = findErrorMagnitudes(omega, sigma, errorLocations);
+
+    for (int i = 0; i < errorLocations->size(); i++) {
+      int position = received->size() - 1 - field_.log(errorLocations[i]);
+      if (position < 0) {
+        throw ReedSolomonException("Bad error location!");
+      }
+      received[position] = field_.subtract(received[position], errorMagnitudes[i]);
+/*#if (defined (DEBUG)  && defined _WIN32)
+      {
+        WCHAR szmsg[256];
+        swprintf(szmsg,L"ErrorCorrection::decode: fix @ %d, new value = %d\n",
+                 position, received[position]);
+        OutputDebugString(szmsg);
+      }
+#endif*/
+    }
+  }
+}
+
+vector<Ref<ModulusPoly> >  ErrorCorrection::runEuclideanAlgorithm(Ref<ModulusPoly> a, Ref<ModulusPoly> b, int R)
+{
+  // Assume a's degree is >= b's
+  if (a->getDegree() < b->getDegree()) {
+    Ref<ModulusPoly> temp = a;
+    a = b;
+    b = temp;
+  }
+
+  Ref<ModulusPoly> rLast ( a);
+  Ref<ModulusPoly> r ( b);
+  Ref<ModulusPoly> tLast ( field_.getZero());
+  Ref<ModulusPoly> t ( field_.getOne());
+
+  // Run Euclidean algorithm until r's degree is less than R/2
+  while (r->getDegree() >= R / 2) {
+    Ref<ModulusPoly> rLastLast (rLast);
+    Ref<ModulusPoly> tLastLast (tLast);
+    rLast = r;
+    tLast = t;
+
+    // Divide rLastLast by rLast, with quotient in q and remainder in r
+    if (rLast->isZero()) {
+      // Oops, Euclidean algorithm already terminated?
+      throw ReedSolomonException("Euclidean algorithm already terminated?");
+    }
+    r = rLastLast;
+    Ref<ModulusPoly> q (field_.getZero());
+    int denominatorLeadingTerm = rLast->getCoefficient(rLast->getDegree());
+    int dltInverse = field_.inverse(denominatorLeadingTerm);
+    while (r->getDegree() >= rLast->getDegree() && !r->isZero()) {
+      int degreeDiff = r->getDegree() - rLast->getDegree();
+      int scale = field_.multiply(r->getCoefficient(r->getDegree()), dltInverse);
+      q = q->add(field_.buildMonomial(degreeDiff, scale));
+      r = r->subtract(rLast->multiplyByMonomial(degreeDiff, scale));
+    }
+
+	  t = q->multiply(tLast)->subtract(tLastLast)->negative();
+  }
+
+  int sigmaTildeAtZero = t->getCoefficient(0);
+  if (sigmaTildeAtZero == 0) {
+    throw ReedSolomonException("sigmaTilde = 0!");
+  }
+
+  int inverse = field_.inverse(sigmaTildeAtZero);
+  Ref<ModulusPoly> sigma (t->multiply(inverse));
+  Ref<ModulusPoly> omega (r->multiply(inverse));
+	vector<Ref<ModulusPoly> > v(2);
+	v[0] = sigma;
+	v[1] = omega;
+  return v;
+}
+
+ArrayRef<int> ErrorCorrection::findErrorLocations(Ref<ModulusPoly> errorLocator)  {
+  // This is a direct application of Chien's search
+  int numErrors = errorLocator->getDegree();
+  ArrayRef<int> result( new Array<int>(numErrors));
+  int e = 0;
+  for (int i = 1; i < field_.getSize() && e < numErrors; i++) {
+    if (errorLocator->evaluateAt(i) == 0) {
+      result[e] = field_.inverse(i);
+      e++;
+    }
+  }
+  if (e != numErrors) {
+#if (defined (DEBUG) && defined _WIN32)
+	  char sz[128];
+	  sprintf(sz,"Error number inconsistency, %d/%d!",e,numErrors);
+    throw ReedSolomonException(sz);
+#else
+	  throw ReedSolomonException("Error number inconsistency!");
+#endif
+  }
+/*#if (defined (DEBUG) && defined _WIN32)
+  {
+    WCHAR szmsg[256];
+    swprintf(szmsg,L"ErrorCorrection::findErrorLocations: found %d errors.\n",
+             e);
+    OutputDebugString(szmsg);
+  }
+#endif*/
+  return result;
+}
+
+ArrayRef<int> ErrorCorrection::findErrorMagnitudes(Ref<ModulusPoly> errorEvaluator,
+                                                   Ref<ModulusPoly> errorLocator,
+                                                   ArrayRef<int> errorLocations) {
+	int i;
+  int errorLocatorDegree = errorLocator->getDegree();
+  ArrayRef<int> formalDerivativeCoefficients (new Array<int>(errorLocatorDegree));
+  for (i = 1; i <= errorLocatorDegree; i++) {
+    formalDerivativeCoefficients[errorLocatorDegree - i] =
+        field_.multiply(i, errorLocator->getCoefficient(i));
+  }
+  Ref<ModulusPoly> formalDerivative (new ModulusPoly(field_, formalDerivativeCoefficients));
+
+  // This is directly applying Forney's Formula
+  int s = errorLocations->size();
+  ArrayRef<int> result ( new Array<int>(s));
+  for (i = 0; i < s; i++) {
+    int xiInverse = field_.inverse(errorLocations[i]);
+    int numerator = field_.subtract(0, errorEvaluator->evaluateAt(xiInverse));
+    int denominator = field_.inverse(formalDerivative->evaluateAt(xiInverse));
+    result[i] = field_.multiply(numerator, denominator);
+  }
+  return result;
+}
+

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/pdf417/decoder/ec/ErrorCorrection.h

@@ -0,0 +1,71 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __ERROR_CORRECTION_PDF_H__
+#define __ERROR_CORRECTION_PDF_H__
+/*
+ * Copyright 2012 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.
+ *
+ * 2012-09-17 HFN translation from Java into C++
+ */
+
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/DecoderResult.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/pdf417/decoder/ec/ModulusGF.h>
+#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+
+namespace zxing {
+namespace pdf417 {
+namespace decoder {
+namespace ec {
+
+
+/**
+ * <p>PDF417 error correction implementation.</p>
+ *
+ * <p>This <a href="http://en.wikipedia.org/wiki/Reed%E2%80%93Solomon_error_correction#Example">example</a>
+ * is quite useful in understanding the algorithm.</p>
+ *
+ * @author Sean Owen
+ * @see com.google.zxing.common.reedsolomon.ReedSolomonDecoder
+ */
+class ErrorCorrection: public Counted {
+
+ private:
+  ModulusGF &field_;
+
+ public:
+  ErrorCorrection();
+  void decode(ArrayRef<int> received,
+              int numECCodewords,
+              ArrayRef<int> erasures);
+
+ private:
+  std::vector<Ref<ModulusPoly> > runEuclideanAlgorithm(Ref<ModulusPoly> a, Ref<ModulusPoly> b, int R);
+
+  ArrayRef<int> findErrorLocations(Ref<ModulusPoly> errorLocator);
+  ArrayRef<int> findErrorMagnitudes(Ref<ModulusPoly> errorEvaluator,
+                                    Ref<ModulusPoly> errorLocator,
+                                    ArrayRef<int> errorLocations);
+};
+
+}
+}
+}
+}
+
+#endif /* __ERROR_CORRECTION_PDF_H__ */

data/lib/commonAPI/barcode/ext/platform/qt/src/qzxing/zxing/zxing/pdf417/decoder/ec/ModulusGF.cpp

@@ -0,0 +1,120 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ * Copyright 2012 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.
+ *
+ * 2012-09-19 HFN translation from Java into C++
+ */
+
+#include <zxing/pdf417/decoder/ec/ModulusGF.h>
+#include <zxing/pdf417/decoder/ec/ModulusPoly.h>
+
+using zxing::Ref;
+using zxing::pdf417::decoder::ec::ModulusGF;
+using zxing::pdf417::decoder::ec::ModulusPoly;
+
+/**
+ * The central Modulus Galois Field for PDF417 with prime number 929
+ * and generator 3.
+ */
+ModulusGF ModulusGF::PDF417_GF(929,3);
+
+
+/**
+ * <p>A field based on powers of a generator integer, modulo some modulus.</p>
+ *
+ * @author Sean Owen
+ * @see com.google.zxing.common.reedsolomon.GenericGF
+ */
+ 
+ModulusGF::ModulusGF(int modulus, int generator)
+    : modulus_(modulus) {
+	expTable_ = new Array<int>(modulus_);
+	logTable_ = new Array<int>(modulus_);
+  int x = 1,i;
+  for (i = 0; i < modulus_; i++) {
+    expTable_[i] = x;
+    x = (x * generator) % modulus_;
+  }
+  for (i = 0; i < modulus_-1; i++) {
+    logTable_[expTable_[i]] = i;
+  }
+  // logTable[0] == 0 but this should never be used
+	ArrayRef<int>aZero(new Array<int>(1)),aOne(new Array<int>(1));
+	aZero[0]=0;aOne[0]=1;
+  zero_ = new ModulusPoly(*this, aZero);
+  one_ = new ModulusPoly(*this, aOne);
+}
+ 
+Ref<ModulusPoly> ModulusGF::getZero() {
+  return zero_;
+}
+
+Ref<ModulusPoly> ModulusGF::getOne() {
+  return one_;
+}
+
+Ref<ModulusPoly> ModulusGF::buildMonomial(int degree, int coefficient)
+{
+  if (degree < 0) {
+    throw IllegalArgumentException("monomial: degree < 0!");
+  }
+  if (coefficient == 0) {
+    return zero_;
+  }
+	int nCoefficients = degree + 1;
+  ArrayRef<int> coefficients (new Array<int>(nCoefficients));
+  coefficients[0] = coefficient;
+	Ref<ModulusPoly> result(new ModulusPoly(*this,coefficients));
+  return result;
+}
+
+ 
+
+int ModulusGF::add(int a, int b) {
+  return (a + b) % modulus_;
+}
+
+int ModulusGF::subtract(int a, int b) {
+  return (modulus_ + a - b) % modulus_;
+}
+
+int ModulusGF::exp(int a) {
+  return expTable_[a];
+}
+
+int ModulusGF::log(int a) {
+  if (a == 0) {
+    throw IllegalArgumentException("log of zero!");
+  }
+  return logTable_[a];
+}
+
+int ModulusGF::inverse(int a) {
+  if (a == 0) {
+    throw IllegalArgumentException("inverse of zero!");;
+  }
+  return expTable_[modulus_ - logTable_[a] - 1];
+}
+
+int ModulusGF::multiply(int a, int b) {
+  if (a == 0 || b == 0) {
+    return 0;
+  }
+  return expTable_[(logTable_[a] + logTable_[b]) % (modulus_ - 1)];
+}
+
+int ModulusGF::getSize() {
+  return modulus_;
+}