zxing_cpp_no_cmake 0.1.1

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/JavaMath.h

@@ -0,0 +1,43 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __ZXING_COMMON_DETECTOR_MATH_H__
+#define __ZXING_COMMON_DETECTOR_MATH_H__
+/*
+ *  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.
+ */
+
+#include <cmath>
+
+namespace zxing {
+namespace common {
+namespace detector {
+
+class Math {
+ private:
+  Math();
+  ~Math();
+ public:
+
+  // Java standard Math.round
+  static inline int round(float a) {
+    return (int)std::floor(a +0.5f);
+  }
+
+};
+
+}
+}
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/MathUtils.h

@@ -0,0 +1,57 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+#ifndef __ZXING_COMMON_DETECTOR_MATHUTILS_H__
+#define __ZXING_COMMON_DETECTOR_MATHUTILS_H__
+/*
+ *  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.
+ */
+
+#include <cmath>
+
+namespace zxing {
+namespace common {
+namespace detector {
+
+class MathUtils {
+ private:
+  MathUtils();
+  ~MathUtils();
+ public:
+
+  /**
+   * Ends up being a bit faster than {@link Math#round(float)}. This merely rounds its
+   * argument to the nearest int, where x.5 rounds up to x+1.
+   */
+  static inline int round(float d) {
+    return (int) (d + 0.5f);
+  }
+
+  static inline float distance(float aX, float aY, float bX, float bY) {
+    float xDiff = aX - bX;
+    float yDiff = aY - bY;
+    return sqrt(xDiff * xDiff + yDiff * yDiff);
+  }
+
+  static inline float distance(int aX, int aY, int bX, int bY) {
+    int xDiff = aX - bX;
+    int yDiff = aY - bY;
+    return sqrt(float(xDiff * xDiff + yDiff * yDiff));
+  }
+};
+
+}
+}
+}
+
+#endif

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/MonochromeRectangleDetector.cpp

@@ -0,0 +1,175 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  MonochromeRectangleDetector.cpp
+ *  y_wmk
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 y_wmk 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/NotFoundException.h>
+#include <zxing/common/detector/MonochromeRectangleDetector.h>
+#include <sstream>
+#include <algorithm>  // vs12, std::min und std:max
+
+using std::vector;
+using zxing::Ref;
+using zxing::ResultPoint;
+using zxing::TwoInts;
+using zxing::MonochromeRectangleDetector;
+
+vector<Ref<ResultPoint> > MonochromeRectangleDetector::detect() {
+  int height = image_->getHeight();
+  int width = image_->getWidth();
+  int halfHeight = height >> 1;
+  int halfWidth = width >> 1;
+  int deltaY = std::max(1, height / (MAX_MODULES << 3));
+  int deltaX = std::max(1, width / (MAX_MODULES << 3));
+
+  int top = 0;
+  int bottom = height;
+  int left = 0;
+  int right = width;
+  Ref<ResultPoint> pointA(findCornerFromCenter(halfWidth, 0, left, right,
+                                               halfHeight, -deltaY, top, bottom, halfWidth >> 1));
+  top = (int) pointA->getY() - 1;;
+  Ref<ResultPoint> pointB(findCornerFromCenter(halfWidth, -deltaX, left, right,
+                                               halfHeight, 0, top, bottom, halfHeight >> 1));
+  left = (int) pointB->getX() - 1;
+  Ref<ResultPoint> pointC(findCornerFromCenter(halfWidth, deltaX, left, right,
+                                               halfHeight, 0, top, bottom, halfHeight >> 1));
+  right = (int) pointC->getX() + 1;
+  Ref<ResultPoint> pointD(findCornerFromCenter(halfWidth, 0, left, right,
+                                               halfHeight, deltaY, top, bottom, halfWidth >> 1));
+  bottom = (int) pointD->getY() + 1;
+
+  // Go try to find point A again with better information -- might have been off at first.
+  pointA.reset(findCornerFromCenter(halfWidth, 0, left, right,
+                                    halfHeight, -deltaY, top, bottom, halfWidth >> 2));
+
+  vector<Ref<ResultPoint> > corners(4);
+  corners[0].reset(pointA);
+  corners[1].reset(pointB);
+  corners[2].reset(pointC);
+  corners[3].reset(pointD);
+  return corners;
+}
+
+Ref<ResultPoint> MonochromeRectangleDetector::findCornerFromCenter(int centerX, int deltaX, int left, int right,
+                                                                   int centerY, int deltaY, int top, int bottom, int maxWhiteRun) {
+  Ref<TwoInts> lastRange(NULL);
+  for (int y = centerY, x = centerX;
+       y < bottom && y >= top && x < right && x >= left;
+       y += deltaY, x += deltaX) {
+    Ref<TwoInts> range(NULL);
+    if (deltaX == 0) {
+      // horizontal slices, up and down
+      range = blackWhiteRange(y, maxWhiteRun, left, right, true);
+    } else {
+      // vertical slices, left and right
+      range = blackWhiteRange(x, maxWhiteRun, top, bottom, false);
+    }
+    if (range == NULL) {
+      if (lastRange == NULL) {
+        throw NotFoundException("Couldn't find corners (lastRange = NULL) ");
+      } else {
+        // lastRange was found
+        if (deltaX == 0) {
+          int lastY = y - deltaY;
+          if (lastRange->start < centerX) {
+            if (lastRange->end > centerX) {
+              // straddle, choose one or the other based on direction
+              Ref<ResultPoint> result(new ResultPoint(deltaY > 0 ? lastRange->start : lastRange->end, lastY));
+              return result;
+            }
+            Ref<ResultPoint> result(new ResultPoint(lastRange->start, lastY));
+            return result;
+          } else {
+            Ref<ResultPoint> result(new ResultPoint(lastRange->end, lastY));
+            return result;
+          }
+        } else {
+          int lastX = x - deltaX;
+          if (lastRange->start < centerY) {
+            if (lastRange->end > centerY) {
+              Ref<ResultPoint> result(new ResultPoint(lastX, deltaX < 0 ? lastRange->start : lastRange->end));
+              return result;
+            }
+            Ref<ResultPoint> result(new ResultPoint(lastX, lastRange->start));
+            return result;
+          } else {
+            Ref<ResultPoint> result(new ResultPoint(lastX, lastRange->end));
+            return result;
+          }
+        }
+      }
+    }
+    lastRange = range;
+  }   
+  throw NotFoundException("Couldn't find corners");
+}
+
+Ref<TwoInts> MonochromeRectangleDetector::blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim,
+                                                          bool horizontal) {
+    
+  int center = (minDim + maxDim) >> 1;
+
+  // Scan left/up first
+  int start = center;
+  while (start >= minDim) {
+    if (horizontal ? image_->get(start, fixedDimension) : image_->get(fixedDimension, start)) {
+      start--;
+    } else {
+      int whiteRunStart = start;
+      do {
+        start--;
+      } while (start >= minDim && !(horizontal ? image_->get(start, fixedDimension) :
+                                    image_->get(fixedDimension, start)));
+      int whiteRunSize = whiteRunStart - start;
+      if (start < minDim || whiteRunSize > maxWhiteRun) {
+        start = whiteRunStart;
+        break;
+      }
+    }
+  }
+  start++;
+
+  // Then try right/down
+  int end = center;
+  while (end < maxDim) {
+    if (horizontal ? image_->get(end, fixedDimension) : image_->get(fixedDimension, end)) {
+      end++;
+    } else {
+      int whiteRunStart = end;
+      do {
+        end++;
+      } while (end < maxDim && !(horizontal ? image_->get(end, fixedDimension) :
+                                 image_->get(fixedDimension, end)));
+      int whiteRunSize = end - whiteRunStart;
+      if (end >= maxDim || whiteRunSize > maxWhiteRun) {
+        end = whiteRunStart;
+        break;
+      }
+    }
+  }
+  end--;
+  Ref<TwoInts> result(NULL);
+  if (end > start) {
+    result = new TwoInts;
+    result->start = start;
+    result->end = end;
+  }
+  return result;
+}

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/MonochromeRectangleDetector.h

@@ -0,0 +1,62 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+
+#ifndef __MONOCHROMERECTANGLEDETECTOR_H__
+#define __MONOCHROMERECTANGLEDETECTOR_H__
+
+/*
+ *  MonochromeRectangleDetector.h
+ *  y_wmk
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 y_wmk 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/NotFoundException.h>
+#include <zxing/ResultPoint.h>
+#include <zxing/common/BitMatrix.h>
+#include <zxing/common/Counted.h>
+#include <zxing/ResultPoint.h>
+
+namespace zxing {
+
+struct TwoInts: public Counted {
+  int start;
+  int end;
+};
+
+class MonochromeRectangleDetector : public Counted {
+ private:
+  static const int MAX_MODULES = 32;
+  Ref<BitMatrix> image_;
+
+ public:
+  MonochromeRectangleDetector(Ref<BitMatrix> image) : image_(image) {  };
+
+  std::vector<Ref<ResultPoint> > detect();
+
+ private:
+  Ref<ResultPoint> findCornerFromCenter(int centerX, int deltaX, int left, int right,
+                                        int centerY, int deltaY, int top, int bottom, int maxWhiteRun);
+
+  Ref<TwoInts> blackWhiteRange(int fixedDimension, int maxWhiteRun, int minDim, int maxDim,
+                               bool horizontal);
+
+  int max(int a, float b) { return (float) a > b ? a : (int) b;};
+};
+
+}
+
+#endif // __MONOCHROMERECTANGLEDETECTOR_H__

data/ext/zxing/zxing-cpp/core/src/zxing/common/detector/WhiteRectangleDetector.cpp

@@ -0,0 +1,330 @@
+// -*- mode:c++; tab-width:2; indent-tabs-mode:nil; c-basic-offset:2 -*-
+/*
+ *  WhiteRectangleDetector.cpp
+ *  y_wmk
+ *
+ *  Created by Luiz Silva on 09/02/2010.
+ *  Copyright 2010 y_wmk 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/NotFoundException.h>
+#include <zxing/common/detector/WhiteRectangleDetector.h>
+#include <zxing/common/detector/MathUtils.h>
+#include <sstream>
+
+using std::vector;
+using zxing::Ref;
+using zxing::ResultPoint;
+using zxing::WhiteRectangleDetector;
+using zxing::common::detector::MathUtils;
+
+// VC++
+using zxing::BitMatrix;
+
+int WhiteRectangleDetector::INIT_SIZE = 30;
+int WhiteRectangleDetector::CORR = 1;
+
+WhiteRectangleDetector::WhiteRectangleDetector(Ref<BitMatrix> image) : image_(image) {
+  width_ = image->getWidth();
+  height_ = image->getHeight();
+  
+  leftInit_ = (width_ - INIT_SIZE) >> 1;
+  rightInit_ = (width_ + INIT_SIZE) >> 1;
+  upInit_ = (height_ - INIT_SIZE) >> 1;
+  downInit_ = (height_ + INIT_SIZE) >> 1;
+  
+  if (upInit_ < 0 || leftInit_ < 0 || downInit_ >= height_ || rightInit_ >= width_) {
+    throw NotFoundException("Invalid dimensions WhiteRectangleDetector");
+}
+}
+
+WhiteRectangleDetector::WhiteRectangleDetector(Ref<BitMatrix> image, int initSize, int x, int y) : image_(image) {
+  width_ = image->getWidth();
+  height_ = image->getHeight();
+  
+  int halfsize = initSize >> 1;
+  leftInit_ = x - halfsize;
+  rightInit_ = x + halfsize;
+  upInit_ = y - halfsize;
+  downInit_ = y + halfsize;
+  
+  if (upInit_ < 0 || leftInit_ < 0 || downInit_ >= height_ || rightInit_ >= width_) {
+    throw NotFoundException("Invalid dimensions WhiteRectangleDetector");
+  }
+}
+
+/**
+ * <p>
+ * Detects a candidate barcode-like rectangular region within an image. It
+ * starts around the center of the image, increases the size of the candidate
+ * region until it finds a white rectangular region.
+ * </p>
+ *
+ * @return {@link vector<Ref<ResultPoint> >} describing the corners of the rectangular
+ *         region. The first and last points are opposed on the diagonal, as
+ *         are the second and third. The first point will be the topmost
+ *         point and the last, the bottommost. The second point will be
+ *         leftmost and the third, the rightmost
+ * @throws NotFoundException if no Data Matrix Code can be found
+*/
+std::vector<Ref<ResultPoint> > WhiteRectangleDetector::detect() {
+  int left = leftInit_;
+  int right = rightInit_;
+  int up = upInit_;
+  int down = downInit_;
+
+  bool sizeExceeded = false;
+  bool aBlackPointFoundOnBorder = true;
+  bool atLeastOneBlackPointFoundOnBorder = false;
+
+  while (aBlackPointFoundOnBorder) {
+    aBlackPointFoundOnBorder = false;
+
+    // .....
+    // .   |
+    // .....
+    bool rightBorderNotWhite = true;
+    while (rightBorderNotWhite && right < width_) {
+      rightBorderNotWhite = containsBlackPoint(up, down, right, false);
+      if (rightBorderNotWhite) {
+        right++;
+        aBlackPointFoundOnBorder = true;
+      }
+    }
+
+    if (right >= width_) {
+      sizeExceeded = true;
+      break;
+    }
+
+    // .....
+    // .   .
+    // .___.
+    bool bottomBorderNotWhite = true;
+    while (bottomBorderNotWhite && down < height_) {
+      bottomBorderNotWhite = containsBlackPoint(left, right, down, true);
+      if (bottomBorderNotWhite) {
+        down++;
+        aBlackPointFoundOnBorder = true;
+      }
+    }
+
+    if (down >= height_) {
+      sizeExceeded = true;
+      break;
+    }
+
+    // .....
+    // |   .
+    // .....
+    bool leftBorderNotWhite = true;
+    while (leftBorderNotWhite && left >= 0) {
+      leftBorderNotWhite = containsBlackPoint(up, down, left, false);
+      if (leftBorderNotWhite) {
+        left--;
+        aBlackPointFoundOnBorder = true;
+      }
+    }
+
+    if (left < 0) {
+      sizeExceeded = true;
+      break;
+    }
+
+    // .___.
+    // .   .
+    // .....
+    bool topBorderNotWhite = true;
+    while (topBorderNotWhite && up >= 0) {
+      topBorderNotWhite = containsBlackPoint(left, right, up, true);
+      if (topBorderNotWhite) {
+        up--;
+        aBlackPointFoundOnBorder = true;
+      }
+    }
+
+    if (up < 0) {
+      sizeExceeded = true;
+      break;
+    }
+
+    if (aBlackPointFoundOnBorder) {
+      atLeastOneBlackPointFoundOnBorder = true;
+    }
+
+  }
+  if (!sizeExceeded && atLeastOneBlackPointFoundOnBorder) {
+
+    int maxSize = right - left;
+
+    Ref<ResultPoint> z(NULL);
+    //go up right
+    for (int i = 1; i < maxSize; i++) {
+      z = getBlackPointOnSegment(left, down - i, left + i, down);
+      if (z != NULL) {
+        break;
+      }
+    }
+
+    if (z == NULL) {
+      throw NotFoundException("z == NULL");
+    }
+
+    Ref<ResultPoint> t(NULL);
+    //go down right
+    for (int i = 1; i < maxSize; i++) {
+      t = getBlackPointOnSegment(left, up + i, left + i, up);
+      if (t != NULL) {
+        break;
+      }
+    }
+
+    if (t == NULL) {
+      throw NotFoundException("t == NULL");
+    }
+
+    Ref<ResultPoint> x(NULL);
+    //go down left
+    for (int i = 1; i < maxSize; i++) {
+      x = getBlackPointOnSegment(right, up + i, right - i, up);
+      if (x != NULL) {
+        break;
+      }
+    }
+
+    if (x == NULL) {
+      throw NotFoundException("x == NULL");
+    }
+
+    Ref<ResultPoint> y(NULL);
+    //go up left
+    for (int i = 1; i < maxSize; i++) {
+      y = getBlackPointOnSegment(right, down - i, right - i, down);
+      if (y != NULL) {
+        break;
+      }
+    }
+
+    if (y == NULL) {
+      throw NotFoundException("y == NULL");
+    }
+
+    return centerEdges(y, z, x, t);
+
+  } else {
+    throw NotFoundException("No black point found on border");
+  }
+}
+
+Ref<ResultPoint>
+WhiteRectangleDetector::getBlackPointOnSegment(int aX_, int aY_, int bX_, int bY_) {
+  float aX = float(aX_), aY = float(aY_), bX = float(bX_), bY = float(bY_);
+  int dist = MathUtils::round(MathUtils::distance(aX, aY, bX, bY));
+  float xStep = (bX - aX) / dist;
+  float yStep = (bY - aY) / dist;
+
+  for (int i = 0; i < dist; i++) {
+    int x = MathUtils::round(aX + i * xStep);
+    int y = MathUtils::round(aY + i * yStep);
+    if (image_->get(x, y)) {
+      Ref<ResultPoint> point(new ResultPoint(float(x), float(y)));
+      return point;
+    }
+  }
+  Ref<ResultPoint> point(NULL);
+  return point;
+}
+
+/**
+ * recenters the points of a constant distance towards the center
+ *
+ * @param y bottom most point
+ * @param z left most point
+ * @param x right most point
+ * @param t top most point
+ * @return {@link vector<Ref<ResultPoint> >} describing the corners of the rectangular
+ *         region. The first and last points are opposed on the diagonal, as
+ *         are the second and third. The first point will be the topmost
+ *         point and the last, the bottommost. The second point will be
+ *         leftmost and the third, the rightmost
+ */
+vector<Ref<ResultPoint> > WhiteRectangleDetector::centerEdges(Ref<ResultPoint> y, Ref<ResultPoint> z,
+                                  Ref<ResultPoint> x, Ref<ResultPoint> t) {
+
+  //
+  //       t            t
+  //  z                      x
+  //        x    OR    z
+  //   y                    y
+  //
+
+  float yi = y->getX();
+  float yj = y->getY();
+  float zi = z->getX();
+  float zj = z->getY();
+  float xi = x->getX();
+  float xj = x->getY();
+  float ti = t->getX();
+  float tj = t->getY();
+
+  std::vector<Ref<ResultPoint> > corners(4);
+  if (yi < (float)width_/2.0f) {
+    Ref<ResultPoint> pointA(new ResultPoint(ti - CORR, tj + CORR));
+    Ref<ResultPoint> pointB(new ResultPoint(zi + CORR, zj + CORR));
+    Ref<ResultPoint> pointC(new ResultPoint(xi - CORR, xj - CORR));
+    Ref<ResultPoint> pointD(new ResultPoint(yi + CORR, yj - CORR));
+	  corners[0].reset(pointA);
+	  corners[1].reset(pointB);
+	  corners[2].reset(pointC);
+	  corners[3].reset(pointD);
+  } else {
+    Ref<ResultPoint> pointA(new ResultPoint(ti + CORR, tj + CORR));
+    Ref<ResultPoint> pointB(new ResultPoint(zi + CORR, zj - CORR));
+    Ref<ResultPoint> pointC(new ResultPoint(xi - CORR, xj + CORR));
+    Ref<ResultPoint> pointD(new ResultPoint(yi - CORR, yj - CORR));
+	  corners[0].reset(pointA);
+	  corners[1].reset(pointB);
+	  corners[2].reset(pointC);
+	  corners[3].reset(pointD);
+  }
+  return corners;
+}
+
+/**
+ * Determines whether a segment contains a black point
+ *
+ * @param a          min value of the scanned coordinate
+ * @param b          max value of the scanned coordinate
+ * @param fixed      value of fixed coordinate
+ * @param horizontal set to true if scan must be horizontal, false if vertical
+ * @return true if a black point has been found, else false.
+ */
+bool WhiteRectangleDetector::containsBlackPoint(int a, int b, int fixed, bool horizontal) {
+  if (horizontal) {
+    for (int x = a; x <= b; x++) {
+      if (image_->get(x, fixed)) {
+        return true;
+      }
+    }
+  } else {
+    for (int y = a; y <= b; y++) {
+      if (image_->get(fixed, y)) {
+        return true;
+      }
+    }
+  }
+
+  return false;
+}