Update app.py

app.py

@@ -5,200 +5,220 @@ from PIL import Image
 import io
 from collections import defaultdict
 
-# Mapeamento detalhado de sinais para doenças específicas
-SINAIS_DOENÇAS = {
-    "congestao_inflamacao": {
-        "Doenças Autoimunes": {
-            "Artrite Reumatoide": {
-                "prob": 0.75,
-                "sinais_adicionais": ["simetria", "anéis de tensão"],
-                "exames": ["Fator Reumatóide", "Anti-CCP", "PCR", "VHS"],
-                "tratamentos": ["Imunossupressores", "Anti-inflamatórios", "Fisioterapia"]
-            },
-            "Lúpus": {
-                "prob": 0.70,
-                "sinais_adicionais": ["manchas em borboleta", "lacunas"],
-                "exames": ["FAN", "Anti-DNA", "Complemento"],
-                "tratamentos": ["Corticoides", "Antimaláricos", "Protetor Solar"]
-            }
-        },
-        "Doenças Inflamatórias": {
-            "Doença de Crohn": {
-                "prob": 0.65,
-                "sinais_adicionais": ["radiais intestinais", "hiperpigmentação"],
-                "exames": ["Calprotectina", "Colonoscopia", "PCR"],
-                "tratamentos": ["Imunomoduladores", "Biológicos", "Dieta"]
-            }
-        }
-    },
-    "deficiencia_hipofuncao": {
-        "Doenças Endócrinas": {
-            "Hipotireoidismo": {
-                "prob": 0.80,
-                "sinais_adicionais": ["anéis nervosos", "pigmentação clara"],
-                "exames": ["TSH", "T4 livre", "Anti-TPO"],
-                "tratamentos": ["Levotiroxina", "Suplementação de Iodo", "Selenium"]
-            },
-            "Diabetes": {
-                "prob": 0.75,
-                "sinais_adicionais": ["radiais pancreáticos", "manchas açúcar"],
-                "exames": ["Glicemia", "HbA1c", "Peptídeo C"],
-                "tratamentos": ["Insulina", "Metformina", "Dieta"]
-            }
-        }
-    },
-    "atrofia_degeneracao": {
-        "Doenças Neurológicas": {
-            "Alzheimer": {
-                "prob": 0.70,
-                "sinais_adicionais": ["lesões cerebrais", "manchas escuras"],
-                "exames": ["Mini-Mental", "Ressonância", "Beta Amilóide"],
-                "tratamentos": ["Inibidores Colinesterase", "Memantina", "Estimulação"]
-            }
-        },
-        "Doenças Ósseas": {
-            "Osteoporose": {
-                "prob": 0.75,
-                "sinais_adicionais": ["anéis cálcio", "lacunas ósseas"],
-                "exames": ["Densitometria", "Vitamina D", "CTX"],
-                "tratamentos": ["Bisfosfonatos", "Cálcio", "Exercícios"]
-            }
-        }
-    },
-    "irritacao_estresse": {
-        "Doenças Psiquiátricas": {
-            "Ansiedade Generalizada": {
-                "prob": 0.85,
-                "sinais_adicionais": ["anéis nervosos", "manchas adrenal"],
-                "exames": ["Cortisol", "ACTH", "Neurotransmissores"],
-                "tratamentos": ["Ansiolíticos", "Psicoterapia", "Meditação"]
-            },
-            "Depressão": {
-                "prob": 0.80,
-                "sinais_adicionais": ["manchas escuras", "anéis profundos"],
-                "exames": ["Serotonina", "Cortisol", "BDNF"],
-                "tratamentos": ["Antidepressivos", "Psicoterapia", "Exercícios"]
-            }
-        }
+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
 
-# Correlações entre regiões da íris e sistemas corporais
-CORRELAÇÕES_SISTEMAS = {
-    "Cerebro": {
-        "sistema": "Sistema Nervoso Central",
-        "doenças_associadas": [
-            "Enxaqueca", "Epilepsia", "Parkinson",
-            "Esclerose Múltipla", "Alzheimer"
-        ]
-    },
-    "Sistema Nervoso": {
-        "sistema": "Sistema Nervoso Periférico",
-        "doenças_associadas": [
-            "Neuropatia Diabética", "Síndrome do Túnel do Carpo",
-            "Neuralgia do Trigêmeo"
-        ]
-    },
-    "Pulmao": {
-        "sistema": "Sistema Respiratório",
-        "doenças_associadas": [
-            "Asma", "DPOC", "Bronquite Crônica",
-            "Fibrose Pulmonar", "Enfisema"
+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 analisar_doencas(dados_analise):
+def processar_imagem(imagem):
     """
-    Analisa os dados para identificar possíveis doenças
+    Processa a imagem da íris e retorna análise
     """
-    resultados = defaultdict(list)
-    padroes = defaultdict(int)
-    
-    # Análise por região
-    regiao_atual = None
-    sinais_atuais = set()
-    
-    for linha in dados_analise.split('\n'):
-        if 'Região:' in linha:
-            if regiao_atual and sinais_atuais:
-                # Processar região anterior
-                for sinal in sinais_atuais:
-                    if sinal in SINAIS_DOENÇAS:
-                        for categoria, doenças in SINAIS_DOENÇAS[sinal].items():
-                            for doença, info in doenças.items():
-                                resultados[regiao_atual].append({
-                                    'doença': doença,
-                                    'categoria': categoria,
-                                    'probabilidade': info['prob'],
-                                    'exames': info['exames'],
-                                    'tratamentos': info['tratamentos']
-                                })
-            
-            regiao_atual = linha.split('Região:')[1].strip()
-            sinais_atuais = set()
-        
-        if regiao_atual:
-            if 'congestão/inflamação' in linha:
-                sinais_atuais.add('congestao_inflamacao')
-            if 'deficiência/hipofunção' in linha:
-                sinais_atuais.add('deficiencia_hipofuncao')
-            if 'atrofia/degeneração' in linha:
-                sinais_atuais.add('atrofia_degeneracao')
-            if 'irritação/estresse' in linha:
-                sinais_atuais.add('irritacao_estresse')
-    
-    return dict(resultados)
+    # 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 a interface moderna do Gradio com tema verde piscina
+    Cria interface moderna do Gradio
     """
-    def analisar(texto_analise):
-        resultados = analisar_doencas(texto_analise)
-        
-        # Gerar relatório estruturado
-        saida = "ANÁLISE DETALHADA DE DOENÇAS POR IRIDOLOGIA\n\n"
-        
-        # Agrupar por sistemas
-        sistemas = {
-            "Sistema Nervoso": ["Cerebro", "Sistema Nervoso"],
-            "Sistema Digestivo": ["Estomago", "Figado", "Vesicula", "Pancreas", 
-                                "Sistema Digestivo", "Intestino Grosso", "Intestino Delgado"],
-            "Sistema Circulatório": ["Coracao"],
-            "Sistema Respiratório": ["Pulmao", "Bronquios"],
-            "Sistema Endócrino": ["Tireoide"],
-            "Sistema Urinário": ["Rim Direito", "Rim Esquerdo", "Bexiga"]
-        }
-        
-        for sistema, orgaos in sistemas.items():
-            saida += f"\n{sistema.upper()}\n{'='*len(sistema)}\n"
-            
-            doenças_sistema = []
-            for orgao in orgaos:
-                if orgao in resultados:
-                    for resultado in resultados[orgao]:
-                        doenças_sistema.append({
-                            'orgao': orgao,
-                            **resultado
-                        })
-            
-            if doenças_sistema:
-                # Ordenar por probabilidade
-                doenças_sistema.sort(key=lambda x: x['probabilidade'], reverse=True)
-                
-                for doença in doenças_sistema:
-                    prob_percent = doença['probabilidade'] * 100
-                    saida += f"\n• {doença['doença']} ({doença['categoria']})\n"
-                    saida += f"  Órgão: {doença['orgao']}\n"
-                    saida += f"  Probabilidade: {prob_percent:.1f}%\n"
-                    saida += f"  Exames Recomendados: {', '.join(doença['exames'])}\n"
-                    saida += f"  Tratamentos Sugeridos: {', '.join(doença['tratamentos'])}\n"
-            else:
-                saida += "  Sem alterações significativas\n"
-        
-        return saida
-
     # Tema personalizado verde piscina
     theme = gr.themes.Soft(
         primary_hue="teal",
@@ -210,68 +230,63 @@ def criar_interface():
         input_background_fill="#E9F5F3",
         button_primary_background_fill="#2A9D8F",
         button_primary_background_fill_dark="#264653",
-        button_primary_text_color="#FFFFFF",
-        button_primary_text_color_dark="#FFFFFF",
     )
-
-    # Interface com abas
-    with gr.Blocks(theme=theme, title="Análise Avançada de Doenças por Iridologia") as interface:
+    
+    # Interface
+    with gr.Blocks(theme=theme, title="Análise Iridológica por Imagem") as interface:
         gr.Markdown("""
-        # Sistema Avançado de Análise de Doenças por Iridologia
-        ### Análise detalhada com probabilidades e recomendações específicas
+        # Sistema Avançado de Análise Iridológica
+        ### Análise automatizada de imagens da íris
         """)
         
         with gr.Tabs():
-            # Aba de Análise Principal
-            with gr.Tab("Análise de Doenças"):
-                input_text = gr.Textbox(
-                    label="Dados da Análise Iridológica",
-                    lines=10,
-                    placeholder="Cole os dados da análise aqui..."
-                )
-                analysis_btn = gr.Button("Analisar Doenças", variant="primary")
+            # 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="Relatório de Doenças",
-                    lines=30
+                    label="Diagnóstico",
+                    lines=10
                 )
                 
                 analysis_btn.click(
-                    fn=analisar,
-                    inputs=[input_text],
-                    outputs=[output_text]
+                    fn=processar_imagem,
+                    inputs=[input_image],
+                    outputs=[output_image, output_text]
                 )
             
-            # Aba de Interpretação
+            # Aba de Guia
             with gr.Tab("Guia de Interpretação"):
                 gr.Markdown("""
-                ## Interpretação dos Resultados
-                
-                ### Níveis de Probabilidade
-                - **>80%**: Alta probabilidade - Investigação prioritária
-                - **60-80%**: Probabilidade moderada - Investigação recomendada
-                - **40-60%**: Probabilidade média - Monitoramento
-                - **<40%**: Baixa probabilidade - Observação
-                
-                ### Categorias de Doenças Analisadas
-                1. **Doenças Autoimunes**
-                   - Artrite Reumatoide
-                   - Lúpus
-                   - Esclerose Múltipla
+                ## Interpretação dos Sinais
                 
-                2. **Doenças Endócrinas**
-                   - Hipotireoidismo
-                   - Diabetes
-                   - Doença de Addison
+                ### 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
                 
-                3. **Doenças Degenerativas**
-                   - Alzheimer
-                   - Parkinson
-                   - Osteoporose
+                ### 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
                 
-                4. **Doenças Inflamatórias**
-                   - Doença de Crohn
-                   - Colite Ulcerativa
-                   - Artrite
+                ### 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
@@ -279,26 +294,27 @@ def criar_interface():
                 gr.Markdown("""
                 ## Recomendações Gerais
                 
-                ### Exames Complementares
-                - Exames laboratoriais específicos
-                - Exames de imagem
-                - Avaliações funcionais
+                ### Qualidade da Imagem
+                - Resolução mínima: 1280x720
+                - Iluminação uniforme
+                - Foco na íris
+                - Sem reflexos
                 
-                ### Abordagens Terapêuticas
-                1. **Convencionais**
-                   - Medicamentos específicos
-                   - Acompanhamento médico
-                   - Fisioterapia
+                ### Preparação
+                1. **Ambiente**
+                   - Bem iluminado
+                   - Sem luz direta
+                   - Fundo claro
                 
-                2. **Complementares**
-                   - Fitoterapia
-                   - Acupuntura
-                   - Homeopatia
+                2. **Posicionamento**
+                   - Olho bem aberto
+                   - Câmera estável
+                   - Distância adequada
                 
-                3. **Mudanças de Estilo de Vida**
-                   - Alimentação
-                   - Exercícios
-                   - Gestão do estresse
+                3. **Momento**
+                   - Evite olhos irritados
+                   - Preferencialmente pela manhã
+                   - Após descanso
                 """)
     
     return interface