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

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
    """
    if iris_info is None or pupil_info is None:
        return {}
    
    ix, iy, ir = iris_info
    px, py, pr = pupil_info
    
    # Converter para escala de cinza
    gray = cv2.cvtColor(imagem, cv2.COLOR_RGB2GRAY)
    
    # 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)
    
    # 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
        mask_setor = np.zeros_like(gray)
        cv2.ellipse(mask_setor,
                   (ix, iy),
                   (ir, ir),
                   0,
                   ang_inicio,
                   ang_fim,
                   255,
                   -1)
        
        # Combinar máscaras
        mask_final = cv2.bitwise_and(mask_iris, mask_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:
            # 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),
                "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 setores

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
        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),
            "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 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
            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
            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 esclera, íris e pupila com análise setorial
        """)
        
        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()