qrscanner 0.1

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

@@ -0,0 +1,38 @@
+#ifndef __EDGEDETECTOR_H__
+#define __EDGEDETECTOR_H__
+/*
+ *  EdgeDetector.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/BitMatrix.h>
+#include <zxing/common/Point.h>
+
+namespace zxing {
+namespace EdgeDetector {
+
+void findEdgePoints(std::vector<Point>& points, const BitMatrix& image, Point start, Point end, bool invert, int skip, float deviation);
+Line findLine(const BitMatrix& image, Line estimate, bool invert, int deviation, float threshold, int skip);
+
+Point intersection(Line a, Line b);
+
+}
+}
+#endif /* EDGEDETECTOR_H_ */

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

@@ -0,0 +1,209 @@
+/*
+ *  GlobalHistogramBinarizer.cpp
+ *  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/GlobalHistogramBinarizer.h>
+
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+using namespace std;
+
+const int LUMINANCE_BITS = 5;
+const int LUMINANCE_SHIFT = 8 - LUMINANCE_BITS;
+const int LUMINANCE_BUCKETS = 1 << LUMINANCE_BITS;
+
+GlobalHistogramBinarizer::GlobalHistogramBinarizer(Ref<LuminanceSource> source) :
+  Binarizer(source), cached_matrix_(NULL), cached_row_(NULL), cached_row_num_(-1) {
+
+}
+
+GlobalHistogramBinarizer::~GlobalHistogramBinarizer() {
+}
+
+
+Ref<BitArray> GlobalHistogramBinarizer::getBlackRow(int y, Ref<BitArray> row) {
+  if (y == cached_row_num_) {
+    if (cached_row_ != NULL) {
+      return cached_row_;
+    } else {
+      throw IllegalArgumentException("Too little dynamic range in luminance");
+    }
+  }
+
+  vector<int> histogram(LUMINANCE_BUCKETS, 0);
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  if (row == NULL || static_cast<int>(row->getSize()) < width) {
+    row = new BitArray(width);
+  } else {
+    row->clear();
+  }
+
+  //TODO(flyashi): cache this instead of allocating and deleting per row
+  unsigned char* row_pixels = NULL;
+  try {
+    row_pixels = new unsigned char[width];
+    row_pixels = source.getRow(y, row_pixels);
+    for (int x = 0; x < width; x++) {
+      histogram[row_pixels[x] >> LUMINANCE_SHIFT]++;
+    }
+    int blackPoint = estimate(histogram) << LUMINANCE_SHIFT;
+
+    BitArray& array = *row;
+    int left = row_pixels[0];
+    int center = row_pixels[1];
+    for (int x = 1; x < width - 1; x++) {
+      int right = row_pixels[x + 1];
+      // A simple -1 4 -1 box filter with a weight of 2.
+      int luminance = ((center << 2) - left - right) >> 1;
+      if (luminance < blackPoint) {
+        array.set(x);
+      }
+      left = center;
+      center = right;
+    }
+
+    cached_row_ = row;
+    cached_row_num_ = y;
+    delete [] row_pixels;
+    return row;
+  } catch (IllegalArgumentException const& iae) {
+    // Cache the fact that this row failed.
+    cached_row_ = NULL;
+    cached_row_num_ = y;
+    delete [] row_pixels;
+    throw iae;
+  }
+}
+
+Ref<BitMatrix> GlobalHistogramBinarizer::getBlackMatrix() {
+  if (cached_matrix_ != NULL) {
+    return cached_matrix_;
+  }
+
+  // Faster than working with the reference
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  int height = source.getHeight();
+  vector<int> histogram(LUMINANCE_BUCKETS, 0);
+
+  // Quickly calculates the histogram by sampling four rows from the image.
+  // This proved to be more robust on the blackbox tests than sampling a
+  // diagonal as we used to do.
+  unsigned char* row = new unsigned char[width];
+  for (int y = 1; y < 5; y++) {
+    int rownum = height * y / 5;
+    int right = (width << 2) / 5;
+    int sdf;
+    row = source.getRow(rownum, row);
+    for (int x = width / 5; x < right; x++) {
+      histogram[row[x] >> LUMINANCE_SHIFT]++;
+      sdf = histogram[row[x] >> LUMINANCE_SHIFT];
+    }
+  }
+
+  int blackPoint = estimate(histogram) << LUMINANCE_SHIFT;
+
+  Ref<BitMatrix> matrix_ref(new BitMatrix(width, height));
+  BitMatrix& matrix = *matrix_ref;
+  for (int y = 0; y < height; y++) {
+    row = source.getRow(y, row);
+    for (int x = 0; x < width; x++) {
+      if (row[x] <= blackPoint)
+        matrix.set(x, y);
+    }
+  }
+
+  cached_matrix_ = matrix_ref;
+  delete [] row;
+  return matrix_ref;
+}
+
+int GlobalHistogramBinarizer::estimate(vector<int> &histogram) {
+  int numBuckets = histogram.size();
+  int maxBucketCount = 0;
+
+  // Find tallest peak in histogram
+  int firstPeak = 0;
+  int firstPeakSize = 0;
+  for (int i = 0; i < numBuckets; i++) {
+    if (histogram[i] > firstPeakSize) {
+      firstPeak = i;
+      firstPeakSize = histogram[i];
+    }
+    if (histogram[i] > maxBucketCount) {
+      maxBucketCount = histogram[i];
+    }
+  }
+
+  // Find second-tallest peak -- well, another peak that is tall and not
+  // so close to the first one
+  int secondPeak = 0;
+  int secondPeakScore = 0;
+  for (int i = 0; i < numBuckets; i++) {
+    int distanceToBiggest = i - firstPeak;
+    // Encourage more distant second peaks by multiplying by square of distance
+    int score = histogram[i] * distanceToBiggest * distanceToBiggest;
+    if (score > secondPeakScore) {
+      secondPeak = i;
+      secondPeakScore = score;
+    }
+  }
+
+  // Put firstPeak first
+  if (firstPeak > secondPeak) {
+    int temp = firstPeak;
+    firstPeak = secondPeak;
+    secondPeak = temp;
+  }
+
+  // Kind of arbitrary; if the two peaks are very close, then we figure there is
+  // so little dynamic range in the image, that discriminating black and white
+  // is too error-prone.
+  // Decoding the image/line is either pointless, or may in some cases lead to
+  // a false positive for 1D formats, which are relatively lenient.
+  // We arbitrarily say "close" is
+  // "<= 1/16 of the total histogram buckets apart"
+  if (secondPeak - firstPeak <= numBuckets >> 4) {
+    throw IllegalArgumentException("Too little dynamic range in luminance");
+  }
+
+  // Find a valley between them that is low and closer to the white peak
+  int bestValley = secondPeak - 1;
+  int bestValleyScore = -1;
+  for (int i = secondPeak - 1; i > firstPeak; i--) {
+    int fromFirst = i - firstPeak;
+    // Favor a "valley" that is not too close to either peak -- especially not
+    // the black peak -- and that has a low value of course
+    int score = fromFirst * fromFirst * (secondPeak - i) *
+      (maxBucketCount - histogram[i]);
+    if (score > bestValleyScore) {
+      bestValley = i;
+      bestValleyScore = score;
+    }
+  }
+
+  return bestValley;
+}
+
+Ref<Binarizer> GlobalHistogramBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+  return Ref<Binarizer> (new GlobalHistogramBinarizer(source));
+}
+
+} // namespace zxing

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

@@ -0,0 +1,47 @@
+#ifndef __GLOBALHISTOGRAMBINARIZER_H__
+#define __GLOBALHISTOGRAMBINARIZER_H__
+/*
+ *  GlobalHistogramBinarizer.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/Binarizer.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/common/BitMatrix.h>
+
+namespace zxing {
+	
+	class GlobalHistogramBinarizer : public Binarizer {
+	 private:
+    Ref<BitMatrix> cached_matrix_;
+	  Ref<BitArray> cached_row_;
+	  int cached_row_num_;
+
+	public:
+		GlobalHistogramBinarizer(Ref<LuminanceSource> source);
+		virtual ~GlobalHistogramBinarizer();
+		
+		virtual Ref<BitArray> getBlackRow(int y, Ref<BitArray> row);
+		virtual Ref<BitMatrix> getBlackMatrix();
+		static int estimate(std::vector<int> &histogram);
+		Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source);
+	};
+	
+}
+
+#endif /* GLOBALHISTOGRAMBINARIZER_H_ */

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

@@ -0,0 +1,70 @@
+/*
+ *  GreyscaleLuminanceSource.cpp
+ *  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/GreyscaleLuminanceSource.h>
+#include <zxing/common/GreyscaleRotatedLuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+
+GreyscaleLuminanceSource::GreyscaleLuminanceSource(unsigned char* greyData, int dataWidth,
+    int dataHeight, int left, int top, int width, int height) : greyData_(greyData),
+    dataWidth_(dataWidth), dataHeight_(dataHeight), left_(left), top_(top), width_(width),
+    height_(height) {
+
+  if (left + width > dataWidth || top + height > dataHeight || top < 0 || left < 0) {
+    throw IllegalArgumentException("Crop rectangle does not fit within image data.");
+  }
+}
+
+unsigned char* GreyscaleLuminanceSource::getRow(int y, unsigned char* row) {
+  if (y < 0 || y >= this->getHeight()) {
+    throw IllegalArgumentException("Requested row is outside the image: " + y);
+  }
+  int width = getWidth();
+  // TODO(flyashi): determine if row has enough size.
+  if (row == NULL) {
+    row = new unsigned char[width_];
+  }
+  int offset = (y + top_) * dataWidth_ + left_;
+  memcpy(row, &greyData_[offset], width);
+  return row;
+}
+
+unsigned char* GreyscaleLuminanceSource::getMatrix() {
+  int size = width_ * height_;
+  unsigned char* result = new unsigned char[size];
+  if (left_ == 0 && top_ == 0 && dataWidth_ == width_ && dataHeight_ == height_) {
+    memcpy(result, greyData_, size);
+  } else {
+    for (int row = 0; row < height_; row++) {
+      memcpy(result + row * width_, greyData_ + (top_ + row) * dataWidth_ + left_, width_);
+    }
+  }
+  return result;
+}
+
+Ref<LuminanceSource> GreyscaleLuminanceSource::rotateCounterClockwise() {
+  // Intentionally flip the left, top, width, and height arguments as needed. dataWidth and
+  // dataHeight are always kept unrotated.
+  return Ref<LuminanceSource> (new GreyscaleRotatedLuminanceSource(greyData_, dataWidth_,
+      dataHeight_, top_, left_, height_, width_));
+}
+
+} /* namespace */

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

@@ -0,0 +1,62 @@
+#ifndef __GREYSCALE_LUMINANCE_SOURCE__
+#define __GREYSCALE_LUMINANCE_SOURCE__
+/*
+ *  GreyscaleLuminanceSource.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/LuminanceSource.h>
+
+namespace zxing {
+
+class GreyscaleLuminanceSource : public LuminanceSource {
+
+ private:
+  unsigned char* greyData_;
+  int dataWidth_;
+  int dataHeight_;
+  int left_;
+  int top_;
+  int width_;
+  int height_;
+
+ public:
+  GreyscaleLuminanceSource(unsigned char* greyData, int dataWidth, int dataHeight, int left,
+      int top, int width, int height);
+
+  unsigned char* getRow(int y, unsigned char* row);
+  unsigned char* getMatrix();
+
+  bool isRotateSupported() const {
+    return true;
+  }
+
+  int getWidth() const {
+    return width_;
+  }
+
+  int getHeight() const {
+    return height_;
+  }
+
+  Ref<LuminanceSource> rotateCounterClockwise();
+
+};
+
+} /* namespace */
+
+#endif

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

@@ -0,0 +1,65 @@
+/*
+ *  GreyscaleRotatedLuminanceSource.cpp
+ *  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/GreyscaleRotatedLuminanceSource.h>
+#include <zxing/common/IllegalArgumentException.h>
+
+namespace zxing {
+
+// Note that dataWidth and dataHeight are not reversed, as we need to be able to traverse the
+// greyData correctly, which does not get rotated.
+GreyscaleRotatedLuminanceSource::GreyscaleRotatedLuminanceSource(unsigned char* greyData,
+    int dataWidth, int dataHeight, int left, int top, int width, int height) : greyData_(greyData),
+    dataWidth_(dataWidth), dataHeight_(dataHeight), left_(left), top_(top), width_(width),
+    height_(height) {
+
+  // Intentionally comparing to the opposite dimension since we're rotated.
+  if (left + width > dataHeight || top + height > dataWidth) {
+    throw IllegalArgumentException("Crop rectangle does not fit within image data.");
+  }
+}
+
+// The API asks for rows, but we're rotated, so we return columns.
+unsigned char* GreyscaleRotatedLuminanceSource::getRow(int y, unsigned char* row) {
+  if (y < 0 || y >= getHeight()) {
+    throw IllegalArgumentException("Requested row is outside the image: " + y);
+  }
+  int width = getWidth();
+  if (row == NULL) {
+    row = new unsigned char[width];
+  }
+  int offset = (left_ * dataWidth_) + (dataWidth_ - (y + top_));
+  for (int x = 0; x < width; x++) {
+    row[x] = greyData_[offset];
+    offset += dataWidth_;
+  }
+  return row;
+}
+
+unsigned char* GreyscaleRotatedLuminanceSource::getMatrix() {
+  unsigned char* result = new unsigned char[width_ * height_];
+  // This depends on getRow() honoring its second parameter.
+  for (int y = 0; y < height_; y++) {
+    getRow(y, &result[y * width_]);
+  }
+  return result;
+}
+
+} // namespace