Update app/eyes_localizer.py

app/eyes_localizer.py

@@ -21,76 +21,22 @@ def _to_b64(img_rgb):
 def _safe_rgb2lab(rgb):
     """
     Aceita uint8 [0..255] ou float [0..1].
-    Converte com skimage para Lab (float).
+    Retorna L*, a*, b* no padrão scikit-image (L em [0..100]).
     """
-    if rgb.dtype != np.float32 and rgb.dtype != np.float64:
-        arr = rgb.astype(np.float32) / 255.0
-    else:
-        arr = np.clip(rgb, 0.0, 1.0).astype(np.float32)
+    arr = rgb
+    if arr.dtype != np.uint8:
+        arr = np.clip(arr, 0.0, 255.0).astype(np.float32)
+        if arr.max() <= 1.0:
+            arr = (arr * 255.0).astype(np.uint8)
     lab = color.rgb2lab(arr)
-    L = lab[...,0].astype(np.float32)
-    a = lab[...,1].astype(np.float32)
-    b = lab[...,2].astype(np.float32)
-    return L, a, b
+    return lab[...,0].astype(np.float32), lab[...,1].astype(np.float32), lab[...,2].astype(np.float32)
 
-def _ring_mask(h, w, cx, cy, rin, rout):
-    if h <= 0 or w <= 0:
-        return np.zeros((0,0), dtype=bool)
-    Y, X = np.ogrid[:h, :w]
-    rr = np.sqrt((X - cx)**2 + (Y - cy)**2)
-    m = (rr >= rin) & (rr <= rout)
-    if not np.any(m):
-        return m
-    return m
-
-def _lab_p50_and_med_robust(L, a, b, mask):
-    sel = (mask.astype(bool) if mask is not None else np.zeros(0, bool))
-    if sel.sum() < 20:
-        return None, None, None, None, None, None
-    Ls, As, Bs = L[sel], a[sel], b[sel]
-    def med_mid(x):
-        if x.size == 0: return None
-        lo, hi = np.nanquantile(x, 0.20), np.nanquantile(x, 0.80)
-        y = x[(x>=lo)&(x<=hi)]
-        return float(np.nanmedian(y)) if y.size else float(np.nanmedian(x))
-    Lm = med_mid(Ls); am = med_mid(As); bm = med_mid(Bs)
-    C_arr = np.hypot(As, Bs).astype(np.float32)
-    Cm = float(np.nanmedian(C_arr)) if C_arr.size else None
-    Lp50 = float(np.nanmedian(Ls)) if Ls.size else None
-    Cp50 = float(np.nanmedian(C_arr)) if C_arr.size else None
-    return Lm, am, bm, Cm, Lp50, Cp50
-
-def _hsv_S(rgb_u8):
-    if rgb_u8.dtype != np.uint8:
-        rgb_u8 = np.clip(rgb_u8, 0, 255).astype(np.uint8)
-    hsv = cv.cvtColor(rgb_u8, cv.COLOR_RGB2HSV)
-    return (hsv[...,1].astype(np.float32)) / 255.0
-
-def _bbox_from_contour(c):
-    x,y,w,h = cv.boundingRect(c)
-    return (x,y,x+w,y+h)
-
-def _pick_eye_contours(eyes_mask):
-    m = (eyes_mask.astype(np.uint8) if eyes_mask is not None else None)
-    if m is None or m.sum() < 10:
-        return []
-    cnts, _ = cv.findContours(m, cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
-    if not cnts: 
-        return []
-    cnts = sorted(cnts, key=cv.contourArea, reverse=True)[:2]
-    return cnts
-
-def _circle_inside_bbox(cx, cy, r, bbox):
-    x0,y0,x1,y1 = bbox
-    return (cx>=x0 and cx<=x1 and cy>=y0 and cy<=y1 and r>2)
+def _hsv_S(img_rgb):
+    hsv = cv.cvtColor(img_rgb.astype(np.uint8), cv.COLOR_RGB2HSV)
+    return (hsv[...,1].astype(np.float32))/255.0
 
 def _fit_circle(points_xy):
-    """
-    Ajuste de círculo por mínimos quadrados (Taubin).
-    Resistente à singularidade (denominador ~0).
-    """
-    if points_xy is None or len(points_xy) < 3:
-        return None
+    """Ajuste de círculo por mínimos quadrados (Taubin)."""
     x = points_xy[:,0].astype(np.float64)
     y = points_xy[:,1].astype(np.float64)
     x_m = x.mean(); y_m = y.mean()
@@ -98,141 +44,122 @@ def _fit_circle(points_xy):
     Suu = (u*u).mean(); Svv = (v*v).mean(); Suv = (u*v).mean()
     Suuu = (u*u*u).mean(); Svvv = (v*v*v).mean()
     Suvv = (u*v*v).mean(); Svuu = (v*u*u).mean()
-    den = 2.0*(Suu*Svv - Suv*Suv)
-    if abs(den) < 1e-9:
-        return None
+    den = 2.0*(Suu*Svv - Suv*Suv) if abs(Suu*Svv - Suv*Suv) > 1e-9 else 1e-9
     uc = ((Svv*(Suuu+Suvv) - Suv*(Svvv+Svuu)) / den)
     vc = ((Suu*(Svvv+Svuu) - Suv*(Suuu+Suvv)) / den)
     cx = x_m + uc; cy = y_m + vc
-    r  = np.sqrt(uc*uc + vc*vc + Suu + Svv)
-    if not np.isfinite(cx) or not np.isfinite(cy) or not np.isfinite(r) or r <= 0:
-        return None
+    r  = float(np.sqrt(uc*uc + vc*vc + Suu + Svv))
     return float(cx), float(cy), float(r)
 
-def _draw_overlay(roi_rgb, cx, cy, rin, rout):
-    vis = roi_rgb.copy()
-    try:
-        cv.circle(vis, (int(round(cx)), int(round(cy))), max(1,int(round(rin))), (0,255,0), 2)
-        cv.circle(vis, (int(round(cx)), int(round(cy))), max(2,int(round(rout))), (0,255,0), 2)
-    except Exception:
-        pass
-    return _to_b64(vis)
-
-def _cfg(cfg, key, default):
-    if isinstance(cfg, dict):
-        return cfg.get(key, default)
-    return default
-
-# ----------------- Função principal -----------------
-def localize_iris_and_sample_mediapipe(orig_rgb, eyes_mask, config=None, debug=False):
+def _ring_mask(h, w, cx, cy, rin, rout):
+    Y, X = np.ogrid[:h, :w]
+    rr = np.sqrt((X - cx)**2 + (Y - cy)**2)
+    return (rr >= rin) & (rr <= rout)
+
+def _circle_inside_bbox(cx, cy, r, bbox):
+    x0,y0,x1,y1 = bbox
+    return (cx-r) >= x0 and (cy-r) >= y0 and (cx+r) <= x1 and (cy+r) <= y1
+
+def _sat_rel(a, b):
+    # métrica auxiliar só para telemetria
+    C = np.hypot(a,b).astype(np.float32)
+    return float(np.nanmean(C)) if C.size else None
+
+def _draw_overlay(roi, cx, cy, rin, rout):
+    ov = roi.copy()
+    cv.circle(ov, (int(cx),int(cy)), int(rout), (0,255,0), 1)
+    cv.circle(ov, (int(cx),int(cy)), int(rin),  (255,0,0), 1)
+    return _to_b64(ov)
+
+# ----------------- Localização principal -----------------
+def localize_eyes(orig_rgb, faces, eyes_mask, config):
     """
-    Retorna: (metrics_dict | None, diag_dict)
-      metrics_dict: {"L","a","b","C","area"}  (mediana robusta no anel selecionado)
-      diag_dict:    { tech, gate_reason, ring_px, cx, cy, rin, rout, roi_bbox, overlay_b64,
-                      band_mode, c_mean_full, c_mean_band, l_mean_band,
-                      highlight_frac, sclera_frac, trim_top_deg, trim_bottom_deg,
-                      L_p50, C_p50, satrel_p50 }
+    Retorna:
+      (metrics_dict | None, diag_dict)
+
+    metrics_dict: {"L","a","b","C","area"}  (amostra final da íris)
+    diag_dict: {
+      "tech","gate_reason","ring_px","cx","cy","rin","rout","roi_bbox","overlay_b64",
+      "band_mode","band_width_px","highlight_frac","sclera_frac","c_mean_full","c_mean_band","l_mean_band",
+      "L_p50","C_p50","sat_rel"
+    }
     """
-    try:
-        H,W = int(orig_rgb.shape[0]), int(orig_rgb.shape[1])
-    except Exception:
-        return None, {"tech":"mp_iris","gate_reason":"bad_image"}
-
-    min_eye_area_px = int(_cfg(_cfg(config,"face_parsing",{}), "min_eye_px", 180))
-    if eyes_mask is None or int(eyes_mask.sum() or 0) < max(60, int(0.5*min_eye_area_px)):
+    # ---------- parâmetros (guardrails) ----------
+    inner_fr = config.get("iris_inner_frac_range", [0.38, 0.46])
+    outer_fr = config.get("iris_outer_frac_range", [0.68, 0.78])
+    min_band_w = int(config.get("iris_band_min_width_px", 14))
+    L_clip_top_q = float(config.get("iris_L_clip_top_q", 0.92))
+    S_sclera_max = float(config.get("iris_S_sclera_max", 0.18))
+    min_ring_px = int(config.get("iris_min_ring_px", 140))
+    c_weighted    = bool(config.get("iris_c_weighted_mean", True))
+
+    trim_cfg = config.get("iris_trim_dark_sectors", {"enabled": True,"deg_top":14,"deg_bottom":14,"L_rel_q":0.15})
+    trim_enabled     = bool(trim_cfg.get("enabled", True))
+    trim_deg_top     = float(trim_cfg.get("deg_top", 14.0))
+    trim_deg_bottom  = float(trim_cfg.get("deg_bottom", 14.0))
+    trim_L_rel_q     = float(trim_cfg.get("L_rel_q", 0.15))
+
+    mid_cfg = config.get("iris_midband_when_lowC",
+              {"enabled": True, "c_mean_threshold": 8.0, "subband_halfwidth_frac": 0.06,
+               "c_outlier_drop_q": 0.25, "l_high_clip_q": 0.85, "guard_to_inner_outer_px": 2})
+    mid_enabled = bool(mid_cfg.get("enabled", True))
+    mid_thrC    = float(mid_cfg.get("c_mean_threshold", 8.0))
+    mid_hw_frac = float(mid_cfg.get("subband_halfwidth_frac", 0.06))
+    mid_guard   = int(mid_cfg.get("guard_to_inner_outer_px", 2))
+
+    # ---------------- segurança de entrada ----------------
+    if eyes_mask is None or int(eyes_mask.sum()) < 120:
         return None, {"tech":"mp_iris","gate_reason":"no_eyes_mask"}
 
-    # ----- ROIs a partir da máscara -----
-    cnts = _pick_eye_contours(eyes_mask)
-    if not cnts:
-        return None, {"tech":"mp_iris","gate_reason":"no_eye_contours"}
-
-    # ordenar por X e inflar bbox com margem
-    cnts = sorted(cnts, key=lambda c: cv.boundingRect(c)[0])
+    # ---- Seleciona ROIs a partir da máscara de olhos ----
+    contours, _ = cv.findContours(eyes_mask.astype(np.uint8), cv.RETR_EXTERNAL, cv.CHAIN_APPROX_SIMPLE)
     rois = []
-    pad = int(0.06 * max(H,W))
-    for c in cnts:
-        x0,y0,x1,y1 = _bbox_from_contour(c)
-        x0 = max(0, x0 - pad); y0 = max(0, y0 - pad)
-        x1 = min(W, x1 + pad); y1 = min(H, y1 + pad)
-        if (x1-x0) <= 5 or (y1-y0) <= 5: 
+    H,W,_ = orig_rgb.shape
+    for cnt in contours:
+        x,y,w,h = cv.boundingRect(cnt)
+        x0 = max(0, x-6); y0 = max(0, y-6)
+        x1 = min(W, x+w+6); y1 = min(H, y+h+6)
+        if (x1-x0) < 10 or (y1-y0) < 10: 
             continue
-        roi = orig_rgb[y0:y1, x0:x1, :]
-        mask_roi = eyes_mask[y0:y1, x0:x1]
-        if roi.size and int(mask_roi.sum()) >= 20:
-            rois.append((roi, mask_roi, (x0,y0,x1,y1)))
-    if not rois:
-        return None, {"tech":"mp_iris","gate_reason":"no_eye_rois"}
-
-    # ----- FaceMesh / landmarks de íris -----
-    if mp_face is None:
-        return None, {"tech":"mp_iris","gate_reason":"mediapipe_unavailable"}
-
-    try:
-        bgr = cv.cvtColor(orig_rgb.astype(np.uint8), cv.COLOR_RGB2BGR)
-    except Exception:
-        return None, {"tech":"mp_iris","gate_reason":"bad_image_colorspace"}
-
-    try:
-        with mp_face.FaceMesh(
-            static_image_mode=True, max_num_faces=1,
-            refine_landmarks=True, min_detection_confidence=0.5
-        ) as face:
-            res = face.process(bgr)
-    except Exception as e:
-        return None, {"tech":"mp_iris","gate_reason":"facemesh_error","error":f"{type(e).__name__}"}
-
-    if not res.multi_face_landmarks:
-        return None, {"tech":"mp_iris","gate_reason":"no_facemesh"}
-
-    lmks = res.multi_face_landmarks[0].landmark
-    pts = np.array([[lmk.x*W, lmk.y*H] for lmk in lmks], dtype=np.float32)
-
-    def circle_from_indices(cand):
-        idx = np.array(cand, dtype=int)
-        if idx.max() >= pts.shape[0]:
-            return None
-        cxy = pts[idx,:]
-        return _fit_circle(cxy)
-
-    left_circ, right_circ = None, None
-    for cand in LEFT_IRIS_CANDIDATES:
-        left_circ = circle_from_indices(cand)
-        if left_circ: break
-    for cand in RIGHT_IRIS_CANDIDATES:
-        right_circ = circle_from_indices(cand)
-        if right_circ: break
-
-    # ----- Config de anel / guard-rails -----
-    inner_fr = _cfg(config, "iris_inner_frac_range", [0.38, 0.46])
-    outer_fr = _cfg(config, "iris_outer_frac_range", [0.68, 0.78])
-    min_band_w = int(_cfg(config, "iris_band_min_width_px", 12))
-    iris_S_min = float(_cfg(config, "iris_S_min", 0.20))
-    L_clip_top_q = float(_cfg(config, "iris_L_clip_top_q", 0.80))
-    sclera_frac_max = float(_cfg(config, "iris_sclera_frac_max", 0.20))
-    highlight_frac_max = float(_cfg(config, "iris_highlight_frac_max", 0.30))
-    min_ring_px = int(_cfg(config, "iris_min_ring_px", 140))
-    c_weighted = bool(_cfg(config, "iris_c_weighted_mean", True))
-
-    trim_cfg = _cfg(config, "iris_trim_dark_sectors", {"enabled": True, "deg_top": 12, "deg_bottom": 12, "L_rel_q": 0.15})
-    trim_enabled = bool(_cfg(trim_cfg, "enabled", False))
-    trim_deg_top = float(_cfg(trim_cfg, "deg_top", 12.0))
-    trim_deg_bottom = float(_cfg(trim_cfg, "deg_bottom", 12.0))
-    trim_L_rel_q = float(_cfg(trim_cfg, "L_rel_q", 0.15))
-
-    mid_cfg = _cfg(config, "iris_midband_when_lowC",
-                   {"enabled": True, "c_mean_threshold": 8.0, "subband_halfwidth_frac": 0.06,
-                    "c_outlier_drop_q": 0.25, "l_high_clip_q": 0.85, "guard_to_inner_outer_px": 2})
-    mid_enabled = bool(_cfg(mid_cfg, "enabled", True))
-    mid_thrC = float(_cfg(mid_cfg, "c_mean_threshold", 8.0))
-    mid_hw_frac = float(_cfg(mid_cfg, "subband_halfwidth_frac", 0.06))
-    mid_guard = int(_cfg(mid_cfg, "guard_to_inner_outer_px", 2))
+        roi = orig_rgb[y0:y1, x0:x1]
+        mroi = eyes_mask[y0:y1, x0:x1]
+        rois.append((roi, mroi, (x0,y0,x1,y1)))
+
+    # ---- Círculos de íris a partir de FaceMesh (se disponível) ----
+    def _fit_iris_circles(faces):
+        if faces is None or len(faces)==0:
+            return None, None
+        # coleta landmarks por olho e ajusta círculo
+        def _one_eye(landmark_ids):
+            pts = []
+            for lid in landmark_ids:
+                try:
+                    lm = faces.landmark[lid]
+                    pts.append([lm.x * W, lm.y * H])
+                except Exception:
+                    pass
+            pts = np.asarray(pts, dtype=np.float32)
+            if pts.shape[0] < 4:
+                return None
+            return _fit_circle(pts)
+        # tenta duas permutações por olho
+        left  = None
+        right = None
+        for cand in LEFT_IRIS_CANDIDATES:
+            left = _one_eye(cand)
+            if left is not None: break
+        for cand in RIGHT_IRIS_CANDIDATES:
+            right = _one_eye(cand)
+            if right is not None: break
+        return left, right
+
+    left_circ, right_circ = _fit_iris_circles(faces)
 
     candidates = []
     for (roi, mroi, bbox) in rois:
         x0,y0,x1,y1 = bbox
         for circ in (left_circ, right_circ):
-            if circ is None: 
+            if circ is None:
                 continue
             cx,cy,r = circ
             if not _circle_inside_bbox(cx,cy,r,bbox):
@@ -244,13 +171,13 @@ def localize_iris_and_sample_mediapipe(orig_rgb, eyes_mask, config=None, debug=F
             if h<=2 or w<=2:
                 continue
 
-            # Raio interno/externo (usar faixas + largura mínima)
-            rin = max(2.0, float(r)*float(inner_fr[0]))
-            rout = min(float(r)*0.98, float(r)*float(outer_fr[1]))
-            if (rout - rin) < float(min_band_w):
-                # ajusta mantendo dentro de (0, r*0.98)
+            # raios interno/externo com largura mínima e teto geométrico
+            rin  = max(2.0, float(r) * float(inner_fr[0]))
+            rout = min(float(r)*0.98, float(r) * float(outer_fr[1]))
+            # garante largura mínima
+            if (rout - rin) < (min_band_w - 0.5):
                 midr = 0.5*(rin + rout)
-                rin = max(2.0, midr - 0.5*min_band_w)
+                rin  = max(2.0, midr - 0.5*min_band_w)
                 rout = min(float(r)*0.98, midr + 0.5*min_band_w)
                 if rout <= rin + 0.5:
                     rout = rin + 0.5
@@ -262,94 +189,83 @@ def localize_iris_and_sample_mediapipe(orig_rgb, eyes_mask, config=None, debug=F
 
             # LAB/HSV
             L, a, b = _safe_rgb2lab(roi)
-            S = _hsv_S(roi)
+            S       = _hsv_S(roi)
 
-            # highlight + sclera (L alto, S baixo)
+            # ---- highlight + sclera (L alto + S baixo) ----
             L_ring = L[ring]
             if L_ring.size == 0:
                 continue
-            L_hi = np.nanquantile(L_ring, L_clip_top_q)
-            sclera = (L >= L_hi) & (S <= 0.15) & ring
+            L_hi = float(np.nanquantile(L_ring, L_clip_top_q))
+            # relaxa clip de highlight quando a massa ainda é pequena
+            if int(ring.sum()) < min_ring_px:
+                L_hi = float(np.nanquantile(L_ring, min(0.95, L_clip_top_q + 0.03)))
+
+            sclera = (L >= L_hi) & (S <= S_sclera_max) & ring
             highlight_frac = float(np.mean((L >= L_hi) & ring)) if ring.any() else 1.0
-            sclera_frac = float(np.mean(sclera)) if ring.any() else 1.0
+            sclera_frac    = float(np.mean(sclera))              if ring.any() else 1.0
 
-            keep = ring & (~sclera) & (S >= iris_S_min)
+            # mantém anel, removendo sclera e highlight — sem gate de S mínimo global
+            keep = ring & (~sclera) & (~((L >= L_hi) & ring))
             if int(keep.sum()) < 20:
                 continue
 
-            # (opcional) trim setorial por sombras de pálpebra
+            # (opcional) trim setorial (sombras de pálpebra)
             trim_top_deg = None
             trim_bot_deg = None
             if trim_enabled:
                 Y, X = np.ogrid[:h, :w]
                 ang = (np.degrees(np.arctan2((Y - cy_r), (X - cx_r))) + 360.0) % 360.0
-                # defino "topo" ~ 90°, "baixo" ~ 270°
-                top_sector = keep & (np.abs(((ang - 90.0 + 180.0) % 360.0) - 180.0) <= trim_deg_top)
+                top_sector = keep & (np.abs(((ang - 90.0  + 180.0) % 360.0) - 180.0) <= trim_deg_top)
                 bot_sector = keep & (np.abs(((ang - 270.0 + 180.0) % 360.0) - 180.0) <= trim_deg_bottom)
-
-                # remove setores se forem mais escuros que um quantil relativo
                 if top_sector.any():
                     L_top = L[top_sector]
-                    L_thr = np.nanquantile(L_ring, trim_L_rel_q)
-                    if np.nanmean(L_top) < L_thr:
-                        keep[top_sector] = False
-                        trim_top_deg = float(trim_deg_top)
+                    thrT  = np.nanquantile(L[keep], 1.0 - trim_L_rel_q)
+                    keep[top_sector & (L_top < thrT)] = False
+                    trim_top_deg = float(trim_deg_top)
                 if bot_sector.any():
                     L_bot = L[bot_sector]
-                    L_thr = np.nanquantile(L_ring, trim_L_rel_q)
-                    if np.nanmean(L_bot) < L_thr:
-                        keep[bot_sector] = False
-                        trim_bot_deg = float(trim_deg_bottom)
+                    thrB  = np.nanquantile(L[keep], 1.0 - trim_L_rel_q)
+                    keep[bot_sector & (L_bot < thrB)] = False
+                    trim_bot_deg = float(trim_deg_bottom)
 
-            if int(keep.sum()) < 20:
-                continue
+            # métricas no anel "full"
+            Lm = float(np.nanmedian(L[keep])) if keep.any() else None
+            am = float(np.nanmedian(a[keep])) if keep.any() else None
+            bm = float(np.nanmedian(b[keep])) if keep.any() else None
+            Cm = float(np.nanmedian(np.hypot(a[keep], b[keep]))) if keep.any() else None
+            c_full = np.hypot(a[keep], b[keep]).astype(np.float32) if keep.any() else np.array([],dtype=np.float32)
+            c_mean_full = float(np.nanmean(c_full)) if c_full.size else None
 
-            # Stats no anel "full"
-            Lm, am, bm, Cm, Lp50, Cp50 = _lab_p50_and_med_robust(L, a, b, keep)
-            if Lm is None:
-                continue
-            C_arr_full = np.hypot(a[keep], b[keep]).astype(np.float32)
-            c_mean_full = float(np.nanmean(C_arr_full)) if C_arr_full.size else float(Cm or 0.0)
+            # força midband para olhos claros quando houver sinais de highlight/sclera ou pouca massa
+            force_mid = (int(ring.sum()) < min_ring_px) or ((rout - rin) < (min_band_w + 0.5)) or (highlight_frac >= 0.22) or (sclera_frac >= 0.18)
 
-            # (opcional) mid-band quando C* baixo
             band_mode = "full"
             c_mean_band = c_mean_full
-            l_mean_band = float(Lm)
+            l_mean_band = float(Lm) if Lm is not None else None
 
-            if mid_enabled and c_mean_full < mid_thrC and int(keep.sum()) >= 40:
+            # ---- MIDBAND: quando necessário ou quando C* muito baixo ----
+            if force_mid or (mid_enabled and c_mean_full is not None and c_mean_full < mid_thrC and int(keep.sum()) >= 40):
                 band_mode = "midband"
-                # sub-anel em torno do raio médio
                 mid_r = 0.5*(rin + rout)
-                hw = max(1.0, float(mid_hw_frac) * float(r))
-                rin2 = max(rin + mid_guard, mid_r - hw)
+                hw    = max(1.0, float(mid_hw_frac) * float(r))
+                rin2  = max(rin + mid_guard,  mid_r - hw)
                 rout2 = min(rout - mid_guard, mid_r + hw)
                 if rout2 > rin2 + 0.5:
                     sub = _ring_mask(h,w, cx_r, cy_r, rin2, rout2) & keep
                     if int(sub.sum()) >= 20:
-                        keep_band = sub
-                        # clipes dentro do sub-anel
-                        L_sub = L[keep_band]; a_sub = a[keep_band]; b_sub = b[keep_band]
+                        L_sub = L[sub]; a_sub = a[sub]; b_sub = b[sub]
                         C_sub = np.hypot(a_sub, b_sub).astype(np.float32)
 
-                        # drop outliers de C* (parte inferior)
+                        # drop outliers de C* (parte inferior), ajuda íris com heterocromia suave
                         if C_sub.size >= 8:
-                            qdrop = int(np.floor(float(_cfg(mid_cfg,"c_outlier_drop_q",0.25))*C_sub.size))
+                            qdrop = int(np.floor(float(mid_cfg.get("c_outlier_drop_q",0.25))*C_sub.size))
                             if qdrop > 0:
                                 idx = np.argsort(C_sub)
                                 keep_idx = idx[qdrop:]
                                 L_sub = L_sub[keep_idx]; a_sub = a_sub[keep_idx]; b_sub = b_sub[keep_idx]
                                 C_sub = C_sub[keep_idx]
-                                keep_band = (np.zeros_like(keep_band, dtype=bool))
-                                # reconstruir máscara band a partir dos índices é custoso; em vez disso,
-                                # só recomputamos stats de arrays filtrados.
-                        # l_high_clip
-                        if L_sub.size >= 5:
-                            L_hi2 = np.nanquantile(L_sub, float(_cfg(mid_cfg,"l_high_clip_q",0.85)))
-                            sel2 = (L_sub <= L_hi2)
-                            L_sub = L_sub[sel2]; a_sub = a_sub[sel2]; b_sub = b_sub[sel2]; C_sub = C_sub[sel2]
 
                         if L_sub.size >= 10:
-                            # médias ponderadas por C* (se habilitado)
                             if c_weighted and C_sub.size > 0 and np.nanmean(C_sub) > 0:
                                 w = C_sub / (np.nanmean(C_sub) + 1e-6)
                                 l_mean_band = float(np.average(L_sub, weights=w))
@@ -360,69 +276,76 @@ def localize_iris_and_sample_mediapipe(orig_rgb, eyes_mask, config=None, debug=F
                                 a_mean_band = float(np.nanmean(a_sub))
                                 b_mean_band = float(np.nanmean(b_sub))
                             c_mean_band = float(np.nanmean(C_sub))
-                            # substitui stats finais (mantendo Lp50/Cp50 dos "full" para telemetria)
+                            # substitui stats finais (mantendo p50 do full para telemetria)
                             Lm, am, bm = l_mean_band, a_mean_band, b_mean_band
-                            Cm = float(np.nanmedian(C_sub)) if C_sub.size else Cm
 
-            # escore de qualidade (pouco sensível a sclera)
-            ring_px = int(keep.sum())
-            score = float(ring_px * max(0.05, 1.0 - min(1.0, sclera_frac)))
+            # estatísticas finais
+            a_mean = float(am) if am is not None else None
+            b_mean = float(bm) if bm is not None else None
+            C_mean = float(np.hypot(a_mean, b_mean)) if (a_mean is not None and b_mean is not None) else (float(Cm) if Cm is not None else None)
+            ring_px_final = int(keep.sum())
 
-            # overlay
-            overlay = _draw_overlay(roi, cx_r, cy_r, rin, rout)
+            overlay = _draw_overlay(roi, cx_r, cy_r,
+                                    rin if band_mode=="full" else (0.5*(rin + rout) - 0.5*min_band_w),
+                                    rout if band_mode=="full" else (0.5*(rin + rout) + 0.5*min_band_w))
 
-            # filtros finais de qualidade para evitar “estouro”
-            ring_area_est = np.pi*(rout*rout - rin*rin)
-            min_cut = max(20, min( min_ring_px, 0.12*ring_area_est ))
-            if ring_px < min_cut:
-                continue
-            if highlight_frac > (highlight_frac_max + 0.25):  # só aborta se MUITO fora
-                continue
-
-            # empacota candidato
             candidates.append({
                 "stats": {
-                    "L": float(Lm), "a": float(am), "b": float(bm),
-                    "C": float(np.hypot(float(am), float(bm))),
-                    "area": ring_px
-                },
-                "diag": {
-                    "tech": "mp_iris", "gate_reason": "ok",
-                    "ring_px": ring_px,
-                    "cx": float(cx), "cy": float(cy),
-                    "rin": float(rin), "rout": float(rout),
-                    "roi_bbox": [int(x0),int(y0),int(x1),int(y1)],
-                    "overlay_b64": overlay,
-                    # métricas de banda
-                    "band_mode": band_mode,
-                    "c_mean_full": float(c_mean_full),
-                    "c_mean_band": float(c_mean_band),
-                    "l_mean_band": float(l_mean_band),
-                    "highlight_frac": float(highlight_frac),
-                    "sclera_frac": float(sclera_frac),
-                    "trim_top_deg": (float(trim_deg_top) if isinstance(trim_top_deg,(int,float)) else None),
-                    "trim_bottom_deg": (float(trim_deg_bottom) if isinstance(trim_bot_deg,(int,float)) else None),
+                    "L": float(Lm) if Lm is not None else None,
+                    "a": a_mean, "b": b_mean, "C": C_mean,
+                    "area": ring_px_final,
+                    "L_p50": float(np.nanmedian(L[keep])) if keep.any() else None,
+                    "C_p50": float(np.nanmedian(np.hypot(a[keep],b[keep]))) if keep.any() else None
                 },
-                "score": float(score)
+                "score": float(ring_px_final * (1.0 - highlight_frac) * (1.0 - sclera_frac)),
+                "cx": float(cx), "cy": float(cy),
+                "rin": float(rin), "rout": float(rout),
+                "roi_bbox": [int(x0),int(y0),int(x1),int(y1)],
+                "overlay_b64": overlay,
+                "ring_px": ring_px_final,
+                "band_mode": band_mode,
+                "band_width_px": float(rout - rin),
+                "highlight_frac": float(highlight_frac),
+                "sclera_frac": float(sclera_frac),
+                "c_mean_full": (None if c_mean_full is None else float(c_mean_full)),
+                "c_mean_band": (None if c_mean_band is None else float(c_mean_band)),
+                "l_mean_band": (None if l_mean_band is None else float(l_mean_band)),
+                "tech": "mp_iris"
             })
 
     if not candidates:
-        # Nenhum anel válido
-        return None, {"tech":"mp_iris","gate_reason":"no_valid_ring"}
-
-    best = max(candidates, key=lambda d: d["score"])
-    # acrescenta p50 e satrel_p50 para telemetria
-    # (recalcula p50 a partir do ROI/keep não guardado — usa aproximação via stats)
+        return None, {
+            "tech": "mp_iris",
+            "gate_reason": "no_valid_ring",
+            "ring_px": 0, "cx": None, "cy": None,
+            "rin": None, "rout": None, "roi_bbox": None,
+            "overlay_b64": None,
+            "band_mode": None, "band_width_px": None,
+            "highlight_frac": 0.0, "sclera_frac": 0.0,
+            "c_mean_full": None, "c_mean_band": None, "l_mean_band": None
+        }
+
+    # escolhe melhor candidato pelo score
+    best = max(candidates, key=lambda c: c["score"])
     stats = best["stats"].copy()
-    diag = best["diag"].copy()
-
-    # aproximações de p50 e satrel
-    Lp50 = float(stats["L"])
-    Cp50 = float(stats["C"])
-    satrel_p50 = float(Cp50 / (Cp50 + 12.0)) if np.isfinite(Cp50) else None
-
-    diag["L_p50"] = Lp50
-    diag["C_p50"] = Cp50
-    diag["satrel_p50"] = satrel_p50
-
+    stats["sat_rel"] = _sat_rel(stats["a"], stats["b"])
+
+    diag = {
+        "tech": "mp_iris",
+        "gate_reason": None,
+        "ring_px": int(best["ring_px"]),
+        "cx": float(best["cx"]), "cy": float(best["cy"]),
+        "rin": float(best["rin"]), "rout": float(best["rout"]),
+        "roi_bbox": best["roi_bbox"],
+        "overlay_b64": best["overlay_b64"],
+        "band_mode": best["band_mode"],
+        "band_width_px": float(best["band_width_px"]),
+        "highlight_frac": float(best["highlight_frac"]),
+        "sclera_frac": float(best["sclera_frac"]),
+        "c_mean_full": best["c_mean_full"],
+        "c_mean_band": best["c_mean_band"],
+        "l_mean_band": best["l_mean_band"],
+        "L_p50": stats["L_p50"],
+        "C_p50": stats["C_p50"]
+    }
     return stats, diag