zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/pdf417/decoder/DecodedBitStreamParser.h

@@ -0,0 +1,84 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __DECODED_BIT_STREAM_PARSER_PD_H__
+#define __DECODED_BIT_STREAM_PARSER_PD_H__
+
+/*
+ * Copyright 2010 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.
+ */
+
+#include <bigint/BigInteger.hh>
+#include <zxing/common/Array.h>
+#include <zxing/common/Str.h>
+#include <zxing/common/DecoderResult.h>
+
+namespace zxing {
+namespace pdf417 {
+
+class DecodedBitStreamParser {
+ protected:
+  enum Mode {
+    ALPHA,
+    LOWER,
+    MIXED,
+    PUNCT,
+    ALPHA_SHIFT,
+    PUNCT_SHIFT
+  };
+
+ private:
+  
+  static const int TEXT_COMPACTION_MODE_LATCH;
+  static const int BYTE_COMPACTION_MODE_LATCH;
+  static const int NUMERIC_COMPACTION_MODE_LATCH;
+  static const int BYTE_COMPACTION_MODE_LATCH_6;
+  static const int BEGIN_MACRO_PDF417_CONTROL_BLOCK;
+  static const int BEGIN_MACRO_PDF417_OPTIONAL_FIELD;
+  static const int MACRO_PDF417_TERMINATOR;
+  static const int MODE_SHIFT_TO_BYTE_COMPACTION_MODE;
+  static const int MAX_NUMERIC_CODEWORDS;
+
+  static const int PL;
+  static const int LL;
+  static const int AS;
+  static const int ML;
+  static const int AL;
+  static const int PS;
+  static const int PAL;
+  static const int EXP900_SIZE;
+
+  static const char PUNCT_CHARS[];
+  static const char MIXED_CHARS[];
+ 
+  static ArrayRef<BigInteger> EXP900;
+  static ArrayRef<BigInteger> initEXP900();
+  
+  static int textCompaction(ArrayRef<int> codewords, int codeIndex, Ref<String> result);
+  static void decodeTextCompaction(ArrayRef<int> textCompactionData,
+                                   ArrayRef<int> byteCompactionData,
+                                   int length,
+                                   Ref<String> result);
+  static int byteCompaction(int mode, ArrayRef<int> codewords, int codeIndex, Ref<String> result);
+  static int numericCompaction(ArrayRef<int> codewords, int codeIndex, Ref<String> result);
+  static Ref<String> decodeBase900toBase10(ArrayRef<int> codewords, int count);
+
+ public:
+  DecodedBitStreamParser();
+  static Ref<DecoderResult> decode(ArrayRef<int> codewords);
+};
+
+} /* namespace pdf417 */
+} /* namespace zxing */
+
+#endif // __DECODED_BIT_STREAM_PARSER_PD_H__

data/ext/zxing/zxing-cpp/core/src/zxing/pdf417/decoder/Decoder.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/ext/zxing/zxing-cpp/core/src/zxing/pdf417/decoder/Decoder.h

@@ -0,0 +1,62 @@
+#ifndef __DECOCER_PDF_H__
+#define __DECOCER_PDF_H__
+
+/*
+ *  Decoder.h
+ *  zxing
+ *
+ *  Created by Hartmut Neubauer, 2012-05-25
+ *  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.
+ */
+
+#include <zxing/pdf417/decoder/ec/ErrorCorrection.h>
+#include <zxing/pdf417/decoder/ec/ModulusGF.h>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/DecoderResult.h>
+#include <zxing/common/BitMatrix.h>
+
+
+namespace zxing {
+namespace pdf417 {
+namespace decoder {
+
+/**
+ * <p>The main class which implements PDF417 Code decoding -- as
+ * opposed to locating and extracting the PDF417 Code from an image.</p>
+ *
+ * <p> 2012-06-27 HFN Reed-Solomon error correction activated, see class PDF417RSDecoder. </p>
+ * <p> 2012-09-19 HFN Reed-Solomon error correction via ErrorCorrection/ModulusGF/ModulusPoly. </p>
+ */
+
+class Decoder {
+private:
+  static const int MAX_ERRORS;
+  static const int MAX_EC_CODEWORDS;
+
+  void correctErrors(ArrayRef<int> codewords,
+		ArrayRef<int> erasures, int numECCodewords);
+  static void verifyCodewordCount(ArrayRef<int> codewords, int numECCodewords);
+
+public:
+
+  Ref<DecoderResult> decode(Ref<BitMatrix> bits, DecodeHints const &hints);
+};
+
+}
+}
+}
+
+#endif // __DECOCER_PDF_H__

data/ext/zxing/zxing-cpp/core/src/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;
+}
+