import gradio as gr
from ultralytics import YOLO
import torch
import cv2
import numpy as np
import os
import re
import math
import pandas as pd
from datetime import datetime

# ===========================================================================
# ESCALA IMPRESSA + RECORTE DA ASA  (antes em asa_lib.py, agora integrado)
# ===========================================================================
try:
    import pytesseract
    OCR_DISPONIVEL = True
except Exception:
    OCR_DISPONIVEL = False

# ===========================================================================
# 1) ESCALA
# ===========================================================================

_UNIT_MM = {"mm": 1.0, "cm": 10.0, "um": 1e-3, "µm": 1e-3, "μm": 1e-3, "nm": 1e-6}
_WL = "0123456789.,mµumcn "
# largura plausível do campo de visão (mm) — usada para desempatar leituras
# ambíguas do OCR, ex. "1 mm" lido como "1 um" (m e u confundem-se).
_LARGURA_MM_MIN, _LARGURA_MM_MAX = 0.5, 2000.0


def _valor_mm(texto):
    """(valor_mm, tem_decimal, match) ou (None, False, None)."""
    if not texto:
        return None, False, None
    t = texto.lower().replace(",", ".").replace("μ", "µ")
    m = (re.search(r"(\d+(?:\.\d+)?)\s*(mm|cm|µm|um|nm)\b", t)
         or re.search(r"(\d+(?:\.\d+)?)\s*(mm|cm|µm|um|nm)", t))
    if not m:
        return None, False, None
    num = m.group(1)
    return float(num) * _UNIT_MM.get(m.group(2), 1.0), ("." in num), m.group(0)


def _ampliar(gray, alvo_h=170):
    h = max(1, gray.shape[0])
    f = min(10.0, max(2.0, alvo_h / h))
    return cv2.resize(gray, None, fx=f, fy=f, interpolation=cv2.INTER_CUBIC)


def _ocr(im, psm):
    """(texto, confiança_média) usando image_to_data."""
    cfg = f"--psm {psm} -c tessedit_char_whitelist={_WL}"
    d = pytesseract.image_to_data(im, config=cfg, output_type=pytesseract.Output.DICT)
    palavras, confs = [], []
    for i, t in enumerate(d["text"]):
        t = t.strip()
        if not t:
            continue
        palavras.append(t)
        try:
            c = float(d["conf"][i])
        except (TypeError, ValueError):
            c = -1.0
        if c >= 0:
            confs.append(c)
    return " ".join(palavras), (float(np.mean(confs)) if confs else 1.0)


def _candidatos_valor(crop_bgr, verbose=None):
    """Recolhe leituras do rótulo -> {valor: [peso, tem_decimal]}."""
    if not OCR_DISPONIVEL or crop_bgr is None or crop_bgr.size == 0:
        return {}
    gray = cv2.cvtColor(crop_bgr, cv2.COLOR_BGR2GRAY)
    big = _ampliar(gray)
    _, otsu = cv2.threshold(big, 0, 255, cv2.THRESH_BINARY + cv2.THRESH_OTSU)
    nit = cv2.morphologyEx(otsu, cv2.MORPH_CLOSE, np.ones((2, 2), np.uint8))
    cands = {}
    for im in (otsu, big, nit):
        for psm in (7, 6, 8, 11, 13):
            try:
                raw, conf = _ocr(im, psm)
            except Exception:
                continue
            v, dec, _ = _valor_mm(raw)
            if verbose is not None and raw:
                verbose.append(f"        OCR '{raw}' (conf {conf:.0f}) -> {v}")
            if v is None:
                continue
            e = cands.setdefault(v, [0.0, False])
            e[0] += max(conf, 1.0)
            e[1] = e[1] or dec
    return cands


def _escolher_valor(cands, barra_px, largura_img):
    """Escolhe o valor mais credível: prefere leituras fisicamente plausíveis,
    depois com decimal, depois com maior peso (confiança acumulada)."""
    if not cands:
        return None, None
    def plausivel(v):
        if not barra_px or not largura_img:
            return True
        larg_mm = largura_img * (v / barra_px)
        return _LARGURA_MM_MIN <= larg_mm <= _LARGURA_MM_MAX
    itens = [(v, p, d, plausivel(v)) for v, (p, d) in cands.items()]
    ok = [i for i in itens if i[3]] or itens
    ok.sort(key=lambda i: (i[2], i[1]), reverse=True)   # decimal, depois peso
    escolhido = ok[0][0]
    nota = "plausível" if ok[0][3] else "sem candidato plausível"
    if len(itens) > 1:
        nota += f" (de {len(itens)} leituras: {sorted(v for v, _, _, _ in itens)})"
    return escolhido, nota


def _candidatos_barra(img_bgr):
    h, w = img_bgr.shape[:2]
    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
    _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    num, _, stats, _ = cv2.connectedComponentsWithStats(bw, connectivity=8)
    cands = []
    for i in range(1, num):
        x, y, ww, hh, area = stats[i]
        if hh == 0 or ww < 25 or ww > 0.6 * w or (ww / hh) < 5:
            continue
        m = 8
        viz = gray[max(0, y - hh - m):min(h, y + 2 * hh + m),
                   max(0, x - m):min(w, x + ww + m)]
        if viz.size == 0 or np.mean(viz) < 180:
            continue
        cands.append((int(x), int(y), int(ww), int(hh)))
    cands.sort(key=lambda b: (b[0] + b[2]) + b[1], reverse=True)
    return cands


def _rotulo_da_barra(img_bgr, bar, verbose=None):
    x, y, ww, hh = bar
    H, W = img_bgr.shape[:2]
    banda = int(max(45, 0.6 * ww))
    px = int(0.3 * ww)
    x1, x2 = max(0, x - px), min(W, x + ww + px)
    todos = {}
    for onde, yy1, yy2 in (("acima", max(0, y - banda), y),
                           ("abaixo", y + hh, min(H, y + hh + banda))):
        if yy2 - yy1 < 6:
            continue
        if verbose is not None:
            verbose.append(f"      rótulo {onde} da barra @({x},{y},{ww},{hh}):")
        c = _candidatos_valor(img_bgr[yy1:yy2, x1:x2], verbose)
        for v, (p, d) in c.items():
            e = todos.setdefault(v, [0.0, False])
            e[0] += p
            e[1] = e[1] or d
        if todos:
            break
    return todos


def _bar_bbox_em_roi(img_bgr, x1, y1, x2, y2):
    roi = img_bgr[y1:y2, x1:x2]
    if roi.size == 0:
        return None
    gray = cv2.cvtColor(roi, cv2.COLOR_BGR2GRAY)
    _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    num, _, stats, _ = cv2.connectedComponentsWithStats(bw, connectivity=8)
    best = (0, None)
    for i in range(1, num):
        bx, by, bwd, bht, _ = stats[i]
        if bht and (bwd / bht) >= 4 and bwd >= 0.15 * roi.shape[1] and bwd > best[0]:
            best = (bwd, (x1 + bx, y1 + by, bwd, bht))
    return best[1]


def _medir_barra_precisa(img_bgr, bbox, pad=3):
    """Distância CENTRO-A-CENTRO das serifas (remove o viés da espessura das
    marcas); se não houver serifas nítidas, largura da bounding box.
    -> (comprimento_px, metodo, largura_bbox_px, centros)"""
    x, y, w, h = bbox
    H, W = img_bgr.shape[:2]
    x1, y1 = max(0, x - pad), max(0, y - pad)
    x2, y2 = min(W, x + w + pad), min(H, y + h + pad)
    gray = cv2.cvtColor(img_bgr[y1:y2, x1:x2], cv2.COLOR_BGR2GRAY)
    _, bw = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY_INV + cv2.THRESH_OTSU)
    num, lab, stats, _ = cv2.connectedComponentsWithStats(bw, connectivity=8)
    if num <= 1:
        return float(w), "bounding-box", float(w), None
    idx = 1 + int(np.argmax(stats[1:, cv2.CC_STAT_AREA]))
    mask = (lab == idx).astype(np.uint8)
    cols = np.where(mask.any(axis=0))[0]
    if cols.size == 0:
        return float(w), "bounding-box", float(w), None
    largura_bbox = float(cols.max() - cols.min() + 1)
    alt = mask.sum(axis=0)[cols]
    linha_th, max_h = float(np.median(alt)), float(alt.max())
    if max_h < 2 * max(linha_th, 1) or (max_h - linha_th) < 2:
        return largura_bbox, "bounding-box", largura_bbox, None
    altas = cols[alt >= linha_th + 0.5 * (max_h - linha_th)]
    if altas.size < 2:
        return largura_bbox, "bounding-box", largura_bbox, None
    g = int(np.argmax(np.diff(altas)))
    esq, dire = altas[:g + 1], altas[g + 1:]
    if esq.size == 0 or dire.size == 0 or (dire.min() - esq.max()) < 0.3 * largura_bbox:
        return largura_bbox, "bounding-box", largura_bbox, None
    cxe, cxd = float(esq.mean()), float(dire.mean())
    return (cxd - cxe), "centro-a-centro", largura_bbox, \
           (int(x1 + cxe), int(x1 + cxd), int((y1 + y2) // 2))


def detectar_escala(img_bgr, debug=False, verbose=None):
    """mm por pixel a partir da escala impressa (ou None)."""
    H, W = img_bgr.shape[:2]
    cands, bar_bbox, origem = {}, None, None

    if OCR_DISPONIVEL:
        try:
            for bar in _candidatos_barra(img_bgr):       # 1) barra-primeiro
                if verbose is not None:
                    verbose.append(f"    candidato barra @{bar}")
                c = _rotulo_da_barra(img_bgr, bar, verbose)
                if c:
                    cands, bar_bbox, origem = c, bar, "barra-primeiro"
                    break
            if not cands:                                 # 2) ROI fundo-direita
                roi = img_bgr[int(H * 0.80):, int(W * 0.55):]
                c = _candidatos_valor(roi, verbose)
                if c:
                    cands, origem = c, "roi-fundo"
        except Exception:
            pass

    if bar_bbox is None:
        bar_bbox = _bar_bbox_em_roi(img_bgr, int(W * 0.55), int(H * 0.80), W, H)

    barra_px = metodo = barra_bbox_px = centros = None
    if bar_bbox is not None:
        barra_px, metodo, barra_bbox_px, centros = _medir_barra_precisa(img_bgr, bar_bbox)

    valor_mm, nota = _escolher_valor(cands, barra_px, W)
    mm_por_pixel = (valor_mm / barra_px
                    if (valor_mm and barra_px and barra_px > 0) else None)
    if debug:
        return mm_por_pixel, {"valor_mm": valor_mm, "nota": nota, "barra_px": barra_px,
                              "barra_bbox_px": barra_bbox_px, "metodo_barra": metodo,
                              "mm_por_pixel": mm_por_pixel, "bar_bbox": bar_bbox,
                              "serif_centros": centros, "origem": origem}
    return mm_por_pixel


# ===========================================================================
# 2) RECORTE DA ASA (grande plano)
# ===========================================================================

def _superficie_fundo(sub, fg, passo=4):
    """Superfície quadrática ajustada ao fundo (corrige iluminação irregular)."""
    H, W = sub.shape
    ys, xs = np.nonzero(~fg[::passo, ::passo])
    if ys.size < 200:
        return np.full_like(sub, float(np.percentile(sub, 80)))
    ys, xs = ys * passo, xs * passo
    z = sub[ys, xs].astype(np.float64)
    xn, yn = xs / max(W - 1, 1), ys / max(H - 1, 1)
    A = np.stack([np.ones_like(xn), xn, yn, xn * xn, yn * yn, xn * yn], axis=1)
    coef, *_ = np.linalg.lstsq(A, z, rcond=None)
    gy, gx = np.mgrid[0:H, 0:W]
    gxn, gyn = gx / max(W - 1, 1), gy / max(H - 1, 1)
    return (coef[0] + coef[1] * gxn + coef[2] * gyn + coef[3] * gxn * gxn +
            coef[4] * gyn * gyn + coef[5] * gxn * gyn).astype(np.float32)


def _mascara_especime(img_bgr, delta=None):
    gray = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY)
    sub = cv2.GaussianBlur(gray, (0, 0), 2.0).astype(np.float32)
    nivel = float(np.percentile(sub, 80))
    fg = (nivel - sub) > max(3.0, 0.02 * nivel)
    for _ in range(2):
        fundo = _superficie_fundo(sub, fg)
        res = fundo - sub
        bg = res[~fg]
        if bg.size:
            mad = float(np.median(np.abs(bg - np.median(bg))))
            d = delta if delta is not None else max(3.0, 5.0 * mad)
        else:
            d = delta if delta is not None else 3.0
        fg = res > d
    m = fg.astype(np.uint8)
    k = max(3, (int(0.004 * max(img_bgr.shape[:2])) | 1))
    m = cv2.morphologyEx(m, cv2.MORPH_CLOSE, np.ones((k, k), np.uint8))
    m = cv2.morphologyEx(m, cv2.MORPH_OPEN, np.ones((3, 3), np.uint8))
    return m


def recortar_asa(img_bgr, margem=0.06, limpar_fundo=True, dilatar=0.02):
    """Recorta a asa em grande plano e uniformiza o fundo à volta.

    Normaliza a entrada do modelo: a asa passa a ocupar sempre a mesma fração do
    enquadramento e artefactos (pó, 2ª asa, brilho do fundo) desaparecem — o que
    evita que a segmentação varie alguns pixels entre fotos da mesma asa.

    Devolve (crop_bgr, (x0, y0), info). Em caso de falha devolve a imagem
    original e (0, 0), para o pipeline continuar a funcionar.
    """
    H, W = img_bgr.shape[:2]
    info = {"ok": False, "bbox": None, "crop_box": None, "area_frac": None, "motivo": None}

    mask = _mascara_especime(img_bgr)
    cnts, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if not cnts:
        info["motivo"] = "sem contorno"
        return img_bgr, (0, 0), info

    cnt = max(cnts, key=cv2.contourArea)
    cheia = np.zeros_like(mask)
    cv2.drawContours(cheia, [cnt], -1, 1, thickness=-1)      # preenche a asa toda

    x, y, w, h = cv2.boundingRect(cnt)
    area_frac = float(cheia.sum()) / (H * W)
    if w < 0.15 * W or h < 0.10 * H or area_frac < 0.02:
        info["motivo"] = f"objeto pequeno demais (w={w}, h={h}, área={area_frac:.3f})"
        return img_bgr, (0, 0), info

    img = img_bgr
    if limpar_fundo:
        d = max(3, int(dilatar * max(w, h)) | 1)
        sup = cv2.dilate(cheia, np.ones((d, d), np.uint8))
        val = int(round(float(np.percentile(cv2.cvtColor(img_bgr, cv2.COLOR_BGR2GRAY), 80))))
        img = img_bgr.copy()
        img[sup == 0] = val

    m = int(margem * max(w, h))
    x0, y0 = max(0, x - m), max(0, y - m)
    x1, y1 = min(W, x + w + m), min(H, y + h + m)
    info.update(ok=True, bbox=(int(x), int(y), int(w), int(h)),
                crop_box=(int(x0), int(y0), int(x1), int(y1)), area_frac=area_frac)
    return img[y0:y1, x0:x1], (x0, y0), info

# Caminho para o modelo treinado
modelo_path = "runs/segment/meu_yolo_seg20/weights/best.pt"

model_cache = {}

def carregar_modelo(device):
    if device not in model_cache:
        model = YOLO(modelo_path)
        model.to(device)
        model_cache[device] = model
    return model_cache[device]

def contar_pixels_conexos(mask, minimo):
    bin_mask = (mask > 0).astype(np.uint8)
    num_labels, labels, stats, _ = cv2.connectedComponentsWithStats(bin_mask)
    return sum(stat[cv2.CC_STAT_AREA] for stat in stats[1:] if stat[cv2.CC_STAT_AREA] >= minimo)

def calcular_distancia(p1, p2):
    return math.sqrt((p1[0] - p2[0])**2 + (p1[1] - p2[1])**2)


def mascaras_da_predicao(r, cw, ch, metodo="auto"):
    """Máscaras binárias nas coordenadas da imagem dada ao modelo (cw x ch).

    metodo="auto"   -> usa `masks.xy` (polígonos já em coordenadas da imagem de
                       entrada). Evita o erro do letterbox: `masks.data` vem no
                       tamanho interno do YOLO, com barras de padding, e
                       redimensioná-lo desloca as máscaras de forma que depende
                       do rácio de aspeto (logo, varia de foto para foto).
    metodo="legado" -> comportamento original (redimensiona `masks.data`).
    """
    if r.masks is None:
        return []
    saida = []

    if metodo != "legado":
        xy = getattr(r.masks, "xy", None)
        if xy is not None and len(xy):
            for poly in xy:
                if poly is None or len(poly) < 3:
                    continue
                m = np.zeros((ch, cw), np.uint8)
                cv2.fillPoly(m, [np.asarray(poly, dtype=np.int32)], 1)
                if m.any():
                    saida.append(m)
            if saida:
                return saida

    dados = getattr(r.masks, "data", None)
    if dados is None:
        return []
    for mask in dados:
        m = mask.cpu().numpy().astype(np.float32) if hasattr(mask, "cpu") else np.asarray(mask, np.float32)
        m = cv2.resize(m, (cw, ch), interpolation=cv2.INTER_LINEAR)
        saida.append((m > 0.5).astype(np.uint8))
    return saida


def processar_uma_imagem(imagem_path, dispositivo, conf_min, pixels_minimos,
                         usar_recorte=True, limpar_fundo=False, metodo_mascara="auto"):
    device = "cuda" if dispositivo == "GPU" and torch.cuda.is_available() else "cpu"
    model = carregar_modelo(device)

    img_bgr = cv2.imread(imagem_path)
    if img_bgr is None:
        return None, None, None, None, "erro ao ler", "-"

    # --- escala: SEMPRE na imagem completa (a barra fica fora do recorte) ---
    mm_por_pixel, escala_info = detectar_escala(img_bgr, debug=True)

    # --- recorte da asa em grande plano (normaliza a entrada do modelo) ---
    if usar_recorte:
        entrada, (off_x, off_y), rec_info = recortar_asa(img_bgr, limpar_fundo=limpar_fundo)
    else:
        entrada, (off_x, off_y), rec_info = img_bgr, (0, 0), {"ok": False, "motivo": "desligado"}

    results = model.predict(source=entrada, device=device, conf=conf_min, verbose=False)
    r = results[0]

    img_rgb = cv2.cvtColor(img_bgr, cv2.COLOR_BGR2RGB)
    ch, cw = entrada.shape[:2]

    # --- máscaras (em coordenadas do recorte) ---
    mascaras_binarias = []
    for m in mascaras_da_predicao(r, cw, ch, metodo_mascara):
        if contar_pixels_conexos(m * 255, pixels_minimos) > 0:
            mascaras_binarias.append(m)

    mascaras_fundidas = []
    for m in mascaras_binarias:
        fundida = False
        for i in range(len(mascaras_fundidas)):
            if np.count_nonzero(cv2.bitwise_and(m, mascaras_fundidas[i])) > 0:
                mascaras_fundidas[i] = cv2.bitwise_or(mascaras_fundidas[i], m)
                fundida = True
                break
        if not fundida:
            mascaras_fundidas.append(m)

    # --- centróides em float, convertidos para coordenadas da imagem original ---
    centroides = []
    for m in mascaras_fundidas:
        M = cv2.moments(m)
        if M["m00"] != 0:
            cx = M["m10"] / M["m00"] + off_x      # float: não arredondar aqui
            cy = M["m01"] / M["m00"] + off_y
            centroides.append((cx, cy))
            cv2.circle(img_rgb, (int(round(cx)), int(round(cy))), 12, (0, 255, 0), 2)

    distancia_px = None
    distancia_mm = None
    if len(centroides) == 2:
        p1 = (int(round(centroides[0][0])), int(round(centroides[0][1])))
        p2 = (int(round(centroides[1][0])), int(round(centroides[1][1])))
        cv2.line(img_rgb, p1, p2, (0, 0, 255), 2)
        for p in (p1, p2):
            cv2.circle(img_rgb, p, 6, (0, 0, 255), -1)
        distancia_px = calcular_distancia(centroides[0], centroides[1])   # float
        if mm_por_pixel:
            distancia_mm = distancia_px * mm_por_pixel

    # --- textos informativos ---
    if escala_info["valor_mm"] and escala_info["barra_px"]:
        met = "c2c" if escala_info["metodo_barra"] == "centro-a-centro" else "bbox"
        escala_str = f"{escala_info['valor_mm']:g} mm / {escala_info['barra_px']:.0f} px ({met})"
    else:
        escala_str = "não detetada"

    if rec_info.get("ok"):
        bx, by, bw, bh = rec_info["bbox"]
        recorte_str = f"{bw}x{bh} px"
    else:
        recorte_str = f"sem recorte ({rec_info.get('motivo', '-')})"

    nome = os.path.basename(imagem_path)
    output_path = os.path.splitext(nome)[0] + "_out.png"
    cv2.imwrite(output_path, cv2.cvtColor(img_rgb, cv2.COLOR_RGB2BGR))

    return output_path, nome, distancia_px, distancia_mm, escala_str, recorte_str


def processar_varias(imagens, dispositivo, conf_min, pixels_minimos,
                     usar_recorte=True, limpar_fundo=False, metodo_mascara="auto"):
    # sem imagens (ex.: alternar a opção antes de carregar ficheiros)
    if not imagens:
        vazio = pd.DataFrame({"Imagem": [], "Escala (real)": [], "Asa recortada": [],
                              "Distância (px)": [], "Distância (mm)": []})
        return [], vazio, pd.DataFrame({"Métrica": [], "Valor (mm)": []}), None

    imagens_resultado = []
    nomes, pxs, mms, escalas, recortes = [], [], [], [], []

    for imagem in imagens:
        out_path, nome, dist_px, dist_mm, escala_str, recorte_str = processar_uma_imagem(
            imagem, dispositivo, conf_min, pixels_minimos, usar_recorte,
            limpar_fundo, metodo_mascara)
        imagens_resultado.append(out_path)
        nomes.append(nome)
        pxs.append(f"{dist_px:.1f}" if dist_px else "-")
        mms.append(f"{dist_mm:.3f}" if dist_mm else "-")
        escalas.append(escala_str)
        recortes.append(recorte_str)

    valores_mm = [float(x) for x in mms if x != "-"]
    media = np.mean(valores_mm) if valores_mm else 0
    desvio = np.std(valores_mm) if valores_mm else 0

    tabela = pd.DataFrame({
        "Imagem": nomes,
        "Escala (real)": escalas,
        "Asa recortada": recortes,
        "Distância (px)": pxs,
        "Distância (mm)": mms,
    })
    resumo_df = pd.DataFrame({"Métrica": ["Média", "Desvio padrão"],
                              "Valor (mm)": [f"{media:.3f}", f"{desvio:.3f}"]})

    agora = datetime.now().strftime("%Y-%m-%d_%H-%M-%S")
    resultados_xlsx_path = f"resultados_medidas_{agora}.xlsx"
    with pd.ExcelWriter(resultados_xlsx_path) as writer:
        tabela.to_excel(writer, sheet_name="Resultados", index=False)
        resumo_df.to_excel(writer, sheet_name="Resumo", index=False)

    pasta_saida = f"imagens_processadas_{agora}"
    os.makedirs(pasta_saida, exist_ok=True)
    for img_path in imagens_resultado:
        os.replace(img_path, os.path.join(pasta_saida, os.path.basename(img_path)))
    imagens_resultado = [os.path.join(pasta_saida, os.path.basename(p)) for p in imagens_resultado]
    legendas = [f"{n} - {m} mm" for n, m in zip(nomes, mms)]

    return list(zip(imagens_resultado, legendas)), tabela, resumo_df, resultados_xlsx_path


# Interface Gradio
with gr.Blocks(title="Medição de asas múltiplas") as demo:
    gr.Markdown("## Medição automática de asas de abelha com normalização à escala impressa")

    imagens_input = gr.File(label="Subir imagens", file_types=[".png", ".jpg", ".jpeg"], file_count="multiple")

    dispositivo = gr.Radio(["CPU", "GPU"], label="Dispositivo", value="CPU", visible=False)
    conf_slider = gr.Slider(0.01, 1.0, value=0.1, step=0.01, label="Confiança mínima", visible=False)
    pixel_slider = gr.Slider(1, 1000, value=10, step=1, label="Pixels conectados mínimos por máscara", visible=False)

    imagens_saida = gr.Gallery(label="Resultados das imagens segmentadas", columns=4, preview=True, show_label=True)
    tabela_resultados = gr.Dataframe(label="Resultados", interactive=False,
                                     headers=["Imagem", "Escala (real)", "Asa recortada",
                                              "Distância (px)", "Distância (mm)"])
    tabela_resumo = gr.Dataframe(label="Resumo estatístico", interactive=False, headers=["Métrica", "Valor (mm)"])
    download_btn = gr.File(label="Download XLSX")

    imagens_input.change(
        # fixo: máscaras em "auto" (masks.xy), recorte da asa ligado,
        # sem uniformizar o fundo (isso descaracteriza a imagem e o modelo falha)
        fn=lambda imagens: processar_varias(imagens, "CPU", 0.1, 10,
                                            usar_recorte=True,
                                            limpar_fundo=False,
                                            metodo_mascara="auto"),
        inputs=imagens_input,
        outputs=[imagens_saida, tabela_resultados, tabela_resumo, download_btn]
    )

if __name__ == "__main__":
    demo.launch(share=False)