Update app.py

app.py

@@ -4,53 +4,69 @@ import numpy as np
 from PIL import Image
 import io
 from collections import defaultdict
+from scipy import ndimage
 
-def melhorar_contraste(imagem):
+def pre_processar_imagem(imagem):
     """
-    Aplica equalização de histograma adaptativo para melhorar contraste
+    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))
-    return cv2.cvtColor(lab, cv2.COLOR_LAB2RGB)
+    
+    # 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_pupila_iris(imagem):
+def detectar_esclera(imagem):
     """
-    Detecta pupila e íris com técnicas avançadas
+    Detecta a região da esclera usando segmentação por cor e morfologia
     """
-    # Melhorar contraste
-    imagem_melhorada = melhorar_contraste(imagem)
+    # Converter para HSV
+    hsv = cv2.cvtColor(imagem, cv2.COLOR_RGB2HSV)
     
-    # Converter para escala de cinza
-    gray = cv2.cvtColor(imagem_melhorada, cv2.COLOR_RGB2GRAY)
+    # Definir faixa de cor para branco (esclera)
+    lower_white = np.array([0, 0, 180])
+    upper_white = np.array([180, 30, 255])
     
-    # Aplicar blur para reduzir ruído
-    blur = cv2.GaussianBlur(gray, (7, 7), 0)
+    # Criar máscara
+    mask_esclera = cv2.inRange(hsv, lower_white, upper_white)
     
-    # Detectar bordas
-    edges = cv2.Canny(blur, 30, 60)
+    # 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 fechamento morfológico para conectar bordas
-    kernel = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (5,5))
-    closed = cv2.morphologyEx(edges, cv2.MORPH_CLOSE, kernel)
+    # Aplicar máscara da esclera invertida
+    mask_olho = cv2.bitwise_not(mask_esclera)
+    eye_region = cv2.bitwise_and(gray, gray, mask=mask_olho)
     
-    # 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 bordas
+    edges = cv2.Canny(eye_region, 30, 60)
     
-    # Detectar círculos para íris (maiores)
+    # Detectar círculos para íris
     iris_circles = cv2.HoughCircles(
-        closed,
+        edges,
         cv2.HOUGH_GRADIENT,
         dp=1,
         minDist=100,
@@ -60,76 +76,72 @@ def detectar_pupila_iris(imagem):
         maxRadius=150
     )
     
-    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
+    # Criar máscara 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
+        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 output_img, pupila_info, iris_info
+    return None, None
 
-def extrair_caracteristicas_avancadas(imagem, pupila_info, iris_info):
+def analisar_textura_setorial(imagem, iris_info, pupil_info):
     """
-    Extrai características avançadas da íris usando a posição da pupila
+    Analisa a textura da íris por setores
     """
-    if pupila_info is None or iris_info is None:
+    if iris_info is None or pupil_info is None:
         return {}
     
-    # Converter para escala de cinza
-    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
-    
-    # Coordenadas da pupila e íris
-    px, py, pr = pupila_info
     ix, iy, ir = iris_info
+    px, py, pr = pupil_info
     
-    # 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
-    
-    # Aplicar máscara
-    iris_ring = cv2.bitwise_and(gray, gray, mask=mask)
-    
-    # Análise de textura
-    caracteristicas = {}
+    # Converter para escala de cinza
+    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
     
-    # Divisão em setores
-    setores = {
-        "superior": (315, 45),
-        "direito": (45, 135),
-        "inferior": (135, 225),
-        "esquerdo": (225, 315)
-    }
+    # Criar máscara anelar da íris
+    mask_iris = np.zeros_like(gray)
+    cv2.circle(mask_iris, (ix, iy), ir, 255, -1)
+    cv2.circle(mask_iris, (px, py), pr, 0, -1)
     
-    for setor, (ang_inicio, ang_fim) in setores.items():
+    # Dividir em 12 setores (como um relógio)
+    setores = {}
+    for i in range(12):
+        ang_inicio = i * 30
+        ang_fim = (i + 1) * 30
+        
         # Criar máscara do setor
-        setor_mask = np.zeros_like(gray)
-        cv2.ellipse(setor_mask, 
+        mask_setor = np.zeros_like(gray)
+        cv2.ellipse(mask_setor,
                    (ix, iy),
                    (ir, ir),
                    0,
@@ -138,58 +150,90 @@ def extrair_caracteristicas_avancadas(imagem, pupila_info, iris_info):
                    255,
                    -1)
         
-        # Aplicar máscara do setor
-        setor_roi = cv2.bitwise_and(iris_ring, iris_ring, mask=setor_mask)
+        # Combinar máscaras
+        mask_final = cv2.bitwise_and(mask_iris, mask_setor)
         
-        # Análises no setor
+        # 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) > 0:
-            caracteristicas[setor] = {
+            # Calcular características de textura
+            glcm = graycomatrix(non_zero.reshape(-1, 1), [1], [0], symmetric=True, normed=True)
+            
+            setores[f"setor_{i+1}"] = {
                 "media": np.mean(non_zero),
                 "std": np.std(non_zero),
-                "min": np.min(non_zero),
-                "max": np.max(non_zero)
+                "contraste": graycoprops(glcm, 'contrast')[0, 0],
+                "homogeneidade": graycoprops(glcm, 'homogeneity')[0, 0],
+                "energia": graycoprops(glcm, 'energy')[0, 0],
+                "correlacao": graycoprops(glcm, 'correlation')[0, 0]
             }
     
-    return caracteristicas
+    return setores
 
-def analisar_padrao_collarette(imagem, pupila_info, iris_info):
+def analisar_collarette(imagem, iris_info, pupil_info):
     """
-    Analisa o padrão do collarette (anel ao redor da pupila)
+    Analisa o collarette (anel de contração) em detalhes
     """
-    if pupila_info is None or iris_info is None:
+    if iris_info is None or pupil_info is None:
         return None
     
-    px, py, pr = pupila_info
     ix, iy, ir = iris_info
+    px, py, pr = pupil_info
     
-    # Região do collarette (aprox. 1/3 da distância entre pupila e íris)
-    collarette_r = pr + int((ir - pr) * 0.33)
+    # Distância entre pupila e íris
+    dist = ir - pr
     
-    # Criar máscara anelar para o collarette
+    # 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_r, 255, -1)
-    cv2.circle(mask, (px, py), pr, 0, -1)
+    cv2.circle(mask, (px, py), collarette_outer, 255, -1)
+    cv2.circle(mask, (px, py), collarette_inner, 0, -1)
     
-    # Aplicar máscara
-    collarette = cv2.bitwise_and(imagem, imagem, mask=mask)
+    # Extrair região do collarette
+    collarette_region = cv2.bitwise_and(imagem, imagem, mask=mask)
     
-    # Análise do collarette
-    gray_collarette = cv2.cvtColor(collarette, cv2.COLOR_RGB2GRAY)
+    # 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
+        glcm = graycomatrix(non_zero.reshape(-1, 1), [1], [0], symmetric=True, normed=True)
+        
         return {
             "intensidade_media": np.mean(non_zero),
             "variacao": np.std(non_zero),
-            "regularidade": cv2.Laplacian(gray_collarette, cv2.CV_64F).var()
+            "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, 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 criar_interface():
     """
-    Cria interface do Gradio com tema verde piscina
+    Cria interface moderna do Gradio
     """
     theme = gr.themes.Soft(
         primary_hue="teal",
@@ -204,70 +248,100 @@ def criar_interface():
     )
     
     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"
+        try:
+            # Pré-processamento
+            imagem_processada = pre_processar_imagem(imagem)
             
-            # 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
+            # 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
+            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
+            output_img = imagem.copy()
+            
+            # Desenhar esclera
+            contours, _ = cv2.findContours(mask_esclera, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+            cv2.drawContours(output_img, contours, -1, (255, 255, 0), 1)
+            
+            # Desenhar íris
+            ix, iy, ir = iris_info
+            cv2.circle(output_img, (ix, iy), ir, (0, 255, 0), 2)
+            
+            # Desenhar pupila
+            px, py, pr = pupil_info
+            cv2.circle(output_img, (px, py), pr, (255, 0, 0), 2)
+            
+            # 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), (0, 255, 0), 1)
+            
+            # Gerar relatório
+            relatorio = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n"
+            
+            # Informações estruturais
+            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"
+            
+            # Análise setorial
+            relatorio += "\n2. ANÁLISE SETORIAL\n"
+            for setor, dados in analise_setorial.items():
+                relatorio += f"\n{setor}:\n"
+                relatorio += f"- Contraste: {dados['contraste']:.2f}\n"
+                relatorio += f"- Homogeneidade: {dados['homogeneidade']:.2f}\n"
+                
+                # Interpretação
+                if dados['contraste'] > 2.0:
+                    relatorio += "  * Alta densidade de sinais\n"
+                if dados['homogeneidade'] < 0.5:
+                    relatorio += "  * Possível área de alteração\n"
+            
+            # Análise do collarette
+            if info_collarette:
+                relatorio += "\n3. ANÁLISE DO COLLARETTE\n"
+                relatorio += f"- Regularidade: {info_collarette['regularidade']:.2f}\n"
+                relatorio += f"- Circularidade: {info_collarette['circularidade']:.2f}\n"
+                
+                # Interpretação
+                if info_collarette['regularidade'] > 500:
+                    relatorio += "  * Irregularidade significativa\n"
+                if info_collarette['circularidade'] < 0.8:
+                    relatorio += "  * Possível deformação estrutural\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 pupila e íris com análise setorial
+        ### Detecção precisa de esclera, íris e pupila com análise setorial
         """)
         
         with gr.Tabs():
-            # Aba de Análise
+            # Aba de Análise Principal
             with gr.Tab("Análise de Imagem"):
                 with gr.Row():
                     with gr.Column():
                         input_image = gr.Image(
-                            label="Imagem da Íris",
+                            label="Imagem do Olho",
                             type="numpy"
                         )
                     with gr.Column():
@@ -275,10 +349,10 @@ def criar_interface():
                             label="Análise Visual"
                         )
                 
-                analysis_btn = gr.Button("Analisar Íris", variant="primary")
+                analysis_btn = gr.Button("Analisar Olho", variant="primary")
                 output_text = gr.Textbox(
                     label="Relatório de Análise",
-                    lines=15
+                    lines=20
                 )
                 
                 analysis_btn.click(
@@ -287,36 +361,97 @@ def criar_interface():
                     outputs=[output_image, output_text]
                 )
             
-            # Aba de Informações
+            # 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
                 
-                ### Requisitos da Imagem
-                1. **Iluminação**
-                   - Luz uniforme
-                   - Sem reflexos na pupila
-                   - Sem sombras fortes
+                ### 1. Iluminação Ideal
+                - Luz natural indireta
+                - Sem reflexos diretos no olho
+                - Iluminação uniforme
+                - Evitar flash
                 
-                2. **Posicionamento**
-                   - Olho bem aberto
-                   - Íris centralizada
-                   - Foco na íris
+                ### 2. Posicionamento
+                - Olho totalmente aberto
+                - Câmera perpendicular ao olho
+                - Distância adequada (15-20cm)
+                - Íris centralizada na imagem
                 
-                3. **Qualidade**
-                   - Alta resolução
-                   - Imagem nítida
-                   - Sem borramento
+                ### 3. Qualidade da Imagem
+                - Resolução mínima: 1280x720
+                - Foco perfeito na íris
+                - Sem movimento/tremor
+                - Imagem nítida e clara
                 
-                ### Dicas de Captura
-                - Use luz natural indireta
-                - Mantenha a câmera estável
-                - Capture múltiplas fotos
-                - Verifique o foco antes
+                ### 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
 
-if __name__ == "__main__":
+def main():
     interface = criar_interface()
-    interface.launch(share=True)
+    interface.launch(share=True)
+
+if __name__ == "__main__":
+    main()