qrscanner 0.1

data/ext/qrscanner/zxing/core/src/zxing/common/IllegalArgumentException.h

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

data/ext/qrscanner/zxing/core/src/zxing/common/PerspectiveTransform.cpp

@@ -0,0 +1,107 @@
+/*
+ *  PerspectiveTransform.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 12/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/PerspectiveTransform.h>
+
+namespace zxing {
+using namespace std;
+
+PerspectiveTransform::PerspectiveTransform(float inA11, float inA21, 
+                                           float inA31, float inA12, 
+                                           float inA22, float inA32, 
+                                           float inA13, float inA23, 
+                                           float inA33) : 
+  a11(inA11), a12(inA12), a13(inA13), a21(inA21), a22(inA22), a23(inA23),
+  a31(inA31), a32(inA32), a33(inA33) {}
+
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1,
+    float x2, float y2, float x3, float y3, float x0p, float y0p, float x1p, float y1p, float x2p, float y2p,
+    float x3p, float y3p) {
+  Ref<PerspectiveTransform> qToS = PerspectiveTransform::quadrilateralToSquare(x0, y0, x1, y1, x2, y2, x3, y3);
+  Ref<PerspectiveTransform> sToQ =
+    PerspectiveTransform::squareToQuadrilateral(x0p, y0p, x1p, y1p, x2p, y2p, x3p, y3p);
+  return sToQ->times(qToS);
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2,
+    float y2, float x3, float y3) {
+  float dy2 = y3 - y2;
+  float dy3 = y0 - y1 + y2 - y3;
+  if (dy2 == 0.0f && dy3 == 0.0f) {
+    Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0, x2 - x1, x0, y1 - y0, y2 - y1, y0, 0.0f,
+                                     0.0f, 1.0f));
+    return result;
+  } else {
+    float dx1 = x1 - x2;
+    float dx2 = x3 - x2;
+    float dx3 = x0 - x1 + x2 - x3;
+    float dy1 = y1 - y2;
+    float denominator = dx1 * dy2 - dx2 * dy1;
+    float a13 = (dx3 * dy2 - dx2 * dy3) / denominator;
+    float a23 = (dx1 * dy3 - dx3 * dy1) / denominator;
+    Ref<PerspectiveTransform> result(new PerspectiveTransform(x1 - x0 + a13 * x1, x3 - x0 + a23 * x3, x0, y1 - y0
+                                     + a13 * y1, y3 - y0 + a23 * y3, y0, a13, a23, 1.0f));
+    return result;
+  }
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2,
+    float y2, float x3, float y3) {
+  // Here, the adjoint serves as the inverse:
+  return squareToQuadrilateral(x0, y0, x1, y1, x2, y2, x3, y3)->buildAdjoint();
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::buildAdjoint() {
+  // Adjoint is the transpose of the cofactor matrix:
+  Ref<PerspectiveTransform> result(new PerspectiveTransform(a22 * a33 - a23 * a32, a23 * a31 - a21 * a33, a21 * a32
+                                   - a22 * a31, a13 * a32 - a12 * a33, a11 * a33 - a13 * a31, a12 * a31 - a11 * a32, a12 * a23 - a13 * a22,
+                                   a13 * a21 - a11 * a23, a11 * a22 - a12 * a21));
+  return result;
+}
+
+Ref<PerspectiveTransform> PerspectiveTransform::times(Ref<PerspectiveTransform> other) {
+  Ref<PerspectiveTransform> result(new PerspectiveTransform(a11 * other->a11 + a21 * other->a12 + a31 * other->a13,
+                                   a11 * other->a21 + a21 * other->a22 + a31 * other->a23, a11 * other->a31 + a21 * other->a32 + a31
+                                   * other->a33, a12 * other->a11 + a22 * other->a12 + a32 * other->a13, a12 * other->a21 + a22
+                                   * other->a22 + a32 * other->a23, a12 * other->a31 + a22 * other->a32 + a32 * other->a33, a13
+                                   * other->a11 + a23 * other->a12 + a33 * other->a13, a13 * other->a21 + a23 * other->a22 + a33
+                                   * other->a23, a13 * other->a31 + a23 * other->a32 + a33 * other->a33));
+  return result;
+}
+
+void PerspectiveTransform::transformPoints(vector<float> &points) {
+  int max = points.size();
+  for (int i = 0; i < max; i += 2) {
+    float x = points[i];
+    float y = points[i + 1];
+    float denominator = a13 * x + a23 * y + a33;
+    points[i] = (a11 * x + a21 * y + a31) / denominator;
+    points[i + 1] = (a12 * x + a22 * y + a32) / denominator;
+  }
+}
+
+ostream& operator<<(ostream& out, const PerspectiveTransform &pt) {
+  out << pt.a11 << ", " << pt.a12 << ", " << pt.a13 << ", \n";
+  out << pt.a21 << ", " << pt.a22 << ", " << pt.a23 << ", \n";
+  out << pt.a31 << ", " << pt.a32 << ", " << pt.a33 << "\n";
+  return out;
+}
+
+}

data/ext/qrscanner/zxing/core/src/zxing/common/PerspectiveTransform.h

@@ -0,0 +1,49 @@
+#ifndef __PERSPECTIVE_TANSFORM_H__
+#define __PERSPECTIVE_TANSFORM_H__
+
+/*
+ *  PerspectiveTransform.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/common/Counted.h>
+#include <vector>
+
+namespace zxing {
+class PerspectiveTransform : public Counted {
+private:
+  float a11, a12, a13, a21, a22, a23, a31, a32, a33;
+  PerspectiveTransform(float a11, float a21, float a31, float a12, float a22, float a32, float a13, float a23,
+                       float a33);
+
+public:
+  static Ref<PerspectiveTransform>
+  quadrilateralToQuadrilateral(float x0, float y0, float x1, float y1, float x2, float y2, float x3, float y3,
+                               float x0p, float y0p, float x1p, float y1p, float x2p, float y2p, float x3p, float y3p);
+  static Ref<PerspectiveTransform> squareToQuadrilateral(float x0, float y0, float x1, float y1, float x2, float y2,
+      float x3, float y3);
+  static Ref<PerspectiveTransform> quadrilateralToSquare(float x0, float y0, float x1, float y1, float x2, float y2,
+      float x3, float y3);
+  Ref<PerspectiveTransform> buildAdjoint();
+  Ref<PerspectiveTransform> times(Ref<PerspectiveTransform> other);
+  void transformPoints(std::vector<float> &points);
+
+  friend std::ostream& operator<<(std::ostream& out, const PerspectiveTransform &pt);
+};
+}
+
+#endif // __PERSPECTIVE_TANSFORM_H__

data/ext/qrscanner/zxing/core/src/zxing/common/Point.h

@@ -0,0 +1,47 @@
+#ifndef __POINT_H__
+#define __POINT_H__
+
+/*
+ *  Point.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.
+ */
+
+namespace zxing {
+class PointI {
+public:
+  int x;
+  int y;
+};
+
+class Point {
+public:
+  Point() : x(0.0f), y(0.0f) {};
+  Point(float x_, float y_) : x(x_), y(y_) {};
+
+  float x;
+  float y;
+};
+
+class Line {
+public:
+  Line(Point start_, Point end_) : start(start_), end(end_) {};
+
+  Point start;
+  Point end;
+};
+}
+#endif // POINT_H_

data/ext/qrscanner/zxing/core/src/zxing/common/Str.cpp

@@ -0,0 +1,38 @@
+/*
+ *  String.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 20/05/2008.
+ *  Copyright 2008 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/common/Str.h>
+
+namespace zxing {
+using namespace std;
+
+String::String(const std::string &text) :
+    text_(text) {
+}
+const std::string& String::getText() const {
+  return text_;
+}
+
+ostream &operator<<(ostream &out, const String &s) {
+  out << s.text_;
+  return out;
+}
+
+}

data/ext/qrscanner/zxing/core/src/zxing/common/Str.h

@@ -0,0 +1,40 @@
+#ifndef __STR_H__
+#define __STR_H__
+
+/*
+ *  Str.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 <string>
+#include <iostream>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+
+class String : public Counted {
+private:
+  std::string text_;
+public:
+  String(const std::string &text);
+  const std::string &getText() const;
+  friend std::ostream &operator<<(std::ostream &out, const String &s);
+};
+
+}
+
+#endif // __COMMON__STRING_H__

data/ext/qrscanner/zxing/core/src/zxing/common/reedsolomon/GF256.cpp

@@ -0,0 +1,136 @@
+/*
+ *  GF256.cpp
+ *  zxing
+ *
+ *  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 <vector>
+#include <iostream>
+#include <zxing/common/reedsolomon/GF256.h>
+#include <zxing/common/reedsolomon/GF256Poly.h>
+#include <zxing/common/IllegalArgumentException.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/Counted.h>
+
+namespace zxing {
+using namespace std;
+
+static inline ArrayRef<int> makeArray(int value) {
+  ArrayRef<int> valuesRef(new Array<int> (value, 1));
+  return valuesRef;
+}
+
+static inline Ref<GF256Poly> refPoly(GF256 &field, int value) {
+  ArrayRef<int> values(makeArray(value));
+  Ref<GF256Poly> result(new GF256Poly(field, values));
+  return result;
+}
+
+GF256::GF256(int primitive) :
+    exp_(256, (const int)0), log_(256, (const int)0), zero_(refPoly(*this, 0)), one_(refPoly(*this, 1)) {
+  int x = 1;
+  for (int i = 0; i < 256; i++) {
+    exp_[i] = x;
+    x <<= 1;
+    if (x >= 0x100) {
+      x ^= primitive;
+    }
+  }
+
+  // log(0) == 0, but should never be used
+  log_[0] = 0;
+  for (int i = 0; i < 255; i++) {
+    log_[exp_[i]] = i;
+  }
+}
+
+Ref<GF256Poly> GF256::getZero() {
+  return zero_;
+}
+
+Ref<GF256Poly> GF256::getOne() {
+  return one_;
+}
+
+Ref<GF256Poly> GF256::buildMonomial(int degree, int coefficient) {
+#ifdef DEBUG
+  cout << __FUNCTION__ << "\n";
+#endif
+  if (degree < 0) {
+    throw IllegalArgumentException("Degree must be non-negative");
+  }
+  if (coefficient == 0) {
+    return zero_;
+  }
+  int nCoefficients = degree + 1;
+  ArrayRef<int> coefficients(new Array<int> (nCoefficients));
+  coefficients[0] = coefficient;
+  Ref<GF256Poly> result(new GF256Poly(*this, coefficients));
+  return result;
+}
+
+int GF256::addOrSubtract(int a, int b) {
+  return a ^ b;
+}
+
+int GF256::exp(int a) {
+  return exp_[a];
+}
+
+int GF256::log(int a) {
+  if (a == 0) {
+    throw IllegalArgumentException("Cannot take the logarithm of 0");
+  }
+  return log_[a];
+}
+
+int GF256::inverse(int a) {
+  if (a == 0) {
+    throw IllegalArgumentException("Cannot calculate the inverse of 0");
+  }
+  return exp_[255 - log_[a]];
+}
+
+int GF256::multiply(int a, int b) {
+  if (a == 0 || b == 0) {
+    return 0;
+  }
+  int logSum = log_[a] + log_[b];
+  // index is a sped-up alternative to logSum % 255 since sum
+  // is in [0,510]. Thanks to jmsachs for the idea
+  return exp_[(logSum & 0xFF) + (logSum >> 8)];
+}
+
+GF256 GF256::QR_CODE_FIELD(0x011D); // x^8 + x^4 + x^3 + x^2 + 1
+GF256 GF256::DATA_MATRIX_FIELD(0x012D); // x^8 + x^5 + x^3 + x^2 + 1
+
+ostream& operator<<(ostream& out, const GF256& field) {
+  out << "Field[\nexp=(";
+  out << field.exp_[0];
+  for (int i = 1; i < 256; i++) {
+    out << "," << field.exp_[i];
+  }
+  out << "),\nlog=(";
+  out << field.log_[0];
+  for (int i = 1; i < 256; i++) {
+    out << "," << field.log_[i];
+  }
+  out << ")\n]";
+  return out;
+}
+
+}