Update app.py

app.py

@@ -5,221 +5,192 @@ from PIL import Image
 import io
 from collections import defaultdict
 
-def detectar_iris(imagem):
+def melhorar_contraste(imagem):
     """
-    Detecta a íris na imagem e retorna a região de interesse
+    Aplica equalização de histograma adaptativo para melhorar contraste
     """
+    lab = cv2.cvtColor(imagem, cv2.COLOR_RGB2LAB)
+    l, a, b = cv2.split(lab)
+    clahe = cv2.createCLAHE(clipLimit=3.0, tileGridSize=(8,8))
+    l = clahe.apply(l)
+    lab = cv2.merge((l,a,b))
+    return cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+
+def detectar_pupila_iris(imagem):
+    """
+    Detecta pupila e íris com técnicas avançadas
+    """
+    # Melhorar contraste
+    imagem_melhorada = melhorar_contraste(imagem)
+    
     # Converter para escala de cinza
-    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
+    gray = cv2.cvtColor(imagem_melhorada, cv2.COLOR_RGB2GRAY)
     
     # Aplicar blur para reduzir ruído
     blur = cv2.GaussianBlur(gray, (7, 7), 0)
     
-    # Detectar círculos (íris) usando transformada de Hough
-    circles = cv2.HoughCircles(
-        blur,
+    # Detectar bordas
+    edges = cv2.Canny(blur, 30, 60)
+    
+    # Aplicar fechamento morfológico para conectar bordas
+    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
+    closed = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
+    
+    # Detectar círculos para pupila (menores)
+    pupila_circles = cv2.HoughCircles(
+        closed,
         cv2.HOUGH_GRADIENT,
         dp=1,
         minDist=50,
         param1=50,
+        param2=25,
+        minRadius=20,
+        maxRadius=50
+    )
+    
+    # Detectar círculos para íris (maiores)
+    iris_circles = cv2.HoughCircles(
+        closed,
+        cv2.HOUGH_GRADIENT,
+        dp=1,
+        minDist=100,
+        param1=50,
         param2=30,
-        minRadius=50,
+        minRadius=80,
         maxRadius=150
     )
     
-    if circles is not None:
-        # Converter coordenadas para inteiros
-        circles = np.uint16(np.around(circles))
-        
-        # Pegar o primeiro círculo detectado
-        x, y, r = circles[0][0]
-        
-        # Criar máscara circular
-        mask = np.zeros_like(gray)
-        cv2.circle(mask, (x, y), r, 255, -1)
-        
-        # Aplicar máscara na imagem original
-        result = cv2.bitwise_and(imagem, imagem, mask=mask)
-        
-        # Recortar região da íris
-        roi = result[y-r:y+r, x-r:x+r]
-        
-        return roi, (x, y, r)
-    
-    return None, None
+    output_img = imagem.copy()
+    
+    # Desenhar círculos da pupila
+    if pupila_circles is not None:
+        pupila_circles = np.uint16(np.around(pupila_circles))
+        for i in pupila_circles[0,:]:
+            # Desenhar círculo da pupila
+            cv2.circle(output_img, (i[0], i[1]), i[2], (255, 0, 0), 2)
+            # Desenhar centro
+            cv2.circle(output_img, (i[0], i[1]), 2, (0, 0, 255), 3)
+            pupila_info = (i[0], i[1], i[2])
+    else:
+        pupila_info = None
+    
+    # Desenhar círculos da íris
+    if iris_circles is not None:
+        iris_circles = np.uint16(np.around(iris_circles))
+        for i in iris_circles[0,:]:
+            # Desenhar círculo da íris
+            cv2.circle(output_img, (i[0], i[1]), i[2], (0, 255, 0), 2)
+            iris_info = (i[0], i[1], i[2])
+            
+            # Desenhar setores da íris
+            ang_step = 45
+            for ang in range(0, 360, ang_step):
+                end_x = int(i[0] + i[2] * np.cos(np.radians(ang)))
+                end_y = int(i[1] + i[2] * np.sin(np.radians(ang)))
+                cv2.line(output_img, (i[0], i[1]), (end_x, end_y), (0, 255, 0), 1)
+    else:
+        iris_info = None
+    
+    return output_img, pupila_info, iris_info
 
-def analisar_textura(roi):
+def extrair_caracteristicas_avancadas(imagem, pupila_info, iris_info):
     """
-    Analisa a textura da íris para identificar padrões
+    Extrai características avançadas da íris usando a posição da pupila
     """
-    if roi is None:
+    if pupila_info is None or iris_info is None:
         return {}
     
     # Converter para escala de cinza
-    gray = cv2.cvtColor(roi, cv2.COLOR_RGB2GRAY)
-    
-    # Análises de textura
-    padroes = {
-        "congestao_inflamacao": False,
-        "deficiencia_hipofuncao": False,
-        "atrofia_degeneracao": False,
-        "irritacao_estresse": False
-    }
-    
-    # Análise de variância local
-    kernel_size = 5
-    local_var = cv2.Laplacian(gray, cv2.CV_64F).var()
-    
-    # Análise de intensidade média
-    mean_intensity = np.mean(gray)
-    
-    # Análise de contraste
-    contrast = np.std(gray)
-    
-    # Detecção de bordas
-    edges = cv2.Canny(gray, 100, 200)
-    edge_density = np.sum(edges) / (edges.shape[0] * edges.shape[1])
-    
-    # Definir limiares para cada padrão
-    if local_var > 100:
-        padroes["congestao_inflamacao"] = True
+    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
     
-    if mean_intensity < 100:
-        padroes["deficiencia_hipofuncao"] = True
+    # Coordenadas da pupila e íris
+    px, py, pr = pupila_info
+    ix, iy, ir = iris_info
     
-    if contrast < 30:
-        padroes["atrofia_degeneracao"] = True
+    # Criar máscara anelar (região entre pupila e íris)
+    mask = np.zeros_like(gray)
+    cv2.circle(mask, (ix, iy), ir, 255, -1)  # Íris
+    cv2.circle(mask, (px, py), pr, 0, -1)    # Pupila
     
-    if edge_density > 0.1:
-        padroes["irritacao_estresse"] = True
+    # Aplicar máscara
+    iris_ring = cv2.bitwise_and(gray, gray, mask=mask)
     
-    return padroes
-
-def analisar_setores(roi, centro, raio):
-    """
-    Analisa diferentes setores da íris
-    """
-    if roi is None:
-        return {}
+    # Análise de textura
+    caracteristicas = {}
     
+    # Divisão em setores
     setores = {
-        "superior": (315, 45),    # Cérebro
-        "direito": (45, 135),     # Fígado
-        "inferior": (135, 225),   # Sistema Digestivo
-        "esquerdo": (225, 315)    # Coração
+        "superior": (315, 45),
+        "direito": (45, 135),
+        "inferior": (135, 225),
+        "esquerdo": (225, 315)
     }
     
-    resultados = {}
-    
     for setor, (ang_inicio, ang_fim) in setores.items():
-        # Criar máscara para o setor
-        mask = np.zeros_like(roi[:,:,0])
-        cv2.ellipse(mask, 
-                   (raio, raio), 
-                   (raio-10, raio-10), 
-                   0, 
-                   ang_inicio, 
-                   ang_fim, 
-                   255, 
+        # Criar máscara do setor
+        setor_mask = np.zeros_like(gray)
+        cv2.ellipse(setor_mask, 
+                   (ix, iy),
+                   (ir, ir),
+                   0,
+                   ang_inicio,
+                   ang_fim,
+                   255,
                    -1)
         
-        # Aplicar máscara
-        setor_roi = cv2.bitwise_and(roi, roi, mask=mask)
+        # Aplicar máscara do setor
+        setor_roi = cv2.bitwise_and(iris_ring, iris_ring, mask=setor_mask)
         
-        # Analisar textura do setor
-        resultados[setor] = analisar_textura(setor_roi)
-    
-    return resultados
+        # Análises no setor
+        non_zero = setor_roi[setor_roi != 0]
+        if len(non_zero) > 0:
+            caracteristicas[setor] = {
+                "media": np.mean(non_zero),
+                "std": np.std(non_zero),
+                "min": np.min(non_zero),
+                "max": np.max(non_zero)
+            }
+    
+    return caracteristicas
 
-def gerar_diagnostico(padroes, setores):
+def analisar_padrao_collarette(imagem, pupila_info, iris_info):
     """
-    Gera diagnóstico baseado nos padrões encontrados
+    Analisa o padrão do collarette (anel ao redor da pupila)
     """
-    diagnostico = []
-    
-    # Mapeamento de padrões para possíveis condições
-    mapa_condicoes = {
-        "congestao_inflamacao": [
-            "Processo inflamatório ativo",
-            "Possível condição autoimune",
-            "Inflamação crônica"
-        ],
-        "deficiencia_hipofuncao": [
-            "Deficiência nutricional",
-            "Hipofunção glandular",
-            "Fadiga crônica"
-        ],
-        "atrofia_degeneracao": [
-            "Desgaste tecidual",
-            "Processo degenerativo",
-            "Envelhecimento acelerado"
-        ],
-        "irritacao_estresse": [
-            "Estresse crônico",
-            "Sobrecarga do sistema nervoso",
-            "Ansiedade"
-        ]
-    }
+    if pupila_info is None or iris_info is None:
+        return None
     
-    # Analisar padrões gerais
-    for padrao, presente in padroes.items():
-        if presente:
-            diagnostico.extend(mapa_condicoes[padrao])
+    px, py, pr = pupila_info
+    ix, iy, ir = iris_info
     
-    # Analisar setores específicos
-    for setor, padroes_setor in setores.items():
-        for padrao, presente in padroes_setor.items():
-            if presente:
-                if setor == "superior":
-                    diagnostico.append(f"Região cerebral: {mapa_condicoes[padrao][0]}")
-                elif setor == "direito":
-                    diagnostico.append(f"Região hepática: {mapa_condicoes[padrao][0]}")
-                elif setor == "inferior":
-                    diagnostico.append(f"Região digestiva: {mapa_condicoes[padrao][0]}")
-                elif setor == "esquerdo":
-                    diagnostico.append(f"Região cardíaca: {mapa_condicoes[padrao][0]}")
+    # Região do collarette (aprox. 1/3 da distância entre pupila e íris)
+    collarette_r = pr + int((ir - pr) * 0.33)
     
-    return list(set(diagnostico))  # Remover duplicatas
-
-def processar_imagem(imagem):
-    """
-    Processa a imagem da íris e retorna análise
-    """
-    # Converter imagem para formato OpenCV
-    img_array = np.array(imagem)
+    # Criar máscara anelar para o collarette
+    mask = np.zeros_like(cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY))
+    cv2.circle(mask, (px, py), collarette_r, 255, -1)
+    cv2.circle(mask, (px, py), pr, 0, -1)
     
-    # Detectar íris
-    roi, (x, y, r) = detectar_iris(img_array)
-    if roi is None:
-        return "Não foi possível detectar a íris na imagem."
+    # Aplicar máscara
+    collarette = cv2.bitwise_and(imagem, imagem, mask=mask)
     
-    # Analisar padrões gerais
-    padroes = analisar_textura(roi)
+    # Análise do collarette
+    gray_collarette = cv2.cvtColor(collarette, cv2.COLOR_RGB2GRAY)
+    non_zero = gray_collarette[gray_collarette != 0]
     
-    # Analisar setores
-    setores = analisar_setores(roi, (x, y), r)
+    if len(non_zero) > 0:
+        return {
+            "intensidade_media": np.mean(non_zero),
+            "variacao": np.std(non_zero),
+            "regularidade": cv2.Laplacian(gray_collarette, cv2.CV_64F).var()
+        }
     
-    # Gerar diagnóstico
-    diagnostico = gerar_diagnostico(padroes, setores)
-    
-    # Gerar visualização
-    output_img = img_array.copy()
-    cv2.circle(output_img, (x, y), r, (0, 255, 0), 2)
-    
-    # Desenhar setores
-    ang_step = 45
-    for ang in range(0, 360, ang_step):
-        end_x = int(x + r * np.cos(np.radians(ang)))
-        end_y = int(y + r * np.sin(np.radians(ang)))
-        cv2.line(output_img, (x, y), (end_x, end_y), (0, 255, 0), 1)
-    
-    return output_img, "\n".join(diagnostico)
+    return None
 
 def criar_interface():
     """
-    Cria interface moderna do Gradio
+    Cria interface do Gradio com tema verde piscina
     """
-    # Tema personalizado verde piscina
     theme = gr.themes.Soft(
         primary_hue="teal",
         secondary_hue="green",
@@ -232,11 +203,62 @@ def criar_interface():
         button_primary_background_fill_dark="#264653",
     )
     
+    def processar_imagem(imagem):
+        # Detectar pupila e íris
+        output_img, pupila_info, iris_info = detectar_pupila_iris(imagem)
+        
+        if pupila_info is None or iris_info is None:
+            return output_img, "Não foi possível detectar pupila ou íris corretamente."
+        
+        # Extrair características
+        caracteristicas = extrair_caracteristicas_avancadas(imagem, pupila_info, iris_info)
+        
+        # Analisar collarette
+        collarette_info = analisar_padrao_collarette(imagem, pupila_info, iris_info)
+        
+        # Gerar relatório
+        relatorio = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n"
+        
+        # Informações da pupila
+        px, py, pr = pupila_info
+        relatorio += f"Pupila:\n"
+        relatorio += f"- Centro: ({px}, {py})\n"
+        relatorio += f"- Raio: {pr}px\n"
+        
+        # Informações da íris
+        ix, iy, ir = iris_info
+        relatorio += f"\nÍris:\n"
+        relatorio += f"- Centro: ({ix}, {iy})\n"
+        relatorio += f"- Raio: {ir}px\n"
+        
+        # Análise por setores
+        relatorio += "\nAnálise por Setores:\n"
+        for setor, dados in caracteristicas.items():
+            relatorio += f"\n{setor.title()}:\n"
+            relatorio += f"- Intensidade média: {dados['media']:.1f}\n"
+            relatorio += f"- Variação: {dados['std']:.1f}\n"
+            
+            # Interpretar dados
+            if dados['std'] > 40:
+                relatorio += "  * Alta variação - possível inflamação\n"
+            if dados['media'] < 100:
+                relatorio += "  * Baixa intensidade - possível deficiência\n"
+        
+        # Análise do collarette
+        if collarette_info:
+            relatorio += "\nAnálise do Collarette:\n"
+            if collarette_info['regularidade'] > 500:
+                relatorio += "- Irregularidade significativa\n"
+            if collarette_info['variacao'] > 30:
+                relatorio += "- Alta variação de textura\n"
+        
+        return output_img, relatorio
+    
     # Interface
-    with gr.Blocks(theme=theme, title="Análise Iridológica por Imagem") as 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
-        ### Análise automatizada de imagens da íris
+        ### Detecção precisa de pupila e íris com análise setorial
         """)
         
         with gr.Tabs():
@@ -246,17 +268,17 @@ def criar_interface():
                     with gr.Column():
                         input_image = gr.Image(
                             label="Imagem da Íris",
-                            type="pil"
+                            type="numpy"
                         )
                     with gr.Column():
                         output_image = gr.Image(
-                            label="Íris Analisada"
+                            label="Análise Visual"
                         )
                 
                 analysis_btn = gr.Button("Analisar Íris", variant="primary")
                 output_text = gr.Textbox(
-                    label="Diagnóstico",
-                    lines=10
+                    label="Relatório de Análise",
+                    lines=15
                 )
                 
                 analysis_btn.click(
@@ -265,56 +287,32 @@ def criar_interface():
                     outputs=[output_image, output_text]
                 )
             
-            # Aba de Guia
-            with gr.Tab("Guia de Interpretação"):
+            # Aba de Informações
+            with gr.Tab("Guia de Captura"):
                 gr.Markdown("""
-                ## Interpretação dos Sinais
-                
-                ### Padrões Principais
-                - **Congestão/Inflamação**: Áreas escuras ou densas
-                - **Deficiência/Hipofunção**: Áreas claras ou vazias
-                - **Atrofia/Degeneração**: Lacunas ou descontinuidades
-                - **Irritação/Estresse**: Linhas radiais ou manchas
+                ## Guia para Captura de Imagem
                 
-                ### Setores da Íris
-                1. **Superior**: Região cerebral
-                2. **Direito**: Região hepática
-                3. **Inferior**: Região digestiva
-                4. **Esquerdo**: Região cardíaca
-                
-                ### Recomendações
-                - Faça a foto com boa iluminação
-                - Mantenha o olho bem aberto
-                - Evite reflexos na imagem
-                - Use câmera com boa resolução
-                """)
-            
-            # Aba de Recomendações
-            with gr.Tab("Recomendações"):
-                gr.Markdown("""
-                ## Recomendações Gerais
-                
-                ### Qualidade da Imagem
-                - Resolução mínima: 1280x720
-                - Iluminação uniforme
-                - Foco na íris
-                - Sem reflexos
-                
-                ### Preparação
-                1. **Ambiente**
-                   - Bem iluminado
-                   - Sem luz direta
-                   - Fundo claro
+                ### Requisitos da Imagem
+                1. **Iluminação**
+                   - Luz uniforme
+                   - Sem reflexos na pupila
+                   - Sem sombras fortes
                 
                 2. **Posicionamento**
                    - Olho bem aberto
-                   - Câmera estável
-                   - Distância adequada
+                   - Íris centralizada
+                   - Foco na íris
+                
+                3. **Qualidade**
+                   - Alta resolução
+                   - Imagem nítida
+                   - Sem borramento
                 
-                3. **Momento**
-                   - Evite olhos irritados
-                   - Preferencialmente pela manhã
-                   - Após descanso
+                ### Dicas de Captura
+                - Use luz natural indireta
+                - Mantenha a câmera estável
+                - Capture múltiplas fotos
+                - Verifique o foco antes
                 """)
     
     return interface