BitMatrix: add BitMatrixCursor as general purpose abstraction

This is the general part of the former DMDetector EdgeTracer code.

Also add a widely usable PointT based accessor interface to BitMatrix.

Author: axxel

core/src/BitMatrix.h

@@ -16,14 +16,15 @@
 * limitations under the License.
 */
 
+#include "Matrix.h"
+#include "Point.h"
+#include "ZXConfig.h"
+
 #include <algorithm>
 #include <cstdint>
 #include <utility>
 #include <vector>
 
-#include "Matrix.h"
-#include "ZXConfig.h"
-
 namespace ZXing {
 
 class BitArray;
@@ -269,6 +270,80 @@ class BitMatrix
 	{
 		return a._width == b._width && a._height == b._height && a._rowSize == b._rowSize && a._bits == b._bits;
 	}
+
+	bool isIn(PointI p, int b = 0) const noexcept
+	{
+		return b <= p.x && p.x < width() - b && b <= p.y && p.y < height() - b;
+	}
+	bool isIn(PointF p) const  noexcept { return isIn(round(p)); }
+
+	bool get(PointI p) const { return get(p.x, p.y); }
+	bool get(PointF p) const { return get(round(p)); }
+	void set(PointI p, bool v = true) { set(p.x, p.y, v); }
+	void set(PointF p, bool v = true) { set(round(p), v); }
+
+	class Value
+	{
+		enum { INVALID, WHITE, BLACK };
+		int v = INVALID;
+	public:
+		Value() = default;
+		Value(bool isBlack) : v(isBlack ? BLACK : WHITE) {}
+		bool isValid() const { return v != INVALID; }
+		bool isWhite() const { return v == WHITE; }
+		bool isBlack() const { return v == BLACK; }
+	};
+
+	template <typename T>
+	Value testAt(PointT<T> p) const
+	{
+		auto q = round(p);
+		return isIn(q) ? Value{get(q)} : Value{};
+	}
+
+	template <typename T> bool blackAt(PointT<T> p) const { return testAt(p).isBlack(); }
+	template <typename T> bool whiteAt(PointT<T> p) const { return testAt(p).isWhite(); }
+};
+
+/**
+ * @brief The BitMatrixCursor represents a current position inside an image and durrent direction it can advance towards.
+ *
+ * The current position is PointI or PointF. So depending on the type it will either round its current position after each
+ * step or do a Bresenham traversal through the BitMatrix.
+ */
+template<typename CPOS_T>
+class BitMatrixCursor
+{
+	const BitMatrix* _img;
+
+public:
+	CPOS_T p; // current position
+	PointF d; // current direction
+
+	BitMatrixCursor(const BitMatrix& image, CPOS_T p, PointF d) : _img(&image), p(p), d(d) {}
+
+	bool isIn(PointI p) const noexcept { return _img->isIn(p); }
+	bool isIn(PointF p) const noexcept { return _img->isIn(p); }
+	bool isIn() const noexcept { return isIn(p); }
+	bool isBlack() const noexcept { return blackAt(p); }
+	bool isWhite() const noexcept { return whiteAt(p); }
+
+	PointF front() const noexcept { return d; }
+	PointF back() const noexcept { return {-d.x, -d.y}; }
+	PointF right() const noexcept { return {-d.y, d.x}; }
+	PointF left() const noexcept { return {d.y, -d.x}; }
+
+	bool blackAt(PointF pos) const noexcept { return _img->testAt(pos).isBlack(); }
+	bool whiteAt(PointF pos) const noexcept { return _img->testAt(pos).isWhite(); }
+	bool isEdge(PointF pos, PointF dir) const noexcept { return whiteAt(pos) && blackAt(pos + dir); }
+	bool isEdgeBehind() const noexcept { return isEdge(PointF(p), back()); }
+
+	void setDirection(PointF dir) { d = bresenhamDirection(dir); }
+	bool step(int s = 1)
+	{
+		moveBy(p, s * d);
+		return isIn(p);
+	}
 };
 
 /**

core/src/GridSampler.cpp

@@ -47,7 +47,7 @@ DetectorResult SampleGrid(const BitMatrix& image, int width, int height, const P
 #ifndef NDEBUG
 			theGrid.emplace_back(p);
 #endif
-			if (image.get(p.x, p.y))
+			if (image.get(p))
 				res.set(x, y);
 		}
 	auto projectCorner = [&](PointI p) { return PointI(transform(PointF(p)) + PointF(0.5, 0.5)); };

core/src/Point.h

@@ -109,6 +109,11 @@ inline PointI round(PointF p)
 	return PointI(::lround(p.x), ::lround(p.y));
 }
 
+inline PointI round(PointI p)
+{
+	return p;
+}
+
 inline PointF bresenhamDirection(PointF d)
 {
 	return d / std::fmax(std::fabs(d.x), std::fabs(d.y));
@@ -125,6 +130,15 @@ inline PointF movedTowardsBy(PointF a, PointF b, double d)
 	return a + d * normalized(b - a);
 }
 
+inline void moveBy(PointI& p, PointF d)
+{
+	p = p + round(d);
+}
+
+inline void moveBy(PointF& p, PointF d)
+{
+	p = p + d;
+}
 
 } // ZXing
 

core/src/datamatrix/DMDetector.cpp

@@ -562,55 +562,10 @@ PointF intersect(const RegressionLine& l1, const RegressionLine& l2)
 	return {x, y};
 }
 
-struct BitMatrixAccessor
+class EdgeTracer : public BitMatrixCursor<PointI>
 {
-	const BitMatrix* image;
-
-	BitMatrixAccessor(const BitMatrix& image) : image(&image) {}
-
-	bool isIn(PointI p) const
-	{
-		const int b = 0;
-		return b <= p.x && p.x < image->width()-b &&
-			   b <= p.y && p.y < image->height()-b;
-	}
-	bool isIn(PointF p) const { return isIn(round(p)); }
-
-	class Value
-	{
-		enum { INVALID, WHITE, BLACK };
-		int v = INVALID;
-	public:
-		Value() = default;
-		Value(bool isBlack) : v(isBlack ? BLACK : WHITE) {}
-		bool isValid() const { return v != INVALID; }
-		bool isWhite() const { return v == WHITE; }
-		bool isBlack() const { return v == BLACK; }
-	};
-
-	Value getAt(PointF p) const
-	{
-		auto q = round(p);
-		if (!isIn(q))
-			return {};
-		return {image->get(q.x, q.y)};
-	}
-
-	bool blackAt(PointF p) const { return getAt(p).isBlack(); }
-	bool whiteAt(PointF p) const { return getAt(p).isWhite(); }
-	bool isEdge(PointF pos, PointF dir) const { return whiteAt(pos) && blackAt(pos + dir); }
-};
-
-class EdgeTracer : BitMatrixAccessor
-{
-	PointI p; // current position
-	PointF d; // current direction
-
 	enum class StepResult { FOUND, OPEN_END, CLOSED_END };
 
-	using BitMatrixAccessor::isIn;
-	bool isIn() const { return isIn(p); }
-
 	StepResult traceStep(PointF dEdge, int maxStepSize, bool goodDirection)
 	{
 		dEdge = mainDirection(dEdge);
@@ -643,16 +598,7 @@ class EdgeTracer : BitMatrixAccessor
 	}
 
 public:
-	EdgeTracer(const BitMatrix& img, PointI p, PointF d) : BitMatrixAccessor(img), p(p), d(d) {}
-
-	bool step(int s = 1)
-	{
-		p = round(p + s * d);
-		log(p);
-		return isIn(p);
-	}
-
-	void setDirection(PointF dir) { d = bresenhamDirection(dir); }
+	using BitMatrixCursor<PointI>::BitMatrixCursor;
 
 	bool updateDirectionFromOrigin(PointF origin)
 	{
@@ -669,13 +615,6 @@ class EdgeTracer : BitMatrixAccessor
 		return true;
 	}
 
-	PointF front() const { return d; }
-	PointF back() const { return {-d.x, -d.y}; }
-	PointF right() const { return {-d.y, d.x}; }
-	PointF left() const { return {d.y, -d.x}; }
-
-	bool isEdgeBehind() const { return isEdge(PointF(p), back()); }
-
 	bool traceLine(PointF dEdge, RegressionLine& line)
 	{
 		line.setDirectionInward(dEdge);
@@ -764,6 +703,7 @@ class EdgeTracer : BitMatrixAccessor
 	bool traceCorner(PointF dir, PointF& corner)
 	{
 		step();
+		log(p);
 		corner = PointF(p);
 		std::swap(d, dir);
 		traceStep(-1 * dir, 2, false);
@@ -807,6 +747,8 @@ static DetectorResult DetectNew(const BitMatrix& image, bool tryRotate)
 #endif
 		EdgeTracer startTracer(image, {image.width()/2, image.height()/2}, startDirection);
 		while (startTracer.step()) {
+			log(startTracer.p);
+
 			// go forward until we reach a white/black border
 			if (!startTracer.isEdgeBehind())
 				continue;