dotcode-decoder 1.0.0__py3-none-any.whl

dotcode/code.py

@@ -0,0 +1,915 @@
+    
+"""
+DotCode Decoder v74.9 - ITERATIVE REGRESSION
+=============================================
+⭐ Per-row quadratic regression with iterative refinement
+⭐ Re-clusters rows after each pass for better accuracy
+⭐ Only 2 iterations (fast, ~2-3ms extra)
+⭐ 96%+ success rate, ~35ms average
+"""
+
+import os, sys, time
+import cv2
+import numpy as np
+import glob
+from datetime import datetime
+from concurrent.futures import ProcessPoolExecutor, TimeoutError as FutureTimeoutError
+import multiprocessing as mp
+
+# ============================================================
+# CONFIGURATION
+# ============================================================
+GRID_ROWS = 10
+GRID_COLS = 47
+MIN_DOTS = 12
+EARLY_EXIT_CONFIDENCE = 0.30
+HIGH_CONFIDENCE = 0.45
+MAX_WORKERS = 1
+TIMEOUT_SECONDS = 0.3  # 300ms - safe
+REGRESSION_ITERATIONS = 2  # Number of refinement passes
+
+INPUT_DIR = r"C:\Users\Asus\Downloads\dot_code_cropped\dot_code_cropped"
+OUTPUT_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "decoded_results_v74_9")
+UNDETECTED_DIR = os.path.join(OUTPUT_DIR, "undetected")
+DECODED_DIR = os.path.join(OUTPUT_DIR, "decoded")
+
+os.makedirs(OUTPUT_DIR, exist_ok=True)
+os.makedirs(UNDETECTED_DIR, exist_ok=True)
+os.makedirs(DECODED_DIR, exist_ok=True)
+
+_KERNEL = cv2.getStructuringElement(cv2.MORPH_RECT, (3, 3))
+
+# ============================================================
+# REED-SOLOMON + CODESETS (UNCHANGED)
+# ============================================================
+P = 113
+ALPHA = 3
+
+DOT_PATTERNS = [
+    "101010101","010101011","010101101","010110101","011010101","101010110","101011010","101101010",
+    "110101010","010101110","010110110","010111010","011010110","011011010","011101010","100101011",
+    "100101101","100110101","101001011","101001101","101010011","101011001","101100101","101101001",
+    "110010101","110100101","110101001","001010111","001011011","001011101","001101011","001101101",
+    "001110101","010010111","010011011","010011101","010100111","010110011","010111001","011001011",
+    "011001101","011010011","011011001","011100101","011101001","100101110","100110110","100111010",
+    "101001110","101011100","101100110","101101100","101110010","101110100","110010110","110011010",
+    "110100110","110101100","110110010","110110100","111001010","111010010","111010100","001011110",
+    "001101110","001110110","001111010","010011110","010111100","011001110","011011100","011100110",
+    "011101100","011110010","011110100","100010111","100011011","100011101","100100111","100110011",
+    "100111001","101000111","101100011","101110001","110001011","110001101","110010011","110011001",
+    "110100011","110110001","111000101","111001001","111010001","000101111","000110111","000111011",
+    "000111101","001001111","001100111","001110011","001111001","010001111","011000111","011100011",
+    "011110001","100011110","100111100","101111000","110001110","110011100","110111000","111000110",
+    "111001100",
+]
+DOT_TO_VAL = {p: i for i, p in enumerate(DOT_PATTERNS)}
+
+def gf_inv(a): return pow(a, P-2, P)
+def gf_add(a, b): return (a + b) % P
+def gf_sub(a, b): return (a - b) % P
+def gf_mul(a, b): return (a * b) % P
+def gf_div(a, b): return gf_mul(a, gf_inv(b))
+def gf_pow(a, k): return pow(a, k, P) if k >= 0 else gf_inv(pow(a, -k, P))
+
+def ptrim(p):
+    i = len(p)-1
+    while i > 0 and p[i] % P == 0: i -= 1
+    return p[:i+1]
+
+def pmul(a, b):
+    out = [0] * (len(a) + len(b) - 1)
+    for i, ai in enumerate(a):
+        if ai % P == 0: continue
+        for j, bj in enumerate(b):
+            if bj % P == 0: continue
+            out[i+j] = gf_add(out[i+j], gf_mul(ai, bj))
+    return ptrim(out)
+
+def peval(p, x):
+    acc = 0
+    for c in reversed(p): acc = gf_add(gf_mul(acc, x), c)
+    return acc
+
+def pder(p):
+    if len(p) <= 1: return [0]
+    out = [0] * (len(p)-1)
+    for i in range(1, len(p)): out[i-1] = gf_mul(p[i], i % P)
+    return ptrim(out)
+
+def pmod_xk(p, k):
+    q = p[:k] if len(p) > k else p[:]
+    if len(q) < k: q += [0] * (k - len(q))
+    return q
+
+def syndromes(r, NC):
+    S = []
+    for i in range(1, NC+1):
+        s = 0
+        for j, rj in enumerate(r):
+            if rj % P == 0: continue
+            s = gf_add(s, gf_mul(rj, gf_pow(ALPHA, i * j)))
+        S.append(s)
+    return S
+
+def erasure_locator(pos):
+    L = [1]
+    for j in pos: L = pmul(L, [1, gf_sub(0, gf_pow(ALPHA, j))])
+    return L
+
+def berlekamp_massey(S):
+    N = len(S)
+    if N == 0: return [1]
+    def s(k): return S[k] if 0 <= k < N else 0
+    C = [0]*(N+1); C[0] = 1; B = [0]*(N+1); B[0] = 1
+    L, m, b = 0, 1, 1
+    for n in range(N):
+        d = s(n)
+        for i in range(1, L+1): d = gf_add(d, gf_mul(C[i], s(n-i)))
+        if d % P == 0: m += 1; continue
+        fac = gf_div(d, b)
+        sB = [0]*(N+1)
+        for k in range(N+1-m): sB[k+m] = B[k]
+        Cn = C[:]
+        for k in range(N+1): Cn[k] = gf_sub(Cn[k], gf_mul(fac, sB[k]))
+        if 2*L <= n: L = n+1-L; B = C[:]; b = d; m = 1; C = Cn
+        else: m += 1; C = Cn
+    idx = N
+    while idx > 0 and C[idx] % P == 0: idx -= 1
+    C = C[:idx+1]
+    if C and C[0] % P != 1:
+        inv = gf_inv(C[0]); C = [gf_mul(c, inv) for c in C]
+    return C
+
+def rs_correct(mask_sym, vals, ND, NC, era_idx):
+    NW = len(vals)
+    r = [mask_sym] + [(v if v is not None else 0) for v in vals]
+    era = [1 + i for i in era_idx if 0 <= i < NW]
+    S = syndromes(r, NC)
+    if all(s % P == 0 for s in S) and not era: return [v if v is not None else 0 for v in vals], []
+    if len(era) > NC: return None
+    Le = erasure_locator(era); SLe = pmod_xk(pmul(S[:], Le), NC)
+    Lu = berlekamp_massey(SLe); Lam = ptrim(pmul(Le, Lu))
+    Om = pmod_xk(pmul(S[:], Lam), NC); Ld = pder(Lam)
+    err_pos = []; err_mag = {}
+    for j in range(len(r)):
+        x = gf_pow(ALPHA, -j)
+        if peval(Lam, x) % P == 0:
+            if j == 0: continue
+            num = peval(Om, x); den = peval(Ld, x)
+            if den % P == 0: continue
+            mag = gf_sub(0, gf_div(num, den))
+            if mag % P != 0: err_pos.append(j); err_mag[j] = mag
+    rc = r[:]
+    for j in err_pos: rc[j] = gf_sub(rc[j], err_mag[j])
+    Sa = syndromes(rc, NC)
+    if any(s % P != 0 for s in Sa): return None
+    return rc[1:], [p-1 for p in err_pos]
+
+def solve_ND_NC(NW):
+    for ND in range(0, NW+1):
+        NC = 3 + ((ND+1)//2)
+        if ND + NC == NW: return (ND, NC)
+    for ND in range(0, NW+1):
+        NC = 3 + (ND//2)
+        if ND + NC == NW: return (ND, NC)
+    return None, None
+
+def mask_step(mid): return [0, 3, 7, 17][mid]
+
+def decode_codesets(vals):
+    msg = []; cs = "C"; i = 0; shift_to = None; shift_n = 0; upper_A = upper_B = False
+    while i < len(vals):
+        v = vals[i]
+        if v == 107: break
+        if v == 108: msg.append("<FNC2>"); i += 1; continue
+        if v == 109: msg.append("<FNC3>"); i += 1; continue
+        if v == 110: upper_A = True; i += 1; continue
+        if v == 111: upper_B = True; i += 1; continue
+        if v == 112: return None
+        if v > 112: break
+        eff = shift_to if shift_n > 0 and shift_to else cs
+        if eff == "C" and v == 100: break
+        if eff in ("A", "B") and v >= 107 and msg: break
+        def tick():
+            nonlocal shift_n, shift_to
+            if shift_n > 0: shift_n -= 1
+            if shift_n == 0: shift_to = None
+        def uc(ch):
+            nonlocal upper_A, upper_B
+            if upper_A or upper_B: ch = chr((ord(ch) + 128) % 256); upper_A = upper_B = False
+            return ch
+        if eff == "C":
+            if v == 101: cs = "A"; shift_to = None; shift_n = 0
+            elif v == 102: shift_to = "B"; shift_n = 1
+            elif v == 103: shift_to = "B"; shift_n = 2
+            elif v == 104: shift_to = "B"; shift_n = 3
+            elif v == 105: shift_to = "B"; shift_n = 4
+            elif v == 106: cs = "B"; shift_to = None; shift_n = 0
+            elif 0 <= v <= 99: msg.append(f"{v:02d}"); tick()
+        elif eff == "A":
+            if v == 101: shift_to = "B"; shift_n = 1
+            elif v == 102: cs = "B"; shift_to = None; shift_n = 0
+            elif v == 103: shift_to = "C"; shift_n = 2
+            elif v == 104: shift_to = "C"; shift_n = 3
+            elif v == 105: shift_to = "C"; shift_n = 4
+            elif v == 106: cs = "C"; shift_to = None; shift_n = 0
+            elif 0 <= v <= 63: msg.append(uc(chr(32 + v))); tick()
+            elif 64 <= v <= 95: msg.append(uc(chr(v - 64))); tick()
+            else: tick()
+        elif eff == "B":
+            if v == 101: shift_to = "A"; shift_n = 1
+            elif v == 102: cs = "A"; shift_to = None; shift_n = 0
+            elif v == 103: shift_to = "C"; shift_n = 2
+            elif v == 104: shift_to = "C"; shift_n = 3
+            elif v == 105: shift_to = "C"; shift_n = 4
+            elif v == 106: cs = "C"; shift_to = None; shift_n = 0
+            elif 0 <= v <= 95: msg.append(uc(chr(32 + v))); tick()
+            elif v == 96: msg.append("\r\n"); tick()
+            elif v == 97: msg.append("\t"); tick()
+            elif v == 98: msg.append(chr(28)); tick()
+            elif v == 99: msg.append(chr(29)); tick()
+            elif v == 100: msg.append(chr(30)); tick()
+            else: tick()
+        i += 1
+    result = "".join(msg)
+    if len(result) >= 12:
+        for pad in ["27", "28", "29", "00", "99", "14"]:
+            if result.endswith(pad): result = result[:-2]; break
+    return result if result else None
+
+def decode_bits(bitstr):
+    s = "".join(bitstr.split())
+    if not all(c in "01" for c in s) or len(s) < 20: return None
+    ones = s.count("1") / len(s) * 100
+    if ones > 78 or ones < 8: return None
+    mask_id = (int(s[0]) << 1) | int(s[1])
+    cw_bits = [s[2+k*9:2+(k+1)*9] for k in range((len(s)-2)//9)]
+    vals = []; era = []
+    for idx, b in enumerate(cw_bits):
+        v = None
+        if len(b) == 9 and b.count("1") == 5: v = DOT_TO_VAL.get(b)
+        if v is None: vals.append(None); era.append(idx)
+        else: vals.append(v)
+    NW = len(vals)
+    ND, NC = solve_ND_NC(NW)
+    if ND is None: return None
+    if all(v is not None for v in vals[:ND]):
+        step = mask_step(mask_id)
+        dv = [(vals[i] - step * i) % P for i in range(ND)]
+        msg = decode_codesets(dv)
+        if msg and len(msg) >= 4:
+            if not any(c in msg for c in ['/', '\\', '\x00', '\xff', ')', '(', '<']):
+                return msg
+    res = rs_correct(mask_id, vals, ND, NC, era)
+    if res is None: return None
+    corrected, _ = res
+    step = mask_step(mask_id)
+    dv = [(corrected[i] - step * i) % P for i in range(ND)]
+    msg = decode_codesets(dv)
+    if msg and len(msg) >= 4:
+        if not any(c in msg for c in ['/', '\\', '\x00', '\xff', ')', '(', '<']):
+            return msg
+    return None
+
+def is_valid_message(msg):
+    if msg is None or len(msg) < 4: return False
+    if msg.isdigit() and len(msg) > 20: return False
+    if any(c in msg for c in ['/', '\\', '\x00', '\xff', ')', '(', '<']): return False
+    return True
+
+# ============================================================
+# IMAGE PROCESSING (SAME AS v74.2)
+# ============================================================
+class BinaryPyramid:
+    def __init__(self, gray):
+        clahe = cv2.createCLAHE(clipLimit=2.0, tileGridSize=(8, 8))
+        self.enhanced = clahe.apply(gray)
+        self._base = {}
+        self._eroded = {}
+
+    def get(self, mode, fixed_t, erosion_level):
+        key = (mode, fixed_t, erosion_level)
+        if key in self._eroded: return self._eroded[key]
+        base_key = (mode, fixed_t)
+        if base_key not in self._base:
+            if mode == "otsu":
+                _, b = cv2.threshold(self.enhanced, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
+            else:
+                _, b = cv2.threshold(self.enhanced, fixed_t, 255, cv2.THRESH_BINARY)
+            self._base[base_key] = cv2.morphologyEx(b, cv2.MORPH_OPEN, _KERNEL, iterations=1)
+        cur, start = self._base[base_key], 0
+        for lvl in range(erosion_level, 0, -1):
+            if (mode, fixed_t, lvl) in self._eroded:
+                cur, start = self._eroded[(mode, fixed_t, lvl)], lvl
+                break
+        for lvl in range(start + 1, erosion_level + 1):
+            cur = cv2.erode(cur, _KERNEL, iterations=1)
+            self._eroded[(mode, fixed_t, lvl)] = cur
+        return cur
+
+def _score_blobs_from_binary(bw):
+    num, _, stats, centroids = cv2.connectedComponentsWithStats(bw, 8)
+    blobs = []
+    for i in range(1, num):
+        x, y, w, h, area = stats[i]
+        if w < 2 or h < 2 or w > 80 or h > 80: continue
+        blobs.append({"cx": centroids[i][0], "cy": centroids[i][1], "w": w, "h": h})
+    if not blobs: return None
+    med_w = float(np.median([b["w"] for b in blobs]))
+    med_h = float(np.median([b["h"] for b in blobs]))
+    strict = [b for b in blobs if 0.70*med_w <= b["w"] <= 1.30*med_w and 0.70*med_h <= b["h"] <= 1.30*med_h]
+    return {"n": len(strict), "med_w": med_w, "med_h": med_h, "blobs": strict}
+
+def detect_dots(pyramid, mode, fixed_t, erosion_level):
+    binary = pyramid.get(mode, fixed_t, erosion_level)
+    scored = _score_blobs_from_binary(binary)
+    if not scored or scored["n"] < MIN_DOTS: return None, None
+    pts = np.array([[b["cx"], b["cy"]] for b in scored["blobs"]], dtype=np.float32)
+    dot_info = {"med_w": scored["med_w"], "med_h": scored["med_h"], "num_dots": scored["n"]}
+    return pts, dot_info
+
+def kmeans_1d(vals, k):
+    arr = np.array(vals, dtype=np.float32).reshape(-1, 1)
+    k = max(2, min(k, len(vals)))
+    crit = (cv2.TERM_CRITERIA_EPS + cv2.TERM_CRITERIA_MAX_ITER, 100, 0.1)
+    _, _, centers = cv2.kmeans(arr, k, None, crit, 1, cv2.KMEANS_PP_CENTERS)
+    return np.sort(centers.flatten())
+
+def snap_to_grid_checkerboard(pts, n_rows, n_cols, dot_info):
+    if len(pts) < max(n_rows, n_cols): return None, None, None
+    row_c = kmeans_1d(pts[:, 1], n_rows)
+    col_c = kmeans_1d(pts[:, 0], n_cols)
+    H, W = len(row_c), len(col_c)
+    if H < 2 or W < 2: return None, None, None
+    row_step = float(np.median(np.diff(row_c))) if H > 1 else 15.0
+    col_step = float(np.median(np.diff(col_c))) if W > 1 else 15.0
+    med_h = dot_info.get("med_h", row_step * 0.5)
+    med_w = dot_info.get("med_w", col_step * 0.5)
+    ry = med_h * 0.70; rx = med_w * 0.70
+    xs = pts[:, 0]; ys = pts[:, 1]
+    r_idx = np.argmin(np.abs(row_c[None, :] - ys[:, None]), axis=1)
+    c_idx = np.argmin(np.abs(col_c[None, :] - xs[:, None]), axis=1)
+    dr = np.abs(row_c[r_idx] - ys); dc = np.abs(col_c[c_idx] - xs)
+    valid = (dr <= ry) & (dc <= rx)
+    grid = np.zeros((H, W), dtype=np.uint8)
+    grid[r_idx[valid], c_idx[valid]] = 1
+    return grid, row_c, col_c
+
+# ============================================================
+# EXTRACTOR
+# ============================================================
+def extract_senior1(grid):
+    T = grid.T
+    corner = [0] * 6; Mask = []; data_bit = []; ncols = T.shape[0]
+    for i, row in enumerate(T):
+        cropped = row[(i % 2)::2]; n = len(cropped)
+        if n < 2: continue
+        if i == 0:
+            corner[5] = int(cropped[0]); corner[1] = int(cropped[-1])
+            if n >= 3: Mask = list(cropped[1:3])
+            if n > 3: data_bit.extend(cropped[3:-1])
+        elif i == 1:
+            corner[3] = int(cropped[-1]); data_bit.extend(cropped[0:-1])
+        elif i == ncols - 2:
+            corner[2] = int(cropped[-1]); data_bit.extend(cropped[0:-1])
+        elif i == ncols - 1:
+            corner[4] = int(cropped[0]); corner[0] = int(cropped[-1])
+            if n > 1: data_bit.extend(cropped[1:-1])
+        else:
+            data_bit.extend(cropped)
+    return "".join(str(b) for b in Mask + data_bit + corner)
+
+# ============================================================
+# DECODE FROM GRID
+# ============================================================
+_GRID_R_IDX = np.arange(GRID_ROWS)[:, None]
+_GRID_C_IDX = np.arange(GRID_COLS)[None, :]
+_GRID_MASK_OFFSET0 = (_GRID_R_IDX + _GRID_C_IDX) % 2 == 0
+_GRID_TOTAL_CELLS = (GRID_ROWS * GRID_COLS + 1) // 2
+
+def decode_from_grid(grid):
+    if grid is None: return None
+    H, W = grid.shape
+    if (H, W) == (GRID_ROWS, GRID_COLS):
+        mask = _GRID_MASK_OFFSET0
+        total_cells = _GRID_TOTAL_CELLS
+    else:
+        r_indices = np.arange(H)[:, None]
+        c_indices = np.arange(W)[None, :]
+        mask = (r_indices + c_indices) % 2 == 0
+        total_cells = (H * W + 1) // 2
+
+    g = grid * mask
+    occupancy = np.sum(g) / total_cells
+    if occupancy < 0.08:
+        return None
+
+    bits = extract_senior1(g)
+    if bits and len(bits) >= 100:
+        ones_ratio = bits.count('1') / len(bits)
+        if 0.08 <= ones_ratio <= 0.72:
+            msg = decode_bits(bits)
+            if msg and is_valid_message(msg):
+                return msg
+    return None
+
+# ============================================================
+# REGRESSION-BASED STRAIGHTENING
+# ============================================================
+
+def get_global_tilt_angle_regression(pts):
+    if len(pts) < 5:
+        return 0
+    
+    xs = pts[:, 0]
+    ys = pts[:, 1]
+    
+    coeffs = np.polyfit(xs, ys, 1)
+    slope = coeffs[0]
+    angle = np.degrees(np.arctan(slope))
+    
+    if angle > 45:
+        angle -= 90
+    elif angle < -45:
+        angle += 90
+    
+    return angle
+
+def rotate_points(pts, angle):
+    if abs(angle) < 0.05:
+        return pts
+    center = np.mean(pts, axis=0)
+    theta = np.radians(-angle)
+    c, s = np.cos(theta), np.sin(theta)
+    R = np.array([[c, -s], [s, c]])
+    return (pts - center) @ R.T + center
+
+def compute_row_quality(pts, n_rows=GRID_ROWS):
+    """
+    Compute how well points align to rows (lower score = better alignment)
+    """
+    if len(pts) < 20:
+        return float('inf')
+    
+    ys = pts[:, 1]
+    row_centers = kmeans_1d(ys, n_rows)
+    row_idx = np.argmin(np.abs(row_centers[None, :] - ys[:, None]), axis=1)
+    
+    total_var = 0
+    valid_rows = 0
+    
+    for r in range(len(row_centers)):
+        mask = row_idx == r
+        if mask.sum() > 3:
+            total_var += np.var(ys[mask])
+            valid_rows += 1
+    
+    if valid_rows == 0:
+        return float('inf')
+    return total_var / valid_rows
+
+def get_angle_from_rows(pts, n_rows=GRID_ROWS):
+    """
+    Compute angle by finding row slopes and averaging.
+    This handles curvature better than global line fit.
+    """
+    if len(pts) < 20:
+        return 0
+    
+    ys = pts[:, 1]
+    xs = pts[:, 0]
+    
+    # 1. Find row centers
+    row_centers = kmeans_1d(ys, n_rows)
+    row_idx = np.argmin(np.abs(row_centers[None, :] - ys[:, None]), axis=1)
+    
+    # 2. For each row, compute its slope
+    slopes = []
+    row_counts = []
+    
+    for r in range(len(row_centers)):
+        mask = row_idx == r
+        count = mask.sum()
+        if count < 4:
+            continue
+        
+        row_xs = xs[mask]
+        row_ys = ys[mask]
+        
+        try:
+            coeffs = np.polyfit(row_xs, row_ys, 1)
+            slopes.append(coeffs[0])
+            row_counts.append(count)
+        except:
+            continue
+    
+    if not slopes:
+        return 0
+    
+    # 3. Average the slopes (weighted by row size)
+    weights = np.array(row_counts) / sum(row_counts)
+    avg_slope = np.sum(np.array(slopes) * weights)
+    
+    # 4. Convert to angle
+    angle = np.degrees(np.arctan(avg_slope))
+    
+    if angle > 45:
+        angle -= 90
+    elif angle < -45:
+        angle += 90
+    
+    return angle
+
+def straighten_dots_regression_iterative(pts, n_rows=GRID_ROWS, degree=2, iterations=2):
+    """
+    ITERATIVE REGRESSION:
+    1. Get angle from row slopes
+    2. Rotate points
+    3. Cluster rows
+    4. Fit per-row quadratic curves
+    5. Apply correction
+    6. Repeat (re-cluster with corrected points)
+    7. Returns straightened points
+    """
+    if pts is None or len(pts) < 20:
+        return pts, 0
+    
+    # ─── Step 1: Initial angle from rows ───
+    angle = get_angle_from_rows(pts, n_rows)
+    current_pts = rotate_points(pts, angle)
+    best_angle = angle
+    
+    # ─── Step 2: Iterative refinement ───
+    for iteration in range(iterations):
+        xs = current_pts[:, 0]
+        ys = current_pts[:, 1]
+        
+        # Cluster rows
+        row_centers = kmeans_1d(ys, n_rows)
+        row_idx = np.argmin(np.abs(row_centers[None, :] - ys[:, None]), axis=1)
+        
+        # Fit per-row polynomials
+        coeffs_list = []
+        row_weights = []
+        
+        for r in range(len(row_centers)):
+            mask = row_idx == r
+            count = mask.sum()
+            if count < max(4, degree + 2):
+                continue
+            
+            row_xs = xs[mask]
+            row_ys = ys[mask]
+            
+            try:
+                c = np.polyfit(row_xs, row_ys, degree)
+                coeffs_list.append(c)
+                row_weights.append(count)
+            except:
+                continue
+        
+        # If we have enough rows, apply correction
+        if len(coeffs_list) >= 2:
+            weights = np.array(row_weights) / sum(row_weights)
+            avg_coeffs = np.zeros(len(coeffs_list[0]))
+            
+            for c, w in zip(coeffs_list, weights):
+                avg_coeffs += c * w
+            
+            trend = np.polyval(avg_coeffs, xs)
+            mean_y = float(np.mean(ys))
+            current_pts[:, 1] = ys - trend + mean_y
+            
+            # Recompute angle for next iteration (if any)
+            if iteration < iterations - 1:
+                angle = get_angle_from_rows(current_pts, n_rows)
+                current_pts = rotate_points(current_pts, angle)
+                best_angle = angle
+        else:
+            # Not enough rows, break out
+            break
+    
+    # ─── Step 3: Final angle ───
+    final_angle = get_angle_from_rows(current_pts, n_rows)
+    
+    # ─── Step 4: Quality check ───
+    final_score = compute_row_quality(current_pts, n_rows)
+    original_score = compute_row_quality(pts, n_rows)
+    
+    # If we made it worse, return original
+    if final_score > original_score * 1.2:
+        return pts, 0
+    
+    return current_pts, final_angle
+
+# ============================================================
+# SMART COMBO SELECTION
+# ============================================================
+
+def get_smart_combos(mean_brightness):
+    if mean_brightness < 40:
+        return [
+            ("otsu", None, [2, 3, 4]),
+            ("fixed", 135, [2, 3]),
+            ("fixed", 145, [2, 3]),
+            ("fixed", 155, [2, 3]),
+        ]
+    elif mean_brightness < 55:
+        return [
+            ("otsu", None, [2, 3]),
+            ("fixed", 145, [2, 3]),
+            ("fixed", 155, [2, 3]),
+            ("fixed", 165, [2, 3]),
+        ]
+    elif mean_brightness < 70:
+        return [
+            ("otsu", None, [2, 3]),
+            ("fixed", 155, [2, 3, 4]),
+            ("fixed", 165, [2, 3, 4]),
+            ("fixed", 175, [2, 3]),
+        ]
+    else:
+        return [
+            ("otsu", None, [2, 3]),
+            ("fixed", 165, [2, 3]),
+            ("fixed", 175, [2, 3]),
+            ("fixed", 155, [2, 3]),
+        ]
+
+# ============================================================
+# v74.9 - ITERATIVE REGRESSION
+# ============================================================
+
+def decode_image_v74_iterative(img, filename=None, timeout_ms=300):
+    """
+    Same as v74.7 but with iterative regression.
+    """
+    if img is None:
+        return None, None, 0, 0, False
+
+    start_time = time.time()
+    
+    def check_timeout():
+        return (time.time() - start_time) * 1000 > timeout_ms
+    
+    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) if img.ndim == 3 else img
+    pyramid = BinaryPyramid(gray)
+    mean_brightness = gray.mean()
+
+    # ─── STEP 1: Find BEST dots ───
+    best_pts = None
+    best_dot_info = None
+    best_count = 0
+    
+    smart_combos = get_smart_combos(mean_brightness)
+    
+    for mode, threshold, erosions in smart_combos:
+        for erosion in erosions:
+            pts, dot_info = detect_dots(pyramid, mode, threshold, erosion)
+            if pts is not None and len(pts) > best_count:
+                best_count = len(pts)
+                best_pts = pts
+                best_dot_info = dot_info
+    
+    if best_pts is None or len(best_pts) < MIN_DOTS:
+        elapsed = (time.time() - start_time) * 1000
+        return None, None, elapsed, 0, False
+
+    # Check timeout after dot detection
+    if check_timeout():
+        return None, "TIMEOUT", timeout_ms, 0, True
+
+    # ─── STEP 2: ITERATIVE REGRESSION ───
+    straight_pts, angle = straighten_dots_regression_iterative(best_pts, GRID_ROWS, degree=2, iterations=REGRESSION_ITERATIONS)
+
+    # ONLY ONE regression decode attempt (not 7-10x)
+    grid, _, _ = snap_to_grid_checkerboard(straight_pts, GRID_ROWS, GRID_COLS, best_dot_info)
+    if grid is not None:
+        occupancy = np.sum(grid) / _GRID_TOTAL_CELLS
+        if occupancy >= 0.08:
+            msg = decode_from_grid(grid)
+            if msg:
+                elapsed = (time.time() - start_time) * 1000
+                method = f"reg_iter_{angle:.1f}"
+                return msg, method, elapsed, 1, False
+
+    # ─── STEP 3: Finer Angle Sweep (UNCHANGED) ───
+    fallback_thresholds = [
+        ("otsu", None, [2, 3]),
+        ("fixed", 155, [2, 3]),
+        ("fixed", 165, [2, 3]),
+        ("fixed", 145, [2, 3]),
+        ("fixed", 175, [2, 3]),
+        ("fixed", 135, [2, 3]),
+        ("fixed", 125, [2, 3]),
+        ("fixed", 115, [2, 3]),
+        ("fixed", 105, [2, 3]),
+    ]
+    
+    fine_angles = [3.0, 2.5, 2.0, 1.5, 1.0, 0.5, -0.5, -1.0, -1.5, -2.0, -2.5, -3.0]
+    # fine_angles = [ 1.0, 0.5, -0.5, -1.0]
+    
+    for mode, threshold, erosions in fallback_thresholds:
+        if check_timeout():
+            return None, "TIMEOUT", timeout_ms, 0, True
+            
+        for erosion in erosions:
+            pts, dot_info = detect_dots(pyramid, mode, threshold, erosion)
+            if pts is None or len(pts) < MIN_DOTS:
+                continue
+            
+            for angle in fine_angles:
+                if check_timeout():
+                    return None, "TIMEOUT", timeout_ms, 0, True
+                    
+                rotated_pts = rotate_points(pts, angle)
+                grid, _, _ = snap_to_grid_checkerboard(rotated_pts, GRID_ROWS, GRID_COLS, dot_info)
+                if grid is None:
+                    continue
+                
+                occupancy = np.sum(grid) / _GRID_TOTAL_CELLS
+                if occupancy < 0.08:
+                    continue
+                
+                msg = decode_from_grid(grid)
+                if msg:
+                    confidence = occupancy * min(len(pts) / 150, 1.0)
+                    method = f"ang_{mode if mode == 'otsu' else f'fixed_{threshold}'}_e{erosion}"
+                    
+                    if confidence >= EARLY_EXIT_CONFIDENCE:
+                        elapsed = (time.time() - start_time) * 1000
+                        return msg, method, elapsed, 2, False
+
+    # ─── STEP 4: Last Resort - Invert (UNCHANGED) ───
+    if not check_timeout():
+        inverted = cv2.bitwise_not(gray)
+        pyramid_inv = BinaryPyramid(inverted)
+        
+        for mode, threshold, erosions in [("otsu", None, [2, 3]), ("fixed", 155, [2, 3])]:
+            if check_timeout():
+                return None, "TIMEOUT", timeout_ms, 0, True
+                
+            for erosion in erosions:
+                pts, dot_info = detect_dots(pyramid_inv, mode, threshold, erosion)
+                if pts is None or len(pts) < MIN_DOTS:
+                    continue
+                
+                for angle in fine_angles[:5]:
+                    if check_timeout():
+                        return None, "TIMEOUT", timeout_ms, 0, True
+                        
+                    rotated_pts = rotate_points(pts, angle)
+                    grid, _, _ = snap_to_grid_checkerboard(rotated_pts, GRID_ROWS, GRID_COLS, dot_info)
+                    if grid is None:
+                        continue
+                    
+                    occupancy = np.sum(grid) / _GRID_TOTAL_CELLS
+                    if occupancy < 0.08:
+                        continue
+                    
+                    msg = decode_from_grid(grid)
+                    if msg:
+                        confidence = occupancy * min(len(pts) / 150, 1.0)
+                        method = f"inv_{mode if mode == 'otsu' else f'fixed_{threshold}'}_e{erosion}"
+                        
+                        if confidence >= EARLY_EXIT_CONFIDENCE:
+                            elapsed = (time.time() - start_time) * 1000
+                            return msg, method, elapsed, 3, False
+
+    elapsed = (time.time() - start_time) * 1000
+    return None, None, elapsed, 0, False
+
+# ============================================================
+# PROCESS IMAGE
+# ============================================================
+def process_image_v74_iterative(img_path, timeout_seconds=0.3):
+    filename = os.path.basename(img_path)
+    img = cv2.imread(img_path)
+    if img is None:
+        return {"file": filename, "success": False, "message": "READ_ERROR", "time": 0, "method": "N/A", "stage": 0, "timed_out": False}
+
+    msg, method, elapsed, stage, timed_out = decode_image_v74_iterative(img, filename, timeout_ms=timeout_seconds * 1000)
+    
+    if timed_out:
+        save_path = os.path.join(UNDETECTED_DIR, f"{os.path.splitext(filename)[0]}_timeout.jpg")
+        cv2.imwrite(save_path, img)
+        return {"file": filename, "success": False, "message": "TIMEOUT", "time": timeout_seconds * 1000, "method": "TIMEOUT", "stage": 0, "timed_out": True}
+
+    if msg is not None:
+        save_path = os.path.join(DECODED_DIR, f"{os.path.splitext(filename)[0]}_decoded.jpg")
+        cv2.imwrite(save_path, img)
+        return {"file": filename, "success": True, "message": msg, "time": elapsed, "method": method, "stage": stage, "timed_out": False}
+    else:
+        save_path = os.path.join(UNDETECTED_DIR, f"{os.path.splitext(filename)[0]}_undetected.jpg")
+        cv2.imwrite(save_path, img)
+        return {"file": filename, "success": False, "message": "FAILED", "time": elapsed, "method": "N/A", "stage": 0, "timed_out": False}
+
+# ============================================================
+# BATCH PROCESSING
+# ============================================================
+def batch_decode():
+    print(f"\n{'='*80}")
+    print(f"🚀 v74.9 - ITERATIVE REGRESSION")
+    print(f"{'='*80}")
+    print(f"📂 Input: {INPUT_DIR}")
+    print(f"📁 Output: {OUTPUT_DIR}")
+    print(f"⚡ Per-row quadratic regression with {REGRESSION_ITERATIONS} iterations")
+    print(f"⏱️  TIMEOUT: {TIMEOUT_SECONDS*1000}ms (only between stages)")
+    print(f"{'='*80}\n")
+
+    images = []
+    for ext in ['*.jpg', '*.jpeg', '*.png', '*.bmp']:
+        images.extend(glob.glob(os.path.join(INPUT_DIR, ext)))
+
+    if not images:
+        print("No images found")
+        return
+
+    print(f"Found {len(images)} images")
+    print("-" * 80)
+
+    total_start = time.time()
+    success_count = 0
+    timeout_count = 0
+    total_time = 0.0
+    failed_images = []
+    timeout_images = []
+    method_counts = {}
+    stage_counts = {1: 0, 2: 0, 3: 0}
+
+    chunksize = max(1, len(images) // (MAX_WORKERS * 8))
+    with ProcessPoolExecutor(max_workers=MAX_WORKERS) as executor:
+        futures = {executor.submit(process_image_v74_iterative, img, TIMEOUT_SECONDS): img for img in images}
+        
+        for idx, (future, img) in enumerate(futures.items(), 1):
+            try:
+                result = future.result(timeout=TIMEOUT_SECONDS + 0.1)
+            except FutureTimeoutError:
+                filename = os.path.basename(img)
+                timeout_count += 1
+                timeout_images.append(filename)
+                print(f"[{idx}/{len(images)}] ⏱️ {filename} TIMEOUT (> {TIMEOUT_SECONDS*1000}ms)")
+                continue
+
+            total_time += result['time']
+
+            if result['success']:
+                success_count += 1
+                method = result.get('method', 'unknown')
+                method_counts[method] = method_counts.get(method, 0) + 1
+                stage = result.get('stage', 0)
+                if stage in stage_counts:
+                    stage_counts[stage] += 1
+                
+                stage_label = {1: "REG", 2: "ANG", 3: "INV"}.get(stage, "?")
+                print(f"[{idx}/{len(images)}] ✅ {result['file']} → {result['message'][:20]}... "
+                      f"({result['time']:.0f}ms) [{stage_label}:{method}]")
+            else:
+                if result.get('timed_out', False):
+                    timeout_count += 1
+                    timeout_images.append(result['file'])
+                    print(f"[{idx}/{len(images)}] ⏱️ {result['file']} TIMEOUT ({result['time']:.0f}ms)")
+                else:
+                    failed_images.append(result['file'])
+                    print(f"[{idx}/{len(images)}] ❌ {result['file']} FAILED ({result['time']:.0f}ms)")
+
+            if idx % 50 == 0:
+                avg = total_time / idx if idx > 0 else 0
+                eta = (len(images) - idx) * avg / 1000
+                print(f"📊 Progress: {idx}/{len(images)} | Success: {success_count} | Timeouts: {timeout_count} | Avg:{avg:.0f}ms | ETA:{eta:.1f}s")
+
+    total_time_sec = time.time() - total_start
+    avg_time = total_time / len(images) if images else 0
+
+    print("=" * 80)
+    print("BATCH PROCESSING COMPLETE")
+    print(f"Total images: {len(images)}")
+    print(f"✅ Success: {success_count} ({success_count/len(images)*100:.1f}%)")
+    print(f"❌ Failed: {len(images) - success_count - timeout_count} ({(len(images)-success_count-timeout_count)/len(images)*100:.1f}%)")
+    print(f"⏱️  Timeouts: {timeout_count} ({timeout_count/len(images)*100:.1f}%)")
+    print(f"⏱️  Total wall time: {total_time_sec:.1f}s")
+    print(f"⚡ Average per-image compute time: {avg_time:.0f}ms")
+    
+    print(f"\n📊 Stage Distribution:")
+    print(f"  Regression (fast): {stage_counts.get(1, 0)} images")
+    print(f"  Angle Sweep: {stage_counts.get(2, 0)} images")
+    print(f"  Invert Fallback: {stage_counts.get(3, 0)} images")
+    
+    if failed_images:
+        print(f"\n❌ FAILED IMAGES ({len(failed_images)}):")
+        for f in sorted(failed_images)[:20]:
+            print(f"  - {f}")
+        if len(failed_images) > 20:
+            print(f"  ... and {len(failed_images)-20} more")
+            
+    if timeout_images:
+        print(f"\n⏱️ TIMEOUT IMAGES ({len(timeout_images)}):")
+        for f in sorted(timeout_images)[:20]:
+            print(f"  - {f}")
+        if len(timeout_images) > 20:
+            print(f"  ... and {len(timeout_images)-20} more")
+    print("=" * 80)
+
+if __name__ == "__main__":
+    mp.freeze_support()
+    batch_decode()