app.py

import gradio as gr
import cv2
import numpy as np
from PIL import Image
import io
from collections import defaultdict

def melhorar_contraste(imagem):
    """
    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_melhorada, cv2.COLOR_RGB2GRAY)
    
    # Aplicar blur para reduzir ruído
    blur = cv2.GaussianBlur(gray, (7, 7), 0)
    
    # 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=80,
        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
    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 extrair_caracteristicas_avancadas(imagem, pupila_info, iris_info):
    """
    Extrai características avançadas da íris usando a posição da pupila
    """
    if pupila_info is None or iris_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
    
    # 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 = {}
    
    # Divisão em setores
    setores = {
        "superior": (315, 45),
        "direito": (45, 135),
        "inferior": (135, 225),
        "esquerdo": (225, 315)
    }
    
    for setor, (ang_inicio, ang_fim) in setores.items():
        # 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 do setor
        setor_roi = cv2.bitwise_and(iris_ring, iris_ring, mask=setor_mask)
        
        # 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 analisar_padrao_collarette(imagem, pupila_info, iris_info):
    """
    Analisa o padrão do collarette (anel ao redor da pupila)
    """
    if pupila_info is None or iris_info is None:
        return None
    
    px, py, pr = pupila_info
    ix, iy, ir = iris_info
    
    # Região do collarette (aprox. 1/3 da distância entre pupila e íris)
    collarette_r = pr + int((ir - pr) * 0.33)
    
    # 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)
    
    # Aplicar máscara
    collarette = cv2.bitwise_and(imagem, imagem, mask=mask)
    
    # Análise do collarette
    gray_collarette = cv2.cvtColor(collarette, cv2.COLOR_RGB2GRAY)
    non_zero = gray_collarette[gray_collarette != 0]
    
    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()
        }
    
    return None

def criar_interface():
    """
    Cria interface do Gradio com tema verde piscina
    """
    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):
        # 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 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
        """)
        
        with gr.Tabs():
            # Aba de Análise
            with gr.Tab("Análise de Imagem"):
                with gr.Row():
                    with gr.Column():
                        input_image = gr.Image(
                            label="Imagem da Íris",
                            type="numpy"
                        )
                    with gr.Column():
                        output_image = gr.Image(
                            label="Análise Visual"
                        )
                
                analysis_btn = gr.Button("Analisar Íris", variant="primary")
                output_text = gr.Textbox(
                    label="Relatório de Análise",
                    lines=15
                )
                
                analysis_btn.click(
                    fn=processar_imagem,
                    inputs=[input_image],
                    outputs=[output_image, output_text]
                )
            
            # Aba de Informações
            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
                
                2. **Posicionamento**
                   - Olho bem aberto
                   - Íris centralizada
                   - Foco na íris
                
                3. **Qualidade**
                   - Alta resolução
                   - Imagem nítida
                   - Sem borramento
                
                ### Dicas de Captura
                - Use luz natural indireta
                - Mantenha a câmera estável
                - Capture múltiplas fotos
                - Verifique o foco antes
                """)
    
    return interface

if __name__ == "__main__":
    interface = criar_interface()
    interface.launch(share=True)