qrscanner 0.1

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

@@ -0,0 +1,205 @@
+#ifndef __COUNTED_H__
+#define __COUNTED_H__
+
+/*
+ *  Counted.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.
+ */
+
+//#define DEBUG_COUNTING
+//using namespace std;
+
+#include <iostream>
+
+#ifdef DEBUG_COUNTING
+#include <typeinfo>
+#endif
+
+namespace zxing {
+
+/* base class for reference-counted objects */
+class Counted {
+private:
+  unsigned int count_;
+public:
+  Counted() :
+      count_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating " << typeid(*this).name() << " " << this <<
+         " @ " << count_ << "\n";
+#endif
+  }
+  virtual ~Counted() {
+  }
+  virtual Counted *retain() {
+#ifdef DEBUG_COUNTING
+    cout << "retaining " << typeid(*this).name() << " " << this <<
+         " @ " << count_;
+#endif
+    count_++;
+#ifdef DEBUG_COUNTING
+    cout << "->" << count_ << "\n";
+#endif
+    return this;
+  }
+  virtual void release() {
+#ifdef DEBUG_COUNTING
+    cout << "releasing " << typeid(*this).name() << " " << this <<
+         " @ " << count_;
+#endif
+    if (count_ == 0 || count_ == 54321) {
+#ifdef DEBUG_COUNTING
+      cout << "\nOverreleasing already-deleted object " << this << "!!!\n";
+#endif
+      throw 4711;
+    }
+    count_--;
+#ifdef DEBUG_COUNTING
+    cout << "->" << count_ << "\n";
+#endif
+    if (count_ == 0) {
+#ifdef DEBUG_COUNTING
+      cout << "deleting " << typeid(*this).name() << " " << this << "\n";
+#endif
+      count_ = 0xDEADF001;
+      delete this;
+    }
+  }
+
+
+  /* return the current count for denugging purposes or similar */
+  int count() const {
+    return count_;
+  }
+};
+
+/* counting reference to reference-counted objects */
+template<typename T> class Ref {
+private:
+public:
+  T *object_;
+  explicit Ref(T *o = 0) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from pointer" << o << "\n";
+#endif
+    reset(o);
+  }
+
+  explicit Ref(const T &o) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from reference\n";
+#endif
+    reset(const_cast<T *>(&o));
+  }
+
+  Ref(const Ref &other) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from Ref " << &other << "\n";
+#endif
+    reset(other.object_);
+  }
+
+  template<class Y>
+  Ref(const Ref<Y> &other) :
+      object_(0) {
+#ifdef DEBUG_COUNTING
+    cout << "instantiating Ref " << this << " from reference\n";
+#endif
+    reset(other.object_);
+  }
+
+  ~Ref() {
+#ifdef DEBUG_COUNTING
+    cout << "destroying Ref " << this << " with " <<
+         (object_ ? typeid(*object_).name() : "NULL") << " " << object_ << "\n";
+#endif
+    if (object_) {
+      object_->release();
+    }
+  }
+
+  void reset(T *o) {
+#ifdef DEBUG_COUNTING
+    cout << "resetting Ref " << this << " from " <<
+         (object_ ? typeid(*object_).name() : "NULL") << " " << object_ <<
+         " to " << (o ? typeid(*o).name() : "NULL") << " " << o << "\n";
+#endif
+    if (o) {
+      o->retain();
+    }
+    if (object_ != 0) {
+      object_->release();
+    }
+    object_ = o;
+  }
+  Ref& operator=(const Ref &other) {
+    reset(other.object_);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(const Ref<Y> &other) {
+    reset(other.object_);
+    return *this;
+  }
+  Ref& operator=(T* o) {
+    reset(o);
+    return *this;
+  }
+  template<class Y>
+  Ref& operator=(Y* o) {
+    reset(o);
+    return *this;
+  }
+
+  T& operator*() {
+    return *object_;
+  }
+  T* operator->() const {
+    return object_;
+  }
+  operator T*() const {
+    return object_;
+  }
+
+  bool operator==(const int x) {
+    return x == 0 ? object_ == 0 : false;
+  }
+  bool operator==(const Ref &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+  template<class Y>
+  bool operator==(const Ref<Y> &other) const {
+    return object_ == other.object_ || *object_ == *(other.object_);
+  }
+
+  bool operator!=(const int x) {
+    return x == 0 ? object_ != 0 : true;
+  }
+
+  bool empty() const {
+    return object_ == 0;
+  }
+
+  template<class Y>
+  friend std::ostream& operator<<(std::ostream &out, Ref<Y>& ref);
+};
+}
+
+#endif // __COUNTED_H__

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

@@ -0,0 +1,37 @@
+/*
+ *  DecoderResult.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/DecoderResult.h>
+
+namespace zxing {
+
+DecoderResult::DecoderResult(ArrayRef<unsigned char> rawBytes, Ref<String> text) :
+    rawBytes_(rawBytes), text_(text) {
+}
+
+ArrayRef<unsigned char> DecoderResult::getRawBytes() {
+  return rawBytes_;
+}
+
+Ref<String> DecoderResult::getText() {
+  return text_;
+}
+
+}

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

@@ -0,0 +1,43 @@
+#ifndef __DECODER_RESULT_H__
+#define __DECODER_RESULT_H__
+
+/*
+ *  DecoderResult.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 <zxing/common/Array.h>
+#include <string>
+#include <zxing/common/Str.h>
+
+namespace zxing {
+
+class DecoderResult : public Counted {
+private:
+  ArrayRef<unsigned char> rawBytes_;
+  Ref<String> text_;
+
+public:
+  DecoderResult(ArrayRef<unsigned char> rawBytes, Ref<String> text);
+  ArrayRef<unsigned char> getRawBytes();
+  Ref<String> getText();
+};
+
+}
+
+#endif // __DECODER_RESULT_H__

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

@@ -0,0 +1,41 @@
+/*
+ *  DetectorResult.cpp
+ *  zxing
+ *
+ *  Created by Christian Brunschen on 14/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/DetectorResult.h>
+
+namespace zxing {
+
+DetectorResult::DetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points, Ref<PerspectiveTransform> transform) :
+    bits_(bits), points_(points), transform_(transform) {
+}
+
+Ref<BitMatrix> DetectorResult::getBits() {
+  return bits_;
+}
+
+std::vector<Ref<ResultPoint> > DetectorResult::getPoints() {
+  return points_;
+}
+
+Ref<PerspectiveTransform> DetectorResult::getTransform() {
+  return transform_;
+}
+
+}

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

@@ -0,0 +1,46 @@
+#ifndef __DETECTOR_RESULT_H__
+#define __DETECTOR_RESULT_H__
+
+/*
+ *  DetectorResult.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 <vector>
+#include <zxing/common/Counted.h>
+#include <zxing/common/Array.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/ResultPoint.h>
+#include <zxing/common/PerspectiveTransform.h>
+
+namespace zxing {
+
+class DetectorResult : public Counted {
+private:
+  Ref<BitMatrix> bits_;
+  std::vector<Ref<ResultPoint> > points_;
+  Ref<PerspectiveTransform> transform_;
+
+public:
+  DetectorResult(Ref<BitMatrix> bits, std::vector<Ref<ResultPoint> > points, Ref<PerspectiveTransform> transform);
+  Ref<BitMatrix> getBits();
+  std::vector<Ref<ResultPoint> > getPoints();
+  Ref<PerspectiveTransform> getTransform();
+};
+}
+
+#endif // __DETECTOR_RESULT_H__

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

@@ -0,0 +1,191 @@
+/*
+ *  EdgeDetector.cpp
+ *  zxing
+ *
+ *  Created by Ralf Kistner on 7/12/2009.
+ *  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/EdgeDetector.h>
+#include <algorithm>
+#include <cmath>
+
+using namespace std;
+
+namespace zxing {
+namespace EdgeDetector {
+
+void findEdgePoints(std::vector<Point>& points, const BitMatrix& image, Point start, Point end, bool invert, int skip, float deviation) {
+  float xdist = end.x - start.x;
+  float ydist = end.y - start.y;
+  float length = sqrt(xdist * xdist + ydist * ydist);
+
+
+  int var;
+
+  if (abs(xdist) > abs(ydist)) {
+    // Horizontal
+    if (xdist < 0)
+      skip = -skip;
+
+    var = int(abs(deviation * length / xdist));
+
+    float dy = ydist / xdist * skip;
+    bool left = (skip < 0) ^ invert;
+    int x = int(start.x);
+
+    int steps = int(xdist / skip);
+    for (int i = 0; i < steps; i++) {
+      x += skip;
+      if (x < 0 || x >= (int)image.getWidth())
+        continue; // In case we start off the edge
+      int my = int(start.y + dy * i);
+      int ey = min(my + var + 1, (int)image.getHeight() - 1);
+      int sy = max(my - var, 0);
+      for (int y = sy + 1; y < ey; y++) {
+        if (left) {
+          if (image.get(x, y) && !image.get(x, y + 1)) {
+            points.push_back(Point(x, y + 0.5f));
+          }
+        } else {
+          if (!image.get(x, y) && image.get(x, y + 1)) {
+            points.push_back(Point(x, y + 0.5f));
+          }
+        }
+      }
+    }
+  } else {
+    // Vertical
+    if (ydist < 0)
+      skip = -skip;
+
+    var = int(abs(deviation * length / ydist));
+
+    float dx = xdist / ydist * skip;
+    bool down = (skip > 0) ^ invert;
+    int y = int(start.y);
+
+    int steps = int(ydist / skip);
+    for (int i = 0; i < steps; i++) {
+      y += skip;
+      if (y < 0 || y >= (int)image.getHeight())
+        continue; // In case we start off the edge
+      int mx = int(start.x + dx * i);
+      int ex = min(mx + var + 1, (int)image.getWidth() - 1);
+      int sx = max(mx - var, 0);
+      for (int x = sx + 1; x < ex; x++) {
+        if (down) {
+          if (image.get(x, y) && !image.get(x + 1, y)) {
+            points.push_back(Point(x + 0.5f, y));
+          }
+
+        } else {
+          if (!image.get(x, y) && image.get(x + 1, y)) {
+            points.push_back(Point(x + 0.5f, y));
+          }
+        }
+
+      }
+    }
+
+  }
+}
+
+Line findLine(const BitMatrix& image, Line estimate, bool invert, int deviation, float threshold, int skip) {
+  float t = threshold * threshold;
+
+  Point start = estimate.start;
+  Point end = estimate.end;
+
+  vector<Point> edges;
+  edges.clear();
+  findEdgePoints(edges, image, start, end, invert, skip, deviation);
+
+  int n = edges.size();
+
+  float xdist = end.x - start.x;
+  float ydist = end.y - start.y;
+
+  bool horizontal = abs(xdist) > abs(ydist);
+
+  float max = 0;
+  Line bestLine(start, end);  // prepopulate with the given line, in case we can't find any line for some reason
+
+  for (int i = -deviation; i < deviation; i++) {
+    float x1, y1;
+    if (horizontal) {
+      y1 = start.y + i;
+      x1 = start.x - i * ydist / xdist;
+    } else {
+      y1 = start.y - i * xdist / ydist;
+      x1 = start.x + i;
+    }
+
+    for (int j = -deviation; j < deviation; j++) {
+      float x2, y2;
+      if (horizontal) {
+        y2 = end.y + j;
+        x2 = end.x - j * ydist / xdist;
+      } else {
+        y2 = end.y - j * xdist / ydist;
+        x2 = end.x + j;
+      }
+
+      float dx = x1 - x2;
+      float dy = y1 - y2;
+      float length = sqrt(dx * dx + dy * dy);
+
+      float score = 0;
+
+      for(int k = 0; k < n; k++) {
+        const Point& edge = edges[k];
+        float dist = ((x1 - edge.x) * dy - (y1 - edge.y) * dx) / length;
+        // Similar to least squares method
+        float s = t - dist * dist;
+        if (s > 0)
+          score += s;
+      }
+
+      if (score > max) {
+        max = score;
+        bestLine.start = Point(x1, y1);
+        bestLine.end = Point(x2, y2);
+      }
+    }
+  }
+
+  return bestLine;
+}
+
+Point intersection(Line a, Line b) {
+  float dxa = a.start.x - a.end.x;
+  float dxb = b.start.x - b.end.x;
+  float dya = a.start.y - a.end.y;
+  float dyb = b.start.y - b.end.y;
+
+  float p = a.start.x * a.end.y - a.start.y * a.end.x;
+  float q = b.start.x * b.end.y - b.start.y * b.end.x;
+  float denom = dxa * dyb - dya * dxb;
+  if(denom == 0)  // Lines don't intersect
+    return Point(INFINITY, INFINITY);
+
+  float x = (p * dxb - dxa * q) / denom;
+  float y = (p * dyb - dya * q) / denom;
+
+  return Point(x, y);
+}
+
+} // namespace EdgeDetector
+} // namespace zxing