app.py

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

def detectar_iris(imagem):
    """
    Detecta a íris na imagem e retorna a região de interesse
    """
    # Converter para escala de cinza
    gray = cv2.cvtColor(imagem, 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,
        cv2.HOUGH_GRADIENT,
        dp=1,
        minDist=50,
        param1=50,
        param2=30,
        minRadius=50,
        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

def analisar_textura(roi):
    """
    Analisa a textura da íris para identificar padrões
    """
    if roi 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
    
    if mean_intensity < 100:
        padroes["deficiencia_hipofuncao"] = True
    
    if contrast < 30:
        padroes["atrofia_degeneracao"] = True
    
    if edge_density > 0.1:
        padroes["irritacao_estresse"] = True
    
    return padroes

def analisar_setores(roi, centro, raio):
    """
    Analisa diferentes setores da íris
    """
    if roi is None:
        return {}
    
    setores = {
        "superior": (315, 45),    # Cérebro
        "direito": (45, 135),     # Fígado
        "inferior": (135, 225),   # Sistema Digestivo
        "esquerdo": (225, 315)    # Coração
    }
    
    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, 
                   -1)
        
        # Aplicar máscara
        setor_roi = cv2.bitwise_and(roi, roi, mask=mask)
        
        # Analisar textura do setor
        resultados[setor] = analisar_textura(setor_roi)
    
    return resultados

def gerar_diagnostico(padroes, setores):
    """
    Gera diagnóstico baseado nos padrões encontrados
    """
    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"
        ]
    }
    
    # Analisar padrões gerais
    for padrao, presente in padroes.items():
        if presente:
            diagnostico.extend(mapa_condicoes[padrao])
    
    # 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]}")
    
    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)
    
    # 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."
    
    # Analisar padrões gerais
    padroes = analisar_textura(roi)
    
    # Analisar setores
    setores = analisar_setores(roi, (x, y), r)
    
    # 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)

def criar_interface():
    """
    Cria interface moderna do Gradio
    """
    # Tema personalizado 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",
    )
    
    # Interface
    with gr.Blocks(theme=theme, title="Análise Iridológica por Imagem") as interface:
        gr.Markdown("""
        # Sistema Avançado de Análise Iridológica
        ### Análise automatizada de imagens da íris
        """)
        
        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="pil"
                        )
                    with gr.Column():
                        output_image = gr.Image(
                            label="Íris Analisada"
                        )
                
                analysis_btn = gr.Button("Analisar Íris", variant="primary")
                output_text = gr.Textbox(
                    label="Diagnóstico",
                    lines=10
                )
                
                analysis_btn.click(
                    fn=processar_imagem,
                    inputs=[input_image],
                    outputs=[output_image, output_text]
                )
            
            # Aba de Guia
            with gr.Tab("Guia de Interpretação"):
                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
                
                ### 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
                
                2. **Posicionamento**
                   - Olho bem aberto
                   - Câmera estável
                   - Distância adequada
                
                3. **Momento**
                   - Evite olhos irritados
                   - Preferencialmente pela manhã
                   - Após descanso
                """)
    
    return interface

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