app.py

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

def analisar_condicoes(regiao, dados):
    """
    Analisa e sumariza as condições encontradas para cada região
    """
    condicoes = defaultdict(int)
    for dado in dados:
        for linha in dado.split('\n'):
            if f'Região: {regiao}' in linha:
                if 'congestão/inflamação' in linha:
                    condicoes['congestao_inflamacao'] += 1
                if 'deficiência/hipofunção' in linha:
                    condicoes['deficiencia_hipofuncao'] += 1
                if 'atrofia/degeneração' in linha:
                    condicoes['atrofia_degeneracao'] += 1
                if 'irritação/estresse' in linha:
                    condicoes['irritacao_estresse'] += 1
    return condicoes

def gerar_diagnostico(regiao, condicoes, total_ocorrencias):
    """
    Gera um diagnóstico baseado na frequência das condições
    """
    diagnostico = []
    limiar = total_ocorrencias * 0.3  # 30% de ocorrências como limiar
    
    if condicoes['congestao_inflamacao'] > limiar:
        diagnostico.append("Processo inflamatório crônico")
    if condicoes['deficiencia_hipofuncao'] > limiar:
        diagnostico.append("Função reduzida ou comprometida")
    if condicoes['atrofia_degeneracao'] > limiar:
        diagnostico.append("Sinais de desgaste tecidual")
    if condicoes['irritacao_estresse'] > limiar:
        diagnostico.append("Sobrecarga funcional")
    
    return diagnostico

def processar_analise_iridologica(dados_analise):
    """
    Processa os dados da análise iridológica e gera um relatório estruturado
    """
    # Identificar todas as regiões únicas
    regioes = set()
    for linha in dados_analise.split('\n'):
        if linha.startswith('Região: '):
            regiao = linha.split('Região: ')[1].strip()
            regioes.add(regiao)
    
    # Analisar cada região
    resultados = {}
    for regiao in regioes:
        condicoes = analisar_condicoes(regiao, [dados_analise])
        diagnostico = gerar_diagnostico(regiao, condicoes, len(dados_analise.split('\n')))
        if diagnostico:
            resultados[regiao] = diagnostico
    
    return resultados

def gerar_recomendacoes(diagnostico):
    """
    Gera recomendações baseadas no diagnóstico
    """
    recomendacoes = {
        "Processo inflamatório crônico": [
            "Avaliação médica específica para a região",
            "Considerar anti-inflamatórios naturais",
            "Reduzir alimentos inflamatórios",
            "Aumentar consumo de água"
        ],
        "Função reduzida ou comprometida": [
            "Suplementação nutricional específica",
            "Avaliação de deficiências nutricionais",
            "Ajuste na dieta para suporte funcional",
            "Exercícios apropriados para estimulação"
        ],
        "Sinais de desgaste tecidual": [
            "Suporte nutricional para regeneração",
            "Redução de fatores estressantes",
            "Avaliação de minerais e vitaminas",
            "Considerar terapias regenerativas"
        ],
        "Sobrecarga funcional": [
            "Técnicas de gerenciamento de estresse",
            "Adequação do ritmo de atividades",
            "Suporte adaptogênico",
            "Melhoria da qualidade do sono"
        ]
    }
    return recomendacoes

def criar_interface():
    """
    Cria a interface do usuário com Gradio
    """
    def analisar(texto_analise):
        resultados = processar_analise_iridologica(texto_analise)
        recomendacoes = gerar_recomendacoes(resultados)
        
        # Formatar saída
        saida = "ANÁLISE IRIDOLÓGICA DETALHADA\n\n"
        
        # Agrupar por sistemas
        sistemas = {
            "Sistema Nervoso": ["Cerebro", "Sistema Nervoso"],
            "Sistema Digestivo": ["Estomago", "Figado", "Vesicula", "Pancreas", "Sistema Digestivo", 
                                "Intestino Grosso", "Intestino Delgado", "Apendice"],
            "Sistema Circulatório": ["Coracao"],
            "Sistema Urinário": ["Rim Direito", "Rim Esquerdo", "Bexiga"],
            "Sistema Endócrino": ["Tireoide"],
            "Sistema Respiratório": ["Pulmao", "Bronquios"],
            "Sistema Reprodutor": ["Sistema Reprodutor"]
        }
        
        for sistema, orgaos in sistemas.items():
            saida += f"\n{sistema.upper()}:\n"
            encontrado = False
            for orgao in orgaos:
                if orgao in resultados:
                    encontrado = True
                    saida += f"\n• {orgao}:\n"
                    for diagnostico in resultados[orgao]:
                        saida += f"  - {diagnostico}\n"
                        if diagnostico in recomendacoes:
                            saida += "    Recomendações:\n"
                            for rec in recomendacoes[diagnostico]:
                                saida += f"    * {rec}\n"
            if not encontrado:
                saida += "  Sem alterações significativas\n"
        
        return saida

    # Interface
    with gr.Blocks(title="Análise Iridológica Avançada") as interface:
        gr.Markdown("""
        # Sistema de Análise Iridológica Avançada
        Este sistema analisa os dados iridológicos e fornece um relatório detalhado com recomendações.
        """)
        
        with gr.Tabs():
            with gr.Tab("Análise Completa"):
                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 Dados", variant="primary")
                output_text = gr.Textbox(
                    label="Relatório de Análise",
                    lines=30
                )
                
                analysis_btn.click(
                    fn=analisar,
                    inputs=[input_text],
                    outputs=[output_text]
                )
            
            with gr.Tab("Informações"):
                gr.Markdown("""
                ## Sobre a Análise Iridológica Avançada
                
                Este sistema utiliza algoritmos avançados para:
                
                1. Analisar padrões nas observações iridológicas
                2. Identificar tendências e correlações
                3. Gerar recomendações personalizadas
                4. Agrupar resultados por sistemas corporais
                
                ### Interpretação dos Resultados
                
                O sistema considera quatro principais categorias de alterações:
                
                * Processos inflamatórios crônicos
                * Funções reduzidas ou comprometidas
                * Sinais de desgaste tecidual
                * Sobrecargas funcionais
                
                ### Observações Importantes
                
                * Os resultados são baseados em análise estatística das observações
                * As recomendações são gerais e devem ser personalizadas por profissional
                * Este é um sistema de suporte à decisão, não um diagnóstico definitivo
                """)
    
    return interface

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