zxing_cpp 0.1.0

data/ext/zxing/zxing-cpp/core/src/zxing/common/HybridBinarizer.cpp

@@ -0,0 +1,226 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  HybridBinarizer.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/HybridBinarizer.h>
+
+#include <zxing/common/IllegalArgumentException.h>
+
+using namespace std;
+using namespace zxing;
+
+namespace {
+  const int BLOCK_SIZE_POWER = 3;
+  const int BLOCK_SIZE = 1 << BLOCK_SIZE_POWER; // ...0100...00
+  const int BLOCK_SIZE_MASK = BLOCK_SIZE - 1;   // ...0011...11
+  const int MINIMUM_DIMENSION = BLOCK_SIZE * 5;
+}
+
+HybridBinarizer::HybridBinarizer(Ref<LuminanceSource> source) :
+  GlobalHistogramBinarizer(source), matrix_(NULL), cached_row_(NULL) {
+}
+
+HybridBinarizer::~HybridBinarizer() {
+}
+
+
+Ref<Binarizer>
+HybridBinarizer::createBinarizer(Ref<LuminanceSource> source) {
+  return Ref<Binarizer> (new HybridBinarizer(source));
+}
+
+
+/**
+ * Calculates the final BitMatrix once for all requests. This could be called once from the
+ * constructor instead, but there are some advantages to doing it lazily, such as making
+ * profiling easier, and not doing heavy lifting when callers don't expect it.
+ */
+Ref<BitMatrix> HybridBinarizer::getBlackMatrix() {
+  if (matrix_) {
+    return matrix_;
+  }
+  LuminanceSource& source = *getLuminanceSource();
+  int width = source.getWidth();
+  int height = source.getHeight();
+  if (width >= MINIMUM_DIMENSION && height >= MINIMUM_DIMENSION) {
+    ArrayRef<char> luminances = source.getMatrix();
+    int subWidth = width >> BLOCK_SIZE_POWER;
+    if ((width & BLOCK_SIZE_MASK) != 0) {
+      subWidth++;
+    }
+    int subHeight = height >> BLOCK_SIZE_POWER;
+    if ((height & BLOCK_SIZE_MASK) != 0) {
+      subHeight++;
+    }
+    ArrayRef<int> blackPoints =
+      calculateBlackPoints(luminances, subWidth, subHeight, width, height);
+
+    Ref<BitMatrix> newMatrix (new BitMatrix(width, height));
+    calculateThresholdForBlock(luminances,
+                               subWidth,
+                               subHeight,
+                               width,
+                               height,
+                               blackPoints,
+                               newMatrix);
+    matrix_ = newMatrix;
+  } else {
+    // If the image is too small, fall back to the global histogram approach.
+    matrix_ = GlobalHistogramBinarizer::getBlackMatrix();
+  }
+  return matrix_;
+}
+
+namespace {
+  inline int cap(int value, int min, int max) {
+    return value < min ? min : value > max ? max : value;
+  }
+}
+
+void
+HybridBinarizer::calculateThresholdForBlock(ArrayRef<char> luminances,
+                                            int subWidth,
+                                            int subHeight,
+                                            int width,
+                                            int height,
+                                            ArrayRef<int> blackPoints,
+                                            Ref<BitMatrix> const& matrix) {
+  for (int y = 0; y < subHeight; y++) {
+    int yoffset = y << BLOCK_SIZE_POWER;
+    int maxYOffset = height - BLOCK_SIZE;
+    if (yoffset > maxYOffset) {
+      yoffset = maxYOffset;
+    }
+    for (int x = 0; x < subWidth; x++) {
+      int xoffset = x << BLOCK_SIZE_POWER;
+      int maxXOffset = width - BLOCK_SIZE;
+      if (xoffset > maxXOffset) {
+        xoffset = maxXOffset;
+      }
+      int left = cap(x, 2, subWidth - 3);
+      int top = cap(y, 2, subHeight - 3);
+      int sum = 0;
+      for (int z = -2; z <= 2; z++) {
+        int *blackRow = &blackPoints[(top + z) * subWidth];
+        sum += blackRow[left - 2];
+        sum += blackRow[left - 1];
+        sum += blackRow[left];
+        sum += blackRow[left + 1];
+        sum += blackRow[left + 2];
+      }
+      int average = sum / 25;
+      thresholdBlock(luminances, xoffset, yoffset, average, width, matrix);
+    }
+  }
+}
+
+void HybridBinarizer::thresholdBlock(ArrayRef<char> luminances,
+                                     int xoffset,
+                                     int yoffset,
+                                     int threshold,
+                                     int stride,
+                                     Ref<BitMatrix> const& matrix) {
+  for (int y = 0, offset = yoffset * stride + xoffset;
+       y < BLOCK_SIZE;
+       y++,  offset += stride) {
+    for (int x = 0; x < BLOCK_SIZE; x++) {
+      int pixel = luminances[offset + x] & 0xff;
+      if (pixel <= threshold) {
+        matrix->set(xoffset + x, yoffset + y);
+      }
+    }
+  }
+}
+
+namespace {
+  inline int getBlackPointFromNeighbors(ArrayRef<int> blackPoints, int subWidth, int x, int y) {
+    return (blackPoints[(y-1)*subWidth+x] +
+            2*blackPoints[y*subWidth+x-1] +
+            blackPoints[(y-1)*subWidth+x-1]) >> 2;
+  }
+}
+
+
+ArrayRef<int> HybridBinarizer::calculateBlackPoints(ArrayRef<char> luminances,
+                                                    int subWidth,
+                                                    int subHeight,
+                                                    int width,
+                                                    int height) {
+  const int minDynamicRange = 24;
+
+  ArrayRef<int> blackPoints (subHeight * subWidth);
+  for (int y = 0; y < subHeight; y++) {
+    int yoffset = y << BLOCK_SIZE_POWER;
+    int maxYOffset = height - BLOCK_SIZE;
+    if (yoffset > maxYOffset) {
+      yoffset = maxYOffset;
+    }
+    for (int x = 0; x < subWidth; x++) {
+      int xoffset = x << BLOCK_SIZE_POWER;
+      int maxXOffset = width - BLOCK_SIZE;
+      if (xoffset > maxXOffset) {
+        xoffset = maxXOffset;
+      }
+      int sum = 0;
+      int min = 0xFF;
+      int max = 0;
+      for (int yy = 0, offset = yoffset * width + xoffset;
+           yy < BLOCK_SIZE;
+           yy++, offset += width) {
+        for (int xx = 0; xx < BLOCK_SIZE; xx++) {
+          int pixel = luminances[offset + xx] & 0xFF;
+          sum += pixel;
+          // still looking for good contrast
+          if (pixel < min) {
+            min = pixel;
+          }
+          if (pixel > max) {
+            max = pixel;
+          }
+        }
+
+        // short-circuit min/max tests once dynamic range is met
+        if (max - min > minDynamicRange) {
+          // finish the rest of the rows quickly
+          for (yy++, offset += width; yy < BLOCK_SIZE; yy++, offset += width) {
+            for (int xx = 0; xx < BLOCK_SIZE; xx += 2) {
+              sum += luminances[offset + xx] & 0xFF;
+              sum += luminances[offset + xx + 1] & 0xFF;
+            }
+          }
+        }
+      }
+      // See
+      // http://groups.google.com/group/zxing/browse_thread/thread/d06efa2c35a7ddc0
+      int average = sum >> (BLOCK_SIZE_POWER * 2);
+      if (max - min <= minDynamicRange) {
+        average = min >> 1;
+        if (y > 0 && x > 0) {
+          int bp = getBlackPointFromNeighbors(blackPoints, subWidth, x, y);
+          if (min < bp) {
+            average = bp;
+          }
+        }
+      }
+      blackPoints[y * subWidth + x] = average;
+    }
+  }
+  return blackPoints;
+}
+

data/ext/zxing/zxing-cpp/core/src/zxing/common/HybridBinarizer.h

@@ -0,0 +1,67 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __HYBRIDBINARIZER_H__
+#define __HYBRIDBINARIZER_H__
+/*
+ *  HybridBinarizer.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/GlobalHistogramBinarizer.h>
+#include <zxing/common/BitArray.h>
+#include <zxing/common/BitMatrix.h>
+
+namespace zxing {
+	
+	class HybridBinarizer : public GlobalHistogramBinarizer {
+	 private:
+    Ref<BitMatrix> matrix_;
+	  Ref<BitArray> cached_row_;
+
+	public:
+		HybridBinarizer(Ref<LuminanceSource> source);
+		virtual ~HybridBinarizer();
+		
+		virtual Ref<BitMatrix> getBlackMatrix();
+		Ref<Binarizer> createBinarizer(Ref<LuminanceSource> source);
+  private:
+    // We'll be using one-D arrays because C++ can't dynamically allocate 2D
+    // arrays
+    ArrayRef<int> calculateBlackPoints(ArrayRef<char> luminances,
+                                       int subWidth,
+                                       int subHeight,
+                                       int width,
+                                       int height);
+    void calculateThresholdForBlock(ArrayRef<char> luminances,
+                                    int subWidth,
+                                    int subHeight,
+                                    int width,
+                                    int height,
+                                    ArrayRef<int> blackPoints,
+                                    Ref<BitMatrix> const& matrix);
+    void thresholdBlock(ArrayRef<char>luminances,
+                        int xoffset,
+                        int yoffset,
+                        int threshold,
+                        int stride,
+                        Ref<BitMatrix> const& matrix);
+	};
+
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/common/IllegalArgumentException.cpp

@@ -0,0 +1,27 @@
+/*
+ *  IllegalArgumentException.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/IllegalArgumentException.h>
+
+using zxing::IllegalArgumentException;
+
+IllegalArgumentException::IllegalArgumentException() : Exception() {}
+IllegalArgumentException::IllegalArgumentException(const char *msg) : Exception(msg) {}
+IllegalArgumentException::~IllegalArgumentException() throw() {}

data/ext/zxing/zxing-cpp/core/src/zxing/common/IllegalArgumentException.h

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

data/ext/zxing/zxing-cpp/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 dx3 = x0 - x1 + x2 - x3;
+  float dy3 = y0 - y1 + y2 - y3;
+  if (dx3 == 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 dy1 = y1 - y2;
+    float dy2 = y3 - 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;
+}
+
+}