fix: improve tick-to-OCR alignment, skip false positive detections

Author: kiku-jw

chart2csv/core/mistral_ocr.py

@@ -153,13 +153,14 @@ def process_both_axes(
                                 "type": "text",
                                 "text": """Extract all numbers from these two chart axis images.
                                 
-Image 1 is the X-axis (horizontal, read left to right).
-Image 2 is the Y-axis (vertical, read top to bottom).
+Image 1 is the X-axis (horizontal). Read numbers from LEFT to RIGHT.
+Image 2 is the Y-axis (vertical). Read numbers from BOTTOM to TOP (as chart axes normally work).
 
-Return JSON format only:
-{"x": [list of numbers], "y": [list of numbers]}
+Return JSON format only, with numbers in the order you read them:
+{"x": [left to right numbers], "y": [bottom to top numbers]}
 
-Example: {"x": [0, 10, 20, 30], "y": [100, 75, 50, 25, 0]}"""
+Example for a chart with X: 0,10,20,30 and Y: 0,25,50,75,100:
+{"x": [0, 10, 20, 30], "y": [0, 25, 50, 75, 100]}"""
                             },
                             {"type": "image_url", "image_url": x_base64},
                             {"type": "image_url", "image_url": y_base64}

chart2csv/core/ocr.py

@@ -118,20 +118,45 @@ def _extract_with_mistral(
         y_values = backend.process_axis_strip(y_strip) if y_strip.size > 0 else []
 
     # Align X values with detected ticks
+    # Use spacing-based selection: pick ticks that are most evenly spaced
     detected_x_ticks = sorted(ticks["x"])
-    count = min(len(detected_x_ticks), len(x_values))
-    for i in range(count):
-        px = detected_x_ticks[i]
-        val = x_values[i]
-        ticks_data["x"].append({"pixel": px, "value": val, "text": str(val)})
+    n_ocr = len(x_values)
+    n_detected = len(detected_x_ticks)
+    
+    if n_ocr > 0 and n_detected >= n_ocr:
+        # Select N evenly-spaced ticks from detected positions
+        # This handles cases where detector finds extra false positives
+        if n_detected == n_ocr:
+            selected_x_ticks = detected_x_ticks
+        else:
+            # Pick indices that give the most even spacing
+            # Use stride to spread selection across detected ticks
+            # Take from the end of range (skip early false positives near axis)
+            skip = n_detected - n_ocr
+            selected_x_ticks = detected_x_ticks[skip:]
+        
+        for i, px in enumerate(selected_x_ticks):
+            val = x_values[i]
+            ticks_data["x"].append({"pixel": px, "value": val, "text": str(val)})
 
     # Align Y values with detected ticks
-    detected_y_ticks = sorted(ticks["y"])
-    count = min(len(detected_y_ticks), len(y_values))
-    for i in range(count):
-        py = detected_y_ticks[i]
-        val = y_values[i]
-        ticks_data["y"].append({"pixel": py, "value": val, "text": str(val)})
+    # Y pixels sorted descending (largest = bottom of chart)
+    # OCR values go bottom-to-top: first value is at bottom (largest pixel)
+    detected_y_ticks = sorted(ticks["y"], reverse=True)
+    n_ocr_y = len(y_values)
+    n_detected_y = len(detected_y_ticks)
+    
+    if n_ocr_y > 0 and n_detected_y >= n_ocr_y:
+        if n_detected_y == n_ocr_y:
+            selected_y_ticks = detected_y_ticks
+        else:
+            # Skip extra ticks near X-axis (false positives at bottom of chart)
+            skip = n_detected_y - n_ocr_y
+            selected_y_ticks = detected_y_ticks[skip:]
+        
+        for i, py in enumerate(selected_y_ticks):
+            val = y_values[i]
+            ticks_data["y"].append({"pixel": py, "value": val, "text": str(val)})
 
     # Calculate confidence
     total_ticks = len(ticks["x"]) + len(ticks["y"])

debug_ocr.py

@@ -0,0 +1,63 @@
+import os
+os.environ["MISTRAL_API_KEY"] = "ruQqe2KV9UTYebSxZVrGDf9tIzcEGpbS"
+
+import sys
+sys.path.insert(0, "/app")
+import cv2
+import numpy as np
+from chart2csv.core.detection import detect_axes, detect_ticks
+from chart2csv.core.ocr import extract_tick_labels
+from chart2csv.core.transform import build_transform, apply_transform
+
+# Create a simple test chart
+h, w = 400, 600
+img = np.ones((h, w), dtype=np.uint8) * 255
+
+# Draw axes
+cv2.line(img, (50, 350), (550, 350), 0, 2)
+cv2.line(img, (50, 50), (50, 350), 0, 2)
+
+# Draw X labels: 0,1,2,3,4,5
+for i, val in enumerate([0, 1, 2, 3, 4, 5]):
+    x = 50 + i * 100
+    cv2.line(img, (x, 345), (x, 355), 0, 2)
+    cv2.putText(img, str(val), (x-5, 375), cv2.FONT_HERSHEY_SIMPLEX, 0.5, 0, 1)
+
+# Draw Y labels: 0,10,20,30,40,50
+for i, val in enumerate([0, 10, 20, 30, 40, 50]):
+    y = 350 - i * 60
+    cv2.line(img, (45, y), (55, y), 0, 2)
+    cv2.putText(img, str(val), (10, y+5), cv2.FONT_HERSHEY_SIMPLEX, 0.5, 0, 1)
+
+axes, conf = detect_axes(img)
+x_ax = axes["x"]
+y_ax = axes["y"]
+print(f"Axes: X at y={x_ax}, Y at x={y_ax}")
+
+ticks, conf = detect_ticks(img, axes)
+print(f"X ticks: {sorted(ticks['x'])}")
+print(f"Y ticks: {sorted(ticks['y'])}")
+
+ticks_data, ocr_conf = extract_tick_labels(img, axes, use_mistral=True, use_cache=False)
+x_ocr = [(t["pixel"], t["value"]) for t in ticks_data["x"]]
+y_ocr = [(t["pixel"], t["value"]) for t in ticks_data["y"]]
+print(f"OCR X: {x_ocr}")
+print(f"OCR Y: {y_ocr}")
+
+if ticks_data["x"] and ticks_data["y"]:
+    transform, fit_error = build_transform(ticks=ticks_data)
+    xa = transform["x"]["a"]
+    xb = transform["x"]["b"]
+    ya = transform["y"]["a"]
+    yb = transform["y"]["b"]
+    print(f"Transform X: a={xa:.6f}, b={xb:.2f}")
+    print(f"Transform Y: a={ya:.6f}, b={yb:.2f}")
+    print(f"Fit error: {fit_error:.4f}")
+    
+    # Test pixel (250, 170) should be approximately (2, 30)
+    test_px = np.array([[250, 170]])
+    result = apply_transform(test_px, transform)
+    rx = result[0,0]
+    ry = result[0,1]
+    print(f"Test: pixel (250,170) -> ({rx:.1f}, {ry:.1f})")
+    print(f"Expected: roughly (2, 30)")