Rename app.py to analisador_iridologico.py

app.py → analisador_iridologico.py

@@ -1,4 +1,3 @@
-import gradio as gr
 import cv2
 import numpy as np
 from PIL import Image
@@ -11,13 +10,13 @@ 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 = {
+        self.referencias = self._definir_referencias()
+
+    def _definir_referencias(self):
+        return {
             'pupila': {
                 'tamanho': {
                     'grande': 'Indica possível estresse do sistema nervoso ou fadiga adrenal',
@@ -54,11 +53,8 @@ class AnalisadorIridologicoNLP:
                 }
             }
         }
-    
+
     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'
@@ -66,7 +62,6 @@ class AnalisadorIridologicoNLP:
                 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'
@@ -76,7 +71,6 @@ class AnalisadorIridologicoNLP:
                 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'
@@ -86,16 +80,10 @@ class AnalisadorIridologicoNLP:
                 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'],
@@ -107,11 +95,9 @@ class AnalisadorIridologicoNLP:
                 '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'],
@@ -123,11 +109,9 @@ class AnalisadorIridologicoNLP:
                 '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'],
@@ -139,14 +123,10 @@ class AnalisadorIridologicoNLP:
                 '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",
@@ -154,94 +134,44 @@ class AnalisadorIridologicoNLP:
             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}")
-        
+        refined_sentencas = [f"• {s}" for s in sentencas if len(s.strip()) > 0]
         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)
-
+# Funções de pré-processamento, detecção e análise
 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,
@@ -252,18 +182,13 @@ def detectar_iris_pupila(imagem, mask_esclera):
         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,
@@ -272,8 +197,6 @@ def detectar_iris_pupila(imagem, mask_esclera):
             11,
             2
         )
-        
-        # Detectar pupila
         pupil_circles = cv2.HoughCircles(
             thresh,
             cv2.HOUGH_GRADIENT,
@@ -284,49 +207,33 @@ def detectar_iris_pupila(imagem, mask_esclera):
             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),
@@ -337,28 +244,21 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
                     255,
                     -1)
 
-        # Combinar máscaras
-        kernel = np.ones((2, 2), np.uint8)
         mask_final = cv2.bitwise_and(mask_iris, mask_setor)
+        kernel = np.ones((2, 2), np.uint8)
         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], 
@@ -366,7 +266,6 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
                                         symmetric=True, 
                                         normed=True)
                     
-                    # Calcular propriedades
                     contraste = np.mean(graycoprops(glcm, 'contrast'))
                     homogeneidade = np.mean(graycoprops(glcm, 'homogeneity'))
 
@@ -377,7 +276,6 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
                         "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,
@@ -400,428 +298,50 @@ def analisar_textura_setorial(imagem, iris_info, pupil_info):
             }
 
     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
+            raio = 35
         if circularidade <= 0 or circularidade > 1:
-            circularidade = 0.85  # valor típico
+            circularidade = 0.85
             
         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
+            densidade = 0.5
         if homogeneidade < 0 or homogeneidade > 1:
-            homogeneidade = 0.5  # valor médio
+            homogeneidade = 0.5
             
         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
+            regularidade = 300
         if circularidade < 0 or circularidade > 1:
-            circularidade = 0.85  # valor típico
+            circularidade = 0.85
             
         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()
+    return metricas_validadas