zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/GenericGFPoly.h

@@ -0,0 +1,56 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  GenericGFPoly.h
+ *  zxing
+ *
+ *  Created by Lukas Stabe on 13/02/2012.
+ *  Copyright 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.
+ */
+
+#ifndef GENERICGFPOLY_H
+#define GENERICGFPOLY_H
+
+#include <vector>
+#include <zxing/common/Array.h>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+
+class GenericGF;
+  
+class GenericGFPoly : public Counted {
+private:
+  GenericGF &field_;
+  ArrayRef<int> coefficients_;
+    
+public:
+  GenericGFPoly(GenericGF &field, ArrayRef<int> coefficients);
+  ArrayRef<int> getCoefficients();
+  int getDegree();
+  bool isZero();
+  int getCoefficient(int degree);
+  int evaluateAt(int a);
+  Ref<GenericGFPoly> addOrSubtract(Ref<GenericGFPoly> other);
+  Ref<GenericGFPoly> multiply(Ref<GenericGFPoly> other);
+  Ref<GenericGFPoly> multiply(int scalar);
+  Ref<GenericGFPoly> multiplyByMonomial(int degree, int coefficient);
+  std::vector<Ref<GenericGFPoly> > divide(Ref<GenericGFPoly> other);
+    
+
+};
+
+}
+
+#endif //GENERICGFPOLY_H

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/ReedSolomonDecoder.cpp

@@ -0,0 +1,174 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  Created by Christian Brunschen on 05/05/2008.
+ *  Copyright 2008 Google UK. 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 <iostream>
+
+#include <memory>
+#include <zxing/common/reedsolomon/ReedSolomonDecoder.h>
+#include <zxing/common/reedsolomon/ReedSolomonException.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/IllegalStateException.h>
+
+using std::vector;
+using zxing::Ref;
+using zxing::ArrayRef;
+using zxing::ReedSolomonDecoder;
+using zxing::GenericGFPoly;
+using zxing::IllegalStateException;
+
+// VC++
+using zxing::GenericGF;
+
+ReedSolomonDecoder::ReedSolomonDecoder(Ref<GenericGF> field_) : field(field_) {}
+
+ReedSolomonDecoder::~ReedSolomonDecoder() {
+}
+
+void ReedSolomonDecoder::decode(ArrayRef<int> received, int twoS) {
+  Ref<GenericGFPoly> poly(new GenericGFPoly(*field, received));
+  ArrayRef<int> syndromeCoefficients(twoS);
+  bool noError = true;
+  for (int i = 0; i < twoS; i++) {
+    int eval = poly->evaluateAt(field->exp(i + field->getGeneratorBase()));
+    syndromeCoefficients[syndromeCoefficients->size() - 1 - i] = eval;
+    if (eval != 0) {
+      noError = false;
+    }
+  }
+  if (noError) {
+    return;
+  }
+  Ref<GenericGFPoly> syndrome(new GenericGFPoly(*field, syndromeCoefficients));
+  vector<Ref<GenericGFPoly> > sigmaOmega =
+    runEuclideanAlgorithm(field->buildMonomial(twoS, 1), syndrome, twoS);
+  Ref<GenericGFPoly> sigma = sigmaOmega[0];
+  Ref<GenericGFPoly> omega = sigmaOmega[1];
+  ArrayRef<int> errorLocations = findErrorLocations(sigma);
+  ArrayRef<int> errorMagitudes = findErrorMagnitudes(omega, 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] = GenericGF::addOrSubtract(received[position], errorMagitudes[i]);
+  }
+}
+
+vector<Ref<GenericGFPoly> > ReedSolomonDecoder::runEuclideanAlgorithm(Ref<GenericGFPoly> a,
+                                                                      Ref<GenericGFPoly> b,
+                                                                      int R) {
+  // Assume a's degree is >= b's
+  if (a->getDegree() < b->getDegree()) {
+    Ref<GenericGFPoly> tmp = a;
+    a = b;
+    b = tmp;
+  }
+
+  Ref<GenericGFPoly> rLast(a);
+  Ref<GenericGFPoly> r(b);
+  Ref<GenericGFPoly> tLast(field->getZero());
+  Ref<GenericGFPoly> t(field->getOne());
+
+  // Run Euclidean algorithm until r's degree is less than R/2
+  while (r->getDegree() >= R / 2) {
+    Ref<GenericGFPoly> rLastLast(rLast);
+    Ref<GenericGFPoly> tLastLast(tLast);
+    rLast = r;
+    tLast = t;
+
+    // Divide rLastLast by rLast, with quotient q and remainder r
+    if (rLast->isZero()) {
+      // Oops, Euclidean algorithm already terminated?
+      throw ReedSolomonException("r_{i-1} was zero");
+    }
+    r = rLastLast;
+    Ref<GenericGFPoly> 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->addOrSubtract(field->buildMonomial(degreeDiff, scale));
+      r = r->addOrSubtract(rLast->multiplyByMonomial(degreeDiff, scale));
+    }
+
+    t = q->multiply(tLast)->addOrSubtract(tLastLast);
+
+    if (r->getDegree() >= rLast->getDegree()) {
+      throw IllegalStateException("Division algorithm failed to reduce polynomial?");
+    }
+  }
+
+  int sigmaTildeAtZero = t->getCoefficient(0);
+  if (sigmaTildeAtZero == 0) {
+    throw ReedSolomonException("sigmaTilde(0) was zero");
+  }
+
+  int inverse = field->inverse(sigmaTildeAtZero);
+  Ref<GenericGFPoly> sigma(t->multiply(inverse));
+  Ref<GenericGFPoly> omega(r->multiply(inverse));
+  vector<Ref<GenericGFPoly> > result(2);
+  result[0] = sigma;
+  result[1] = omega;
+  return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorLocations(Ref<GenericGFPoly> errorLocator) {
+  // This is a direct application of Chien's search
+  int numErrors = errorLocator->getDegree();
+  if (numErrors == 1) { // shortcut
+    ArrayRef<int> result(new Array<int>(1));
+    result[0] = errorLocator->getCoefficient(1);
+    return result;
+  }
+  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) {
+    throw ReedSolomonException("Error locator degree does not match number of roots");
+  }
+  return result;
+}
+
+ArrayRef<int> ReedSolomonDecoder::findErrorMagnitudes(Ref<GenericGFPoly> errorEvaluator, ArrayRef<int> errorLocations) {
+  // This is directly applying Forney's Formula
+  int s = errorLocations->size();
+  ArrayRef<int> result(new Array<int>(s));
+  for (int i = 0; i < s; i++) {
+    int xiInverse = field->inverse(errorLocations[i]);
+    int denominator = 1;
+    for (int j = 0; j < s; j++) {
+      if (i != j) {
+        int term = field->multiply(errorLocations[j], xiInverse);
+        int termPlus1 = (term & 0x1) == 0 ? term | 1 : term & ~1;
+        denominator = field->multiply(denominator, termPlus1);
+      }
+    }
+    result[i] = field->multiply(errorEvaluator->evaluateAt(xiInverse),
+                                field->inverse(denominator));
+    if (field->getGeneratorBase() != 0) {
+      result[i] = field->multiply(result[i], xiInverse);
+    }
+  }
+  return result;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/ReedSolomonDecoder.h

@@ -0,0 +1,49 @@
+#ifndef __REED_SOLOMON_DECODER_H__
+#define __REED_SOLOMON_DECODER_H__
+
+/*
+ *  ReedSolomonDecoder.h
+ *  zxing
+ *
+ *  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 <memory>
+#include <vector>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/reedsolomon/GenericGFPoly.h>
+#include <zxing/common/reedsolomon/GenericGF.h>
+
+namespace zxing {
+class GenericGFPoly;
+class GenericGF;
+
+class ReedSolomonDecoder {
+private:
+  Ref<GenericGF> field;
+public:
+  ReedSolomonDecoder(Ref<GenericGF> fld);
+  ~ReedSolomonDecoder();
+  void decode(ArrayRef<int> received, int twoS);
+  std::vector<Ref<GenericGFPoly> > runEuclideanAlgorithm(Ref<GenericGFPoly> a, Ref<GenericGFPoly> b, int R);
+
+private:
+  ArrayRef<int> findErrorLocations(Ref<GenericGFPoly> errorLocator);
+  ArrayRef<int> findErrorMagnitudes(Ref<GenericGFPoly> errorEvaluator, ArrayRef<int> errorLocations);
+};
+}
+
+#endif // __REED_SOLOMON_DECODER_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/ReedSolomonException.cpp

@@ -0,0 +1,30 @@
+/*
+ *  ReedSolomonException.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 06/05/2008.
+ *  Copyright 2008 Google UK. 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/common/reedsolomon/ReedSolomonException.h>
+
+namespace zxing {
+ReedSolomonException::ReedSolomonException(const char *msg) throw() :
+    Exception(msg) {
+}
+ReedSolomonException::~ReedSolomonException() throw() {
+}
+
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/reedsolomon/ReedSolomonException.h

@@ -0,0 +1,33 @@
+#ifndef __REED_SOLOMON_EXCEPTION_H__
+#define __REED_SOLOMON_EXCEPTION_H__
+
+/*
+ *  ReedSolomonException.h
+ *  zxing
+ *
+ *  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 <zxing/Exception.h>
+
+namespace zxing {
+class ReedSolomonException : public Exception {
+public:
+  ReedSolomonException(const char *msg) throw();
+  ~ReedSolomonException() throw();
+};
+}
+
+#endif // __REED_SOLOMON_EXCEPTION_H__

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/DataMatrixReader.cpp

@@ -0,0 +1,54 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  DataMatrixReader.cpp
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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 <zxing/datamatrix/DataMatrixReader.h>
+#include <zxing/datamatrix/detector/Detector.h>
+#include <iostream>
+
+namespace zxing {
+namespace datamatrix {
+
+using namespace std;
+
+DataMatrixReader::DataMatrixReader() :
+    decoder_() {
+}
+
+Ref<Result> DataMatrixReader::decode(Ref<BinaryBitmap> image, DecodeHints hints) {
+  (void)hints;
+  Detector detector(image->getBlackMatrix());
+  Ref<DetectorResult> detectorResult(detector.detect());
+  ArrayRef< Ref<ResultPoint> > points(detectorResult->getPoints());
+
+
+  Ref<DecoderResult> decoderResult(decoder_.decode(detectorResult->getBits()));
+
+  Ref<Result> result(
+    new Result(decoderResult->getText(), decoderResult->getRawBytes(), points, BarcodeFormat::DATA_MATRIX));
+
+  return result;
+}
+
+DataMatrixReader::~DataMatrixReader() {
+}
+
+}
+}

data/ext/zxing/zxing-cpp/core/src/zxing/datamatrix/DataMatrixReader.h

@@ -0,0 +1,45 @@
+#ifndef __DATA_MATRIX_READER_H__
+#define __DATA_MATRIX_READER_H__
+
+/*
+ *  DataMatrixReader.h
+ *  zxing
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  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 <zxing/Reader.h>
+#include <zxing/DecodeHints.h>
+#include <zxing/datamatrix/decoder/Decoder.h>
+
+namespace zxing {
+namespace datamatrix {
+
+class DataMatrixReader : public Reader {
+private:
+  Decoder decoder_;
+
+public:
+  DataMatrixReader();
+  virtual Ref<Result> decode(Ref<BinaryBitmap> image, DecodeHints hints);
+  virtual ~DataMatrixReader();
+
+};
+
+}
+}
+
+#endif // __DATA_MATRIX_READER_H__