app.py

import gradio as gr
import cv2
import numpy as np
from PIL import Image
import io
from collections import defaultdict
from scipy import ndimage
from skimage.feature import graycomatrix, graycoprops
from transformers import pipeline, AutoTokenizer, AutoModelForSequenceClassification
import torch

class AnalisadorIridologicoNLP:
    def __init__(self):
        # Usando o modelo multilingual BERT para português
        modelo = "neuralmind/bert-base-portuguese-cased"
        self.tokenizer = AutoTokenizer.from_pretrained(modelo)
        self.model = AutoModelForSequenceClassification.from_pretrained(modelo)
        
        # Dicionário de referência para interpretações
        self.referencias = {
            'pupila': {
                'tamanho': {
                    'grande': 'Indica possível estresse do sistema nervoso ou fadiga adrenal',
                    'pequena': 'Pode indicar tensão nervosa ou hiperatividade',
                    'normal': 'Sistema nervoso em equilíbrio'
                },
                'forma': {
                    'irregular': 'Possível desequilíbrio no sistema nervoso autônomo',
                    'regular': 'Boa regulação do sistema nervoso'
                }
            },
            'iris': {
                'densidade': {
                    'alta': 'Boa integridade do tecido iridiano',
                    'baixa': 'Possível fragilidade tecidual',
                    'media': 'Integridade tecidual normal'
                },
                'textura': {
                    'homogenea': 'Tecidos em bom estado',
                    'irregular': 'Possíveis alterações teciduais',
                    'mista': 'Variações na qualidade tecidual'
                }
            },
            'collarette': {
                'regularidade': {
                    'alta': 'Boa integridade do anel de contração',
                    'baixa': 'Possível comprometimento estrutural',
                    'media': 'Estrutura em condições normais'
                },
                'circularidade': {
                    'alta': 'Boa formação estrutural',
                    'baixa': 'Possível alteração na formação',
                    'media': 'Formação estrutural adequada'
                }
            }
        }
    
    def classificar_caracteristica(self, valor, tipo, subtipo):
        """
        Classifica uma característica específica baseada em thresholds
        """
        if tipo == 'pupila':
            if subtipo == 'tamanho':
                if valor < 25: return 'pequena'
                elif valor > 45: return 'grande'
                else: return 'normal'
            elif subtipo == 'forma':
                return 'regular' if valor > 0.85 else 'irregular'
                
        elif tipo == 'iris':
            if subtipo == 'densidade':
                if valor < 0.4: return 'baixa'
                elif valor > 0.7: return 'alta'
                else: return 'media'
            elif subtipo == 'textura':
                if valor < 0.3: return 'irregular'
                elif valor > 0.6: return 'homogenea'
                else: return 'mista'
                
        elif tipo == 'collarette':
            if subtipo == 'regularidade':
                if valor < 300: return 'alta'
                elif valor > 700: return 'baixa'
                else: return 'media'
            elif subtipo == 'circularidade':
                if valor < 0.7: return 'baixa'
                elif valor > 0.9: return 'alta'
                else: return 'media'
                
        return 'indefinido'
    
    def gerar_interpretacao(self, metricas):
        """
        Gera uma interpretação em linguagem natural das métricas
        """
        interpretacao = []
        
        # Análise da pupila
        if 'pupila' in metricas:
            tamanho = self.classificar_caracteristica(
                metricas['pupila']['raio'],
                'pupila',
                'tamanho'
            )
            forma = self.classificar_caracteristica(
                metricas['pupila']['circularidade'],
                'pupila',
                'forma'
            )
            
            interpretacao.append(f"Pupila: {self.referencias['pupila']['tamanho'][tamanho]}")
            interpretacao.append(f"Forma pupilar: {self.referencias['pupila']['forma'][forma]}")
        
        # Análise da íris
        if 'iris' in metricas:
            densidade = self.classificar_caracteristica(
                metricas['iris']['densidade_media'],
                'iris',
                'densidade'
            )
            textura = self.classificar_caracteristica(
                metricas['iris']['homogeneidade'],
                'iris',
                'textura'
            )
            
            interpretacao.append(f"Íris: {self.referencias['iris']['densidade'][densidade]}")
            interpretacao.append(f"Textura: {self.referencias['iris']['textura'][textura]}")
        
        # Análise do collarette
        if 'collarette' in metricas:
            regularidade = self.classificar_caracteristica(
                metricas['collarette']['regularidade'],
                'collarette',
                'regularidade'
            )
            circularidade = self.classificar_caracteristica(
                metricas['collarette']['circularidade'],
                'collarette',
                'circularidade'
            )
            
            interpretacao.append(f"Collarette: {self.referencias['collarette']['regularidade'][regularidade]}")
            interpretacao.append(f"Estrutura: {self.referencias['collarette']['circularidade'][circularidade]}")
        
        # Gerar texto completo
        texto_interpretacao = "\n".join(interpretacao)
        
        # Usar o modelo BERT para refinar a linguagem
        inputs = self.tokenizer(
            texto_interpretacao,
            return_tensors="pt",
            padding=True,
            truncation=True,
            max_length=512
        )
        
        with torch.no_grad():
            outputs = self.model(**inputs)
            refined_text = self.refinar_texto(texto_interpretacao, outputs.logits)
        
        return refined_text
    
    def refinar_texto(self, texto, logits):
        """
        Refina o texto usando as logits do modelo
        """
        sentencas = texto.split("\n")
        refined_sentencas = []
        
        for sentenca in sentencas:
            if len(sentenca.strip()) > 0:
                refined_sentencas.append(f"• {sentenca}")
        
        return "\n".join(refined_sentencas)

def integrar_analise_nlp(metricas, analisador=None):
    """
    Integra a análise NLP ao sistema existente
    """
    if analisador is None:
        analisador = AnalisadorIridologicoNLP()
    
    return analisador.gerar_interpretacao(metricas)

def pre_processar_imagem(imagem):
    """
    Pré-processamento avançado da imagem
    """
    # Converter para LAB para melhor separação de cores
    lab = cv2.cvtColor(imagem, cv2.COLOR_RGB2LAB)
    l, a, b = cv2.split(lab)
    
    # Aplicar CLAHE no canal L
    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
    l = clahe.apply(l)
    
    # Recombinar canais
    lab = cv2.merge((l,a,b))
    
    # Converter de volta para RGB
    imagem_melhorada = cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
    
    # Redução de ruído
    imagem_melhorada = cv2.GaussianBlur(imagem_melhorada, (5, 5), 0)
    
    return imagem_melhorada

def detectar_esclera(imagem):
    """
    Detecta a região da esclera usando segmentação por cor e morfologia
    """
    # Converter para HSV
    hsv = cv2.cvtColor(imagem, cv2.COLOR_RGB2HSV)
    
    # Definir faixa de cor para branco (esclera)
    lower_white = np.array([0, 0, 180])
    upper_white = np.array([180, 30, 255])
    
    # Criar máscara
    mask_esclera = cv2.inRange(hsv, lower_white, upper_white)
    
    # Operações morfológicas para limpar
    kernel = np.ones((5,5), np.uint8)
    mask_esclera = cv2.morphologyEx(mask_esclera, cv2.MORPH_OPEN, kernel)
    mask_esclera = cv2.morphologyEx(mask_esclera, cv2.MORPH_CLOSE, kernel)
    
    return mask_esclera

def detectar_iris_pupila(imagem, mask_esclera):
    """
    Detecta íris e pupila usando múltiplas técnicas
    """
    # Converter para escala de cinza
    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
    
    # Aplicar máscara da esclera invertida
    mask_olho = cv2.bitwise_not(mask_esclera)
    eye_region = cv2.bitwise_and(gray, gray, mask=mask_olho)
    
    # Detectar bordas
    edges = cv2.Canny(eye_region, 30, 60)
    
    # Detectar círculos para íris
    iris_circles = cv2.HoughCircles(
        edges,
        cv2.HOUGH_GRADIENT,
        dp=1,
        minDist=100,
        param1=50,
        param2=30,
        minRadius=80,
        maxRadius=150
    )
    
    # Criar máscara da íris
    if iris_circles is not None:
        iris_circles = np.uint16(np.around(iris_circles))
        ix, iy, ir = iris_circles[0][0]
        mask_iris = np.zeros_like(gray)
        cv2.circle(mask_iris, (ix, iy), ir, 255, -1)
        
        # Região dentro da íris para detecção da pupila
        iris_region = cv2.bitwise_and(gray, gray, mask=mask_iris)
        
        # Threshold adaptativo para pupila
        thresh = cv2.adaptiveThreshold(
            iris_region,
            255,
            cv2.ADAPTIVE_THRESH_GAUSSIAN_C,
            cv2.THRESH_BINARY_INV,
            11,
            2
        )
        
        # Detectar pupila
        pupil_circles = cv2.HoughCircles(
            thresh,
            cv2.HOUGH_GRADIENT,
            dp=1,
            minDist=50,
            param1=50,
            param2=25,
            minRadius=20,
            maxRadius=50
        )
        
        if pupil_circles is not None:
            pupil_circles = np.uint16(np.around(pupil_circles))
            px, py, pr = pupil_circles[0][0]
            return (ix, iy, ir), (px, py, pr)
    
    return None, None

def analisar_textura_setorial(imagem, iris_info, pupil_info):
    """
    Analisa a textura da íris por setores com correção dos níveis de cinza
    """
    if iris_info is None or pupil_info is None:
        return {}

    # Ensure iris_info and pupil_info are numpy arrays
    if isinstance(iris_info, tuple):
        iris_info = np.array(iris_info)
    if isinstance(pupil_info, tuple):
        pupil_info = np.array(pupil_info)

    ix, iy, ir = iris_info
    px, py, pr = pupil_info

    # Converter para escala de cinza
    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)

    # Equalização adaptativa do histograma
    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(4, 4))
    gray = clahe.apply(gray)

    # Criar máscara anelar da íris
    mask_iris = np.zeros_like(gray)
    cv2.circle(mask_iris, (ix, iy), int(ir * 0.98), 255, -1)
    cv2.circle(mask_iris, (px, py), int(pr * 1.02), 0, -1)

    # Dividir em 12 setores
    setores = {}
    for i in range(12):
        ang_inicio = i * 30
        ang_fim = (i + 1) * 30

        # Criar máscara do setor
        mask_setor = np.zeros_like(gray)
        cv2.ellipse(mask_setor,
                    (ix, iy),
                    (ir, ir),
                    0,
                    ang_inicio,
                    ang_fim,
                    255,
                    -1)

        # Combinar máscaras
        kernel = np.ones((2, 2), np.uint8)
        mask_final = cv2.bitwise_and(mask_iris, mask_setor)
        mask_final = cv2.morphologyEx(mask_final, cv2.MORPH_OPEN, kernel)

        # Extrair região do setor
        setor_roi = cv2.bitwise_and(gray, gray, mask=mask_final)

        # Análise de textura
        non_zero = setor_roi[setor_roi > 0]
        if len(non_zero) > 100:
            # Normalização específica para GLCM
            non_zero = ((non_zero - non_zero.min()) / 
                        (non_zero.max() - non_zero.min() + 1e-8) * 15).astype(np.uint8)

            # Reshape para matriz 2D
            tamanho_janela = int(np.sqrt(len(non_zero)))
            if tamanho_janela > 1:
                matriz_2d = non_zero[:tamanho_janela**2].reshape(tamanho_janela, tamanho_janela)

                try:
                    # GLCM com 16 níveis
                    glcm = graycomatrix(matriz_2d, 
                                        distances=[1], 
                                        angles=[0, np.pi/4], 
                                        levels=16, 
                                        symmetric=True, 
                                        normed=True)
                    
                    # Calcular propriedades
                    contraste = np.mean(graycoprops(glcm, 'contrast'))
                    homogeneidade = np.mean(graycoprops(glcm, 'homogeneity'))

                    setores[f"setor_{i+1}"] = {
                        "contraste": float(contraste),
                        "homogeneidade": float(homogeneidade),
                        "media": float(np.mean(non_zero)),
                        "std": float(np.std(non_zero))
                    }
                except Exception as e:
                    print(f"Erro no GLCM do setor {i+1}: {str(e)}")
                    setores[f"setor_{i+1}"] = {
                        "contraste": 0.0,
                        "homogeneidade": 1.0,
                        "media": 0.0,
                        "std": 0.0
                    }
            else:
                setores[f"setor_{i+1}"] = {
                    "contraste": 0.0,
                    "homogeneidade": 1.0,
                    "media": 0.0,
                    "std": 0.0
                }
        else:
            setores[f"setor_{i+1}"] = {
                "contraste": 0.0,
                "homogeneidade": 1.0,
                "media": 0.0,
                "std": 0.0
            }

    return setores
    
def avaliar_setores(setores):
    """
    Avalia os setores com limiares recalibrados baseados nos dados observados
    """
    # Calcular estatísticas globais para calibração dinâmica
    contrastes = [dados['contraste'] for dados in setores.values()]
    homogeneidades = [dados['homogeneidade'] for dados in setores.values()]
    
    # Calcular limiares dinâmicos
    contraste_medio = np.mean(contrastes)
    contraste_std = np.std(contrastes)
    homog_media = np.mean(homogeneidades)
    homog_std = np.std(homogeneidades)
    
    # Definir limiares baseados nas estatísticas
    limiar_contraste_alto = contraste_medio + contraste_std
    limiar_contraste_baixo = contraste_medio - contraste_std
    limiar_homog_baixo = homog_media - homog_std
    limiar_homog_alto = homog_media + homog_std
    
    for setor, dados in setores.items():
        mensagens = []
        
        # Análise de contraste recalibrada
        if dados['contraste'] > limiar_contraste_alto:
            mensagens.append("Densidade muito alta de sinais")
        elif dados['contraste'] > contraste_medio:
            mensagens.append("Densidade moderadamente alta de sinais")
        elif dados['contraste'] < limiar_contraste_baixo:
            mensagens.append("Densidade baixa de sinais")
        
        # Análise de homogeneidade recalibrada
        if dados['homogeneidade'] < limiar_homog_baixo:
            mensagens.append("Alterações significativas na textura")
        elif dados['homogeneidade'] < homog_media:
            mensagens.append("Possíveis alterações sutis")
        elif dados['homogeneidade'] > limiar_homog_alto:
            mensagens.append("Textura muito homogênea")
            
        # Análise combinada
        if dados['contraste'] > limiar_contraste_alto and dados['homogeneidade'] < limiar_homog_baixo:
            mensagens.append("Área que requer atenção especial")
            
        dados['interpretacao'] = mensagens
        
        # Adicionar métricas de referência
        dados['metricas_referencia'] = {
            'contraste_medio': float(contraste_medio),
            'contraste_std': float(contraste_std),
            'homog_media': float(homog_media),
            'homog_std': float(homog_std)
        }
    
    return setores

def gerar_relatorio_setorial(setores_analisados):
    """
    Gera relatório setorial com informações de referência
    """
    relatorio = "\n2. ANÁLISE SETORIAL\n"
    
    # Adicionar informações de referência
    if setores_analisados and 'metricas_referencia' in list(setores_analisados.values())[0]:
        ref = list(setores_analisados.values())[0]['metricas_referencia']
        relatorio += "\nValores de Referência:\n"
        relatorio += f"- Contraste Médio: {ref['contraste_medio']:.2f} (±{ref['contraste_std']:.2f})\n"
        relatorio += f"- Homogeneidade Média: {ref['homog_media']:.2f} (±{ref['homog_std']:.2f})\n\n"
    
    for setor, dados in setores_analisados.items():
        relatorio += f"\n{setor}:\n"
        relatorio += f"- Contraste: {dados['contraste']:.2f}\n"
        relatorio += f"- Homogeneidade: {dados['homogeneidade']:.2f}\n"
        
        if 'interpretacao' in dados:
            for msg in dados['interpretacao']:
                relatorio += f"  * {msg}\n"
    
    return relatorio
    
def analisar_collarette(imagem, iris_info, pupil_info):
    """
    Analisa o collarette (anel de contração) em detalhes
    """
    if iris_info is None or pupil_info is None:
        return None
    
    ix, iy, ir = iris_info
    px, py, pr = pupil_info
    
    # Distância entre pupila e íris
    dist = ir - pr
    
    # Região do collarette (aproximadamente 35% da distância)
    collarette_inner = pr + int(dist * 0.25)
    collarette_outer = pr + int(dist * 0.45)
    
    # Criar máscara do collarette
    mask = np.zeros_like(cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY))
    cv2.circle(mask, (px, py), collarette_outer, 255, -1)
    cv2.circle(mask, (px, py), collarette_inner, 0, -1)
    
    # Extrair região do collarette
    collarette_region = cv2.bitwise_and(imagem, imagem, mask=mask)
    
    # Análise detalhada
    gray_collarette = cv2.cvtColor(collarette_region, cv2.COLOR_RGB2GRAY)
    non_zero = gray_collarette[gray_collarette != 0]
    
    if len(non_zero) > 0:
        # Calcular características
        distances = [1]
        angles = [0]
        glcm = graycomatrix(non_zero.reshape(-1, 1), distances, angles, 
                          symmetric=True, normed=True)
        
        return {
            "intensidade_media": np.mean(non_zero),
            "variacao": np.std(non_zero),
            "contraste": graycoprops(glcm, 'contrast')[0, 0],
            "homogeneidade": graycoprops(glcm, 'homogeneity')[0, 0],
            "regularidade": cv2.Laplacian(gray_collarette, cv2.CV_64F).var(),
            "circularidade": avaliar_circularidade(mask)
        }
    
    return None

def avaliar_circularidade(mask):
    """
    Avalia a circularidade de uma região
    """
    contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
    if contours:
        cnt = max(contours, key=cv2.contourArea)
        area = cv2.contourArea(cnt)
        perimeter = cv2.arcLength(cnt, True)
        if perimeter > 0:
            circularity = 4 * np.pi * area / (perimeter * perimeter)
            return circularity
    return 0

def validar_metricas(metricas):
    """
    Valida e ajusta as métricas antes da interpretação
    """
    metricas_validadas = {}
    
    # Validar pupila
    if 'pupila' in metricas:
        raio = metricas['pupila'].get('raio', 0)
        circularidade = metricas['pupila'].get('circularidade', 0)
        
        # Ajustar valores inválidos
        if raio <= 0 or raio > 100:
            raio = 35  # valor médio típico
        if circularidade <= 0 or circularidade > 1:
            circularidade = 0.85  # valor típico
            
        metricas_validadas['pupila'] = {
            'raio': raio,
            'circularidade': circularidade
        }
    
    # Validar íris
    if 'iris' in metricas:
        densidade = metricas['iris'].get('densidade_media', 0)
        homogeneidade = metricas['iris'].get('homogeneidade', 0)
        
        # Ajustar valores inválidos
        if densidade < 0:
            densidade = 0.5  # valor médio típico
        if homogeneidade < 0 or homogeneidade > 1:
            homogeneidade = 0.5  # valor médio
            
        metricas_validadas['iris'] = {
            'densidade_media': densidade,
            'homogeneidade': homogeneidade
        }
    
    # Validar collarette
    if 'collarette' in metricas and metricas['collarette']:
        regularidade = metricas['collarette'].get('regularidade', 0)
        circularidade = metricas['collarette'].get('circularidade', 0)
        
        # Ajustar valores inválidos
        if regularidade < 0:
            regularidade = 300  # valor típico
        if circularidade < 0 or circularidade > 1:
            circularidade = 0.85  # valor típico
            
        metricas_validadas['collarette'] = {
            'regularidade': regularidade,
            'circularidade': circularidade
        }
    
    return metricas_validadas
    
def criar_interface():
    """
    Cria interface moderna do Gradio
    """
    theme = gr.themes.Soft(
        primary_hue="teal",
        secondary_hue="green",
    ).set(
        body_text_color="#2A9D8F",
        block_title_text_color="#264653",
        block_label_text_color="#2A9D8F",
        input_background_fill="#E9F5F3",
        button_primary_background_fill="#2A9D8F",
        button_primary_background_fill_dark="#264653",
    )

    def processar_imagem(imagem):
        try:
            # Pré-processamento da imagem
            imagem_processada = pre_processar_imagem(imagem)
    
            # Detectar esclera
            mask_esclera = detectar_esclera(imagem_processada)
    
            # Detectar íris e pupila
            iris_info, pupil_info = detectar_iris_pupila(imagem_processada, mask_esclera)
    
            if iris_info is None or pupil_info is None:
                return imagem, "Não foi possível detectar íris ou pupila corretamente."
    
            # Análise de textura setorial
            analise_setorial = analisar_textura_setorial(imagem_processada, iris_info, pupil_info)
    
            # Análise do collarette
            info_collarette = analisar_collarette(imagem_processada, iris_info, pupil_info)
    
            # Criar visualização da imagem de saída
            output_img = imagem.copy()
            ix, iy, ir = iris_info
            px, py, pr = pupil_info
    
            # Desenhar esclera
            contours, _ = cv2.findContours(mask_esclera, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
            cv2.drawContours(output_img, contours, -1, (255, 255, 0), 1)  # Esclera em amarelo
    
            # Desenhar íris
            cv2.circle(output_img, (ix, iy), ir, (0, 255, 0), 2)  # Íris em verde
    
            # Desenhar pupila
            cv2.circle(output_img, (px, py), pr, (255, 0, 0), 2)  # Pupila em vermelho
    
            # Desenhar setores
            for i in range(12):
                ang = i * 30
                rad = np.radians(ang)
                end_x = int(ix + ir * np.cos(rad))
                end_y = int(iy + ir * np.sin(rad))
                cv2.line(output_img, (ix, iy), (end_x, end_y), (255, 255, 255), 1)  # Linhas brancas para setores
    
            # Adicionando feedback visual se o collarette for detectado
            if info_collarette:
                cv2.putText(output_img, "Collarette Detected", (10, 30), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 1)
    
            # Preparar métricas para análise NLP
            metricas = {
                'pupila': {
                    'raio': pr,
                    'circularidade': avaliar_circularidade(pupil_info)
                },
                'iris': {
                    'densidade_media': np.mean([dados['contraste'] for dados in analise_setorial.values()]),
                    'homogeneidade': np.mean([dados['homogeneidade'] for dados in analise_setorial.values()])
                },
                'collarette': info_collarette
            }
    
            # Validar métricas
            metricas = validar_metricas(metricas)
            
            # Integrar análise NLP
            interpretacao_nlp = integrar_analise_nlp(metricas)
    
            # Gerar relatório
            relatorio = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n"
            relatorio += "1. MEDIDAS ESTRUTURAIS\n"
            relatorio += f"Pupila: Centro ({px}, {py}), Raio {pr}px\n"
            relatorio += f"Íris: Centro ({ix}, {iy}), Raio {ir}px\n"
    
            # Adicionar análise setorial
            relatorio += "2. ANÁLISE SETORIAL\n"
            for setor, dados in analise_setorial.items():
                relatorio += f"Setor {setor}: Contraste {dados['contraste']}, Homogeneidade {dados['homogeneidade']}\n"
    
            relatorio += f"3. COLLARETTE: {info_collarette}\n"
            relatorio += f"4. INTERPRETAÇÃO NLP: {interpretacao_nlp}\n"
    
            return output_img, relatorio
    
        except Exception as e:
            return imagem, f"Erro durante o processamento: {str(e)}"
            
    # Interface
    with gr.Blocks(theme=theme, title="Análise Iridológica Avançada") as interface:
        gr.Markdown("""
        # Sistema Avançado de Análise Iridológica
        ### Detecção precisa de esclera, íris e pupila com análise setorial e interpretação em linguagem natural
        """)
        
        with gr.Tabs():
            # Aba de Análise Principal
            with gr.Tab("Análise de Imagem"):
                with gr.Row():
                    with gr.Column():
                        input_image = gr.Image(
                            label="Imagem do Olho",
                            type="numpy"
                        )
                    with gr.Column():
                        output_image = gr.Image(
                            label="Análise Visual"
                        )
                
                analysis_btn = gr.Button("Analisar Olho", variant="primary")
                output_text = gr.Textbox(
                    label="Relatório de Análise",
                    lines=20
                )
                
                analysis_btn.click(
                    fn=processar_imagem,
                    inputs=[input_image],
                    outputs=[output_image, output_text]
                )
            
            # Aba de Configurações
            with gr.Tab("Configurações"):
                with gr.Row():
                    min_iris_radius = gr.Slider(
                        minimum=60,
                        maximum=200,
                        value=80,
                        label="Raio Mínimo da Íris (px)"
                    )
                    max_iris_radius = gr.Slider(
                        minimum=100,
                        maximum=250,
                        value=150,
                        label="Raio Máximo da Íris (px)"
                    )
                
                with gr.Row():
                    min_pupil_radius = gr.Slider(
                        minimum=15,
                        maximum=70,
                        value=20,
                        label="Raio Mínimo da Pupila (px)"
                    )
                    max_pupil_radius = gr.Slider(
                        minimum=30,
                        maximum=100,
                        value=50,
                        label="Raio Máximo da Pupila (px)"
                    )
            
            # Aba de Guia de Captura
            with gr.Tab("Guia de Captura"):
                gr.Markdown("""
                ## Guia para Captura de Imagem
                
                ### 1. Iluminação Ideal
                - Luz natural indireta
                - Sem reflexos diretos no olho
                - Iluminação uniforme
                - Evitar flash
                
                ### 2. Posicionamento
                - Olho totalmente aberto
                - Câmera perpendicular ao olho
                - Distância adequada (15-20cm)
                - Íris centralizada na imagem
                
                ### 3. Qualidade da Imagem
                - Resolução mínima: 1280x720
                - Foco perfeito na íris
                - Sem movimento/tremor
                - Imagem nítida e clara
                
                ### 4. Preparação
                - Limpar a lente da câmera
                - Olho descansado
                - Ambiente calmo
                - Múltiplas capturas
                """)
            
            # Aba de Interpretação
            with gr.Tab("Guia de Interpretação"):
                gr.Markdown("""
                ## Guia de Interpretação dos Resultados
                
                ### 1. Análise da Pupila
                - **Tamanho**: Indica atividade do sistema nervoso
                - **Forma**: Regular ou irregular
                - **Posição**: Centralizada ou deslocada
                
                ### 2. Análise da Íris
                - **Densidade**: Integridade do tecido
                - **Coloração**: Atividade metabólica
                - **Textura**: Estado geral dos tecidos
                
                ### 3. Sinais Específicos
                - **Lacunas**: Possíveis deficiências
                - **Manchas**: Toxicidade ou inflamação
                - **Anéis**: Tensão ou congestão
                
                ### 4. Collarette
                - **Regularidade**: Equilíbrio do sistema
                - **Circularidade**: Integridade estrutural
                - **Densidade**: Vitalidade geral
                """)
    
    return interface

def main():
    interface = criar_interface()
    interface.launch(share=True)

if __name__ == "__main__":
    main()