Fix monochrome video detection and add test videos

- Fix empty color detection for monochrome schemes using time-flow
  direction: filled cells sum increases 0→59 (forward), empty cells
  decrease (backward). Only used as tiebreaker when top 2 colors
  have similar frequency.

- Add IMG_6782.MOV: signature test (P=8191, N=1983)
- Add IMG_6789.MOV: monochrome red + signature (P=1234567, N=196)
- Both videos stripped of GPS/location metadata

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

Author: popojan

.gitattributes

@@ -1,4 +1,5 @@
 *.MOV filter=lfs diff=lfs merge=lfs -text
-
 # Override GitHub language detection - show C as primary
 inverse/* linguist-vendored
+test_videos/IMG_6789.MOV filter=lfs diff=lfs merge=lfs -text
+test_videos/IMG_6782.MOV filter=lfs diff=lfs merge=lfs -text

inverse/run_all_tests.sh

@@ -51,10 +51,13 @@ test_video "IMG_6743.MOV" "29458875" "1970-01-0100:00:00" "1" "0"
 # Standard encoding: P=1, N=0
 test_video "IMG_6746.MOV" "1065579753" "0000-01-0100:00:00" "1" "0"
 
-# Signature encoding test
-# Raw k = minute * P + N, decoded minutes = (k - N) / P = 29465913
+# Signature encoding tests
+# Raw k = minute * P + N, decoded minutes = (k - N) / P
 test_video "IMG_6782.MOV" "241355295366" "1970-01-0100:00:00" "8191" "1983"
 
+# Monochrome red with signature (tests time-flow based empty color detection)
+test_video "IMG_6789.MOV" "36381401836815" "1970-01-0100:00:00" "1234567" "196"
+
 echo
 echo "=== Results ==="
 echo "Passed: $PASS"

inverse/video_analyzer.py

@@ -842,6 +842,64 @@ def detect_empty_color(cell_colors):
     return np.array([v + 10 for v in most_frequent], dtype=np.uint8)
 
 
+def detect_empty_color_by_time_flow(warped_frames, all_cell_colors):
+    """
+    Detect empty color using time-flow direction as tiebreaker.
+
+    In non-monochrome setups, empty color is most frequent and easily detected.
+    In monochrome setups, filled and empty have similar total area, so we use
+    time-flow direction to distinguish:
+    - Filled cells: sum increases 0→59 (forward time)
+    - Empty cells: sum decreases 60→1 (backward time)
+    """
+    quantized = (np.array(all_cell_colors) // 20) * 20
+    color_counts = {}
+    for c in quantized:
+        key = tuple(c)
+        color_counts[key] = color_counts.get(key, 0) + 1
+
+    sorted_colors = sorted(color_counts.items(), key=lambda x: -x[1])
+    if len(sorted_colors) < 2:
+        return np.array([v + 10 for v in sorted_colors[0][0]], dtype=np.uint8)
+
+    top1_key, top1_count = sorted_colors[0]
+    top2_key, top2_count = sorted_colors[1]
+
+    # If top color is clearly dominant (>1.5x second), use it (non-monochrome case)
+    if top1_count > top2_count * 1.5:
+        return np.array([v + 10 for v in top1_key], dtype=np.uint8)
+
+    # Similar frequency (monochrome case) - use time-flow to break tie
+    color_candidates = [np.array([v + 10 for v in c[0]], dtype=np.uint8)
+                       for c in sorted_colors[:2]]
+
+    best_empty = color_candidates[0]
+    best_flow_score = -float('inf')
+
+    for candidate_empty in color_candidates:
+        test_tol = find_adaptive_threshold(warped_frames[:min(60, len(warped_frames))], candidate_empty)
+        sums = []
+        for warped in warped_frames[:min(90, len(warped_frames))]:
+            visible = get_visible_cells_warped(warped, candidate_empty, test_tol)
+            sums.append(sum(visible) % 60)
+
+        # Forward time = increasing sums (positive flow_score)
+        flow_score = 0
+        for i in range(1, len(sums)):
+            diff = sums[i] - sums[i-1]
+            if diff < -30:
+                diff += 60
+            elif diff > 30:
+                diff -= 60
+            flow_score += diff
+
+        if flow_score > best_flow_score:
+            best_flow_score = flow_score
+            best_empty = candidate_empty
+
+    return best_empty
+
+
 def get_empty_color_candidates(cell_colors, max_candidates=3):
     """Get multiple empty color candidates for validation testing."""
     all_colors_array = np.array(cell_colors)
@@ -1037,15 +1095,8 @@ def run_simple_detection(frames, tolerance, verbose=False):
                 color = sample_cell_color_warped(warped, cell_id)
                 all_cell_colors.append(color)
 
-        # Use quantized color detection across all frames (like old version)
-        all_colors_array = np.array(all_cell_colors)
-        quantized = (all_colors_array // 20) * 20
-        color_counts = {}
-        for c in quantized:
-            key = tuple(c)
-            color_counts[key] = color_counts.get(key, 0) + 1
-        most_frequent = max(color_counts, key=color_counts.get)
-        empty_color = np.array([v + 10 for v in most_frequent], dtype=np.uint8)
+        # Detect empty color using time-flow direction as tiebreaker for monochrome
+        empty_color = detect_empty_color_by_time_flow(warped_frames, all_cell_colors)
 
         # Find adaptive threshold from score distribution
         adaptive_tol = find_adaptive_threshold(warped_frames, empty_color)
@@ -1112,8 +1163,8 @@ def run_hough_detection(frames, quad_pts, tolerance, verbose=False):
             for cell_id in CELL_LAYOUT.keys():
                 all_cell_colors.append(sample_cell_color_warped(warped, cell_id))
 
-        # Detect empty color
-        empty_color = detect_empty_color(all_cell_colors)
+        # Detect empty color using time-flow direction as tiebreaker for monochrome
+        empty_color = detect_empty_color_by_time_flow(warped_frames, all_cell_colors)
 
         # Find adaptive threshold from score distribution
         adaptive_tol = find_adaptive_threshold(warped_frames, empty_color)

test_videos/IMG_6782.MOV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e90fb5c2e86106ece5c552f9f0bb26c5ab9e326e433f6562e12cba003589e6c4
+size 20748185

test_videos/IMG_6789.MOV

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:1e5435f863207833b66a884f2c68edda7dddc5ec5b4c07ff587ce5f5dc732c95
+size 16449042

test_videos/README.md

@@ -77,6 +77,25 @@ Videos recorded before this change will show the local time origin when analyzed
 - **Expected Result**: 60/60 seconds matched
 - **Notes**: Tests overflow handling for dates before year 1; origin uses ISO 8601 extended format
 
+### IMG_6782.MOV (Multi-minute Signature Test)
+- **Characteristics**: Multi-minute recording with signature encoding (P, N parameters)
+- **Recorded**: Properly mounted (not handheld) for stable detection
+- **Clock Origin**: 1970-01-01 00:00:00 UTC (Unix epoch)
+- **Expected P**: 8191
+- **Expected N**: 1983
+- **Expected Result**: 60/60 seconds matched per minute, signature detected
+- **Notes**: Tests multi-minute signature detection; requires 2+ minutes to detect P/N values
+
+### IMG_6789.MOV (Monochrome Red with Signature)
+- **Characteristics**: Monochrome red color scheme with signature encoding
+- **Recorded**: 2026-01-11 14:16:42 CET
+- **Clock Origin**: 1970-01-01 00:00:00 UTC (Unix epoch)
+- **Expected k**: 36,381,401,836,815
+- **Expected P**: 1234567
+- **Expected N**: 196
+- **Expected Result**: 60/60 seconds matched
+- **Notes**: Tests time-flow based empty color detection for monochrome schemes where filled and empty cells have similar total area over time. The analyzer detects the correct "empty" color by checking which color assignment produces forward-flowing time (increasing cell sums).
+
 ## Running Tests
 
 ```bash