Drift cooldown?

The idea is that if we drift "right" when decoding a given cell, we
should exclude the same drift for the next cell we check. This *might*
help with runaway decode errors?

Tests remain quite scuffed.

src/lib/cimb_translator/CellDrift.cpp

@@ -6,8 +6,8 @@ namespace {
 }
 
 CellDrift::CellDrift(int x, int y)
-    : _x(x)
-    , _y(y)
+	: _x(x)
+	, _y(y)
 {}
 
 int CellDrift::x() const
@@ -29,3 +29,18 @@ void CellDrift::updateDrift(int dx, int dy)
 	_y = std::min(_y, _limit);
 	_y = std::max(_y, 0-_limit);
 }
+
+// static
+uint8_t CellDrift::calculate_cooldown(uint8_t previous, uint8_t idx)
+{
+	// previous xor idx == 6??
+	if (previous == 1 and idx == 7)
+		return 0xFF;
+	if (previous == 3 and idx == 5)
+		return 0xFF;
+	if (previous == 5 and idx == 3)
+		return 0xFF;
+	if (previous == 1 and idx == 7)
+		return 0xFF;
+	return idx;
+}

src/lib/cimb_translator/CellDrift.h

@@ -10,9 +10,11 @@ class CellDrift
 	CellDrift(int x=0, int y=0);
 
 	inline static const std::array<std::pair<int, int>, 9> driftPairs = {{
-	    {-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {0, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
+		{-1, -1}, {0, -1}, {1, -1}, {-1, 0}, {0, 0}, {1, 0}, {-1, 1}, {0, 1}, {1, 1}
 	}};
 
+	static uint8_t calculate_cooldown(uint8_t previous, uint8_t idx);
+
 	int x() const;
 	int y() const;
 

src/lib/cimb_translator/CimbDecoder.cpp

@@ -79,7 +79,7 @@ bool CimbDecoder::load_tiles()
 	return true;
 }
 
-unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
 	drift_offset = 0;
 	unsigned best_fit = 0;
@@ -91,6 +91,11 @@ unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigne
 	// 8, 0, 2, 6 == corners.
 	for (auto&& [drift_idx, h] : results)
 	{
+		// skip over this drift_idx if it matches cooldown
+		// we could be more clever to check for corners, but for now this is fine
+		// ~0U is "unset"
+		if (drift_idx == cooldown and drift_idx != 4) // don't skip the center, obvs
+			continue;
 		for (unsigned i = 0; i < _tileHashes.size(); ++i)
 		{
 			unsigned distance = image_hash::hamming_distance(h, _tileHashes[i]);
@@ -107,16 +112,16 @@ unsigned CimbDecoder::get_best_symbol(image_hash::ahash_result& results, unsigne
 	return best_fit;
 }
 
-unsigned CimbDecoder::decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
 	image_hash::ahash_result results = image_hash::fuzzy_ahash(cell, _ahashThreshold, image_hash::ahash_result::FAST);
 	return get_best_symbol(results, drift_offset, best_distance);
 }
 
-unsigned CimbDecoder::decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance) const
+unsigned CimbDecoder::decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown) const
 {
 	image_hash::ahash_result results = image_hash::fuzzy_ahash(cell, image_hash::ahash_result::FAST);
-	return get_best_symbol(results, drift_offset, best_distance);
+	return get_best_symbol(results, drift_offset, best_distance, cooldown);
 }
 
 std::tuple<uchar,uchar,uchar> CimbDecoder::fix_color(std::tuple<float,float,float> c, float adjustUp, float down) const

src/lib/cimb_translator/CimbDecoder.h

@@ -16,9 +16,9 @@ class CimbDecoder
 
 	void update_color_correction(cv::Matx<float, 3, 3>&& ccm);
 
-	unsigned get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance) const;
-	unsigned decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance) const;
-	unsigned decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance) const;
+	unsigned get_best_symbol(image_hash::ahash_result& results, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=~0U) const;
+	unsigned decode_symbol(const cv::Mat& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=~0U) const;
+	unsigned decode_symbol(const bitmatrix& cell, unsigned& drift_offset, unsigned& best_distance, unsigned cooldown=~0U) const;
 
 	unsigned get_best_color(float r, float g, float b) const;
 	unsigned decode_color(const Cell& cell) const;

src/lib/cimb_translator/CimbReader.cpp

@@ -119,18 +119,18 @@ unsigned CimbReader::read(PositionData& pos)
 		return 0;
 
 	// need coordinate, index, and drift from next position
-	auto [i, xy, drift] = _positions.next();
+	auto [i, xy, drift, cooldown] = _positions.next();
 	int x = xy.first + drift.x();
 	int y = xy.second + drift.y();
 	bitmatrix cell(_grayscale, _image.cols, _image.rows, x-1, y-1);
 
 	unsigned drift_offset = 0;
 	unsigned error_distance;
-	unsigned bits = _decoder.decode_symbol(cell, drift_offset, error_distance);
+	unsigned bits = _decoder.decode_symbol(cell, drift_offset, error_distance, cooldown);
 
 	std::pair<int, int> best_drift = CellDrift::driftPairs[drift_offset];
 	drift.updateDrift(best_drift.first, best_drift.second);
-	_positions.update(i, drift, error_distance);
+	_positions.update(i, drift, error_distance, CellDrift::calculate_cooldown(cooldown, drift_offset));
 
 	pos.i = i;
 	pos.x = x + best_drift.first;

src/lib/cimb_translator/FloodDecodePositions.cpp

@@ -21,7 +21,7 @@ void FloodDecodePositions::reset()
 	for (unsigned i = 0; i < _positions.size(); ++i)
 	{
 		_remaining.push_back(true);
-		_instructions.push_back({CellDrift(), 0xFF});
+		_instructions.push_back({CellDrift(), 0xFF, 0xFF});
 	}
 
 	// seed
@@ -58,24 +58,24 @@ FloodDecodePositions::iter FloodDecodePositions::next()
 
 		needsDecode = false;
 		++_count;
-		auto [drift, __] = _instructions[i];
-		return {i, _positions[i], drift};
+		auto [drift, __, cooldown] = _instructions[i];
+		return {i, _positions[i], drift, cooldown};
 	}
 
-	return {0, {0, 0}, CellDrift()};
+	return {0, {0, 0}, CellDrift(), 0xFF};
 }
 
-int FloodDecodePositions::update(unsigned index, const CellDrift& drift, unsigned error_distance)
+int FloodDecodePositions::update(unsigned index, const CellDrift& drift, unsigned error_distance, uint8_t cooldown)
 {
 	std::array<int,4> adj = _cellFinder.find(index);
 	for (int next : adj)
 	{
 		if (next < 0 or !_remaining[next])
 			continue;
 		decode_instructions& di = _instructions[next];
-		if (di.second <= error_distance)
+		if (std::get<1>(di) <= error_distance)
 			continue;
-		di = {drift, error_distance};
+		di = {drift, error_distance, cooldown};
 		_heap.push({next, error_distance});
 	}
 	return 0;

src/lib/cimb_translator/FloodDecodePositions.h

@@ -12,8 +12,8 @@
 class FloodDecodePositions
 {
 public:
-	using iter = std::tuple<unsigned, CellPositions::coordinate, CellDrift>;
-	using decode_instructions = std::pair<CellDrift, uint8_t>; // drift, best_prio
+	using iter = std::tuple<unsigned, CellPositions::coordinate, CellDrift, uint8_t>;
+	using decode_instructions = std::tuple<CellDrift, uint8_t, uint8_t>; // drift, best_prio, cooldown_pos
 	using decode_prio = std::tuple<uint16_t, uint8_t>; // index, prio
 
 	class PrioCompare
@@ -33,7 +33,7 @@ class FloodDecodePositions
 
 	bool done() const;
 	iter next();
-	int update(unsigned index, const CellDrift& drift, unsigned error_distance);
+	int update(unsigned index, const CellDrift& drift, unsigned error_distance, uint8_t cooldown);
 
 protected:
 	unsigned _index;

src/lib/cimb_translator/test/FloodDecodePositionsTest.cpp

@@ -23,13 +23,14 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 	unsigned i;
 	CellPositions::coordinate xy;
 	CellDrift drift;
+	uint8_t cooldown;
 
 	// validate seed points
 	unsigned count = 0;
 	for (int c = 0; c < 4; ++c)
 	{
 		// 0
-		std::tie(i, xy, drift) = cells.next();
+		std::tie(i, xy, drift, cooldown) = cells.next();
 		assertEquals(0, drift.x());
 		assertEquals(0, drift.y());
 
@@ -38,25 +39,25 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 			assertEquals(62, xy.first);
 			assertEquals(8, xy.second);
 			drift.updateDrift(1, 1);
-			cells.update(i, drift, 1);
+			cells.update(i, drift, 1, cooldown);
 		}
 		else if (i == 99)
 		{
 			assertEquals(953, xy.first);
 			assertEquals(8, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else if (i == 12300)
 		{
 			assertEquals(62, xy.first);
 			assertEquals(1007, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else if (i == 12399)
 		{
 			assertEquals(953, xy.first);
 			assertEquals(1007, xy.second);
-			cells.update(i, drift, 2);
+			cells.update(i, drift, 2, cooldown);
 		}
 		else
 			FAIL("i ?= " << i);
@@ -68,7 +69,7 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 	// we did "update(..., 1) for index=1. So the next cells should be the ones adjacent to 0: 1, 100.
 	for (int c = 0; c < 2; ++c)
 	{
-		std::tie(i, xy, drift) = cells.next();
+		std::tie(i, xy, drift, cooldown) = cells.next();
 		if (i == 1)
 		{
 			assertEquals(71, xy.first);
@@ -85,16 +86,16 @@ TEST_CASE( "FloodDecodePositionsTest/testSimple", "[unit]" )
 		assertEquals(1, drift.x());
 		assertEquals(1, drift.y());
 
-		cells.update(i, drift, 3);
+		cells.update(i, drift, 3, cooldown);
 		remainingPos.erase(i);
 		++count;
 	}
 
 	// as for the rest... we'll just make sure we hit them all
 	while (!cells.done())
 	{
-		std::tie(i, xy, drift) = cells.next();
-		cells.update(i, drift, 1);
+		std::tie(i, xy, drift, cooldown) = cells.next();
+		cells.update(i, drift, 1, cooldown);
 		remainingPos.erase(i);
 		++count;
 	}

src/lib/image_hash/ahash_result.h

@@ -20,7 +20,7 @@ class ahash_result
 	// 5, 7, 3, 1 == sides.
 	// 8, 0, 2, 6 == corners.
 	// mode=FAST will discard the corner checks.
-	static constexpr std::array<int, 9> _ORDER = {4, 5, 7, 3, 1, 8, 0, 2, 6};
+	static constexpr std::array<unsigned, 9> _ORDER = {4, 5, 7, 3, 1, 8, 0, 2, 6};
 
 public:
 	class iterator
@@ -31,9 +31,9 @@ class ahash_result
 			, _i(i)
 		{}
 
-		std::pair<int, uint64_t> operator*()
+		std::pair<unsigned, uint64_t> operator*()
 		{
-			int idx = _hr._ORDER[_i];
+			unsigned idx = _hr._ORDER[_i];
 			return {idx, _hr._results[idx]};
 		}