Update app.py

app.py

@@ -3,260 +3,193 @@ import cv2
 import numpy as np
 from PIL import Image
 import io
+from collections import defaultdict
 
-# Dicionário de áreas da íris e suas correlações com órgãos/sistemas
-MAPA_IRIDOLOGICO = {
-    "superior": {
-        "cerebro": (330, 30),
-        "sistema_nervoso": (0, 30),
-    },
-    "superior_direito": {
-        "pulmao": (30, 60),
-        "bronquios": (45, 60),
-    },
-    "direito": {
-        "figado": (60, 120),
-        "vesicula": (75, 120),
-        "rim_direito": (90, 120),
-    },
-    "inferior_direito": {
-        "intestino_grosso": (120, 150),
-        "apendice": (135, 150),
-    },
-    "inferior": {
-        "sistema_digestivo": (150, 210),
-        "intestino_delgado": (180, 210),
-    },
-    "inferior_esquerdo": {
-        "bexiga": (210, 240),
-        "sistema_reprodutor": (225, 240),
-    },
-    "esquerdo": {
-        "estomago": (240, 300),
-        "pancreas": (255, 300),
-        "rim_esquerdo": (270, 300),
-    },
-    "superior_esquerdo": {
-        "coracao": (300, 330),
-        "tireoide": (315, 330),
-    }
-}
+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 analisar_caracteristicas_iris(roi, setor):
+def gerar_diagnostico(regiao, condicoes, total_ocorrencias):
     """
-    Analisa características específicas de um setor da íris
+    Gera um diagnóstico baseado na frequência das condições
     """
-    if roi.size == 0:
-        return []
-    
-    media = np.mean(roi)
-    std = np.std(roi)
-    
-    # Análise de padrões específicos
-    alteracoes = []
-    
-    # Análise de densidade
-    if media < 85:  # Área escura
-        alteracoes.append("Possível congestão/inflamação")
-    elif media > 170:  # Área clara
-        alteracoes.append("Possível deficiência/hipofunção")
-        
-    # Análise de textura
-    if std > 45:  # Alta variação
-        alteracoes.append("Sinais de irritação/estresse")
-    elif std < 15:  # Baixa variação
-        alteracoes.append("Possível atrofia/degeneração")
-        
-    return alteracoes
+    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 analisar_iris(imagem):
+def processar_analise_iridologica(dados_analise):
     """
-    Realiza análise completa da íris com foco em indicadores de saúde
+    Processa os dados da análise iridológica e gera um relatório estruturado
     """
-    # Converter para array numpy
-    img_array = np.array(imagem)
-    
-    # Converter para escala de cinza
-    gray = cv2.cvtColor(img_array, cv2.COLOR_RGB2GRAY)
-    
-    # Detectar círculos (íris)
-    circles = cv2.HoughCircles(
-        gray,
-        cv2.HOUGH_GRADIENT,
-        dp=1,
-        minDist=50,
-        param1=50,
-        param2=30,
-        minRadius=20,
-        maxRadius=100
-    )
-    
-    output = img_array.copy()
-    analise_detalhada = []
-    
-    if circles is not None:
-        circles = np.uint16(np.around(circles))
-        for i in circles[0, :]:
-            center = (i[0], i[1])
-            radius = i[2]
-            
-            # Desenhar círculo da íris
-            cv2.circle(output, center, radius, (0, 255, 0), 2)
-            
-            # Análise por setores
-            for setor, orgaos in MAPA_IRIDOLOGICO.items():
-                for orgao, (ang_inicio, ang_fim) in orgaos.items():
-                    # Criar máscara para o setor
-                    mask = np.zeros_like(gray)
-                    cv2.ellipse(mask, center, (radius, radius), 0, ang_inicio, ang_fim, 255, -1)
-                    
-                    # Região de interesse
-                    roi = cv2.bitwise_and(gray, gray, mask=mask)
-                    
-                    # Analisar características
-                    alteracoes = analisar_caracteristicas_iris(roi[roi != 0], setor)
-                    
-                    if alteracoes:
-                        # Desenhar indicador no setor
-                        ang_medio = np.radians((ang_inicio + ang_fim) / 2)
-                        pt_x = int(center[0] + (radius * 0.8) * np.cos(ang_medio))
-                        pt_y = int(center[1] + (radius * 0.8) * np.sin(ang_medio))
-                        cv2.circle(output, (pt_x, pt_y), 3, (0, 0, 255), -1)
-                        
-                        # Adicionar à análise
-                        orgao_formatado = orgao.replace("_", " ").title()
-                        analise_detalhada.append(f"\nRegião: {orgao_formatado}")
-                        for alt in alteracoes:
-                            analise_detalhada.append(f"- {alt}")
-    
-    return output, "\n".join(analise_detalhada)
+    # 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_relatorio_saude(imagem, nome_paciente, idade, data_analise, sintomas):
+def gerar_recomendacoes(diagnostico):
     """
-    Gera relatório completo com análise de saúde
+    Gera recomendações baseadas no diagnóstico
     """
-    resultado_imagem, analise = analisar_iris(imagem)
-    
-    relatorio = f"""
-    RELATÓRIO DE ANÁLISE IRIDOLÓGICA - AVALIAÇÃO DE SAÚDE
-    
-    Data: {data_analise}
-    
-    DADOS DO PACIENTE
-    Nome: {nome_paciente}
-    Idade: {idade}
-    
-    SINTOMAS RELATADOS
-    {sintomas}
-    
-    ANÁLISE IRIDOLÓGICA DETALHADA
-    {analise}
-    
-    OBSERVAÇÕES IMPORTANTES
-    - Esta análise é baseada em princípios da iridologia
-    - Os resultados são indicativos e não substituem diagnóstico médico
-    - Recomenda-se consulta com profissionais de saúde para avaliação completa
-    - Alterações identificadas podem ter diferentes significados clínicos
+    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():
     """
-    
-    return resultado_imagem, relatorio
+    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
 
-def main():
-    # Configuração do tema moderno
-    theme = gr.themes.Soft(
-        primary_hue="teal",
-        secondary_hue="indigo",
-    ).set(
-        body_background_fill="*neutral_50",
-        block_background_fill="*neutral_100",
-        button_primary_background_fill="*primary_500",
-        button_primary_background_fill_dark="*primary_600",
-    )
-    
-    # Interface principal
-    with gr.Blocks(theme=theme, title="Análise Iridológica - Avaliação de Saúde") as iface:
+    # Interface
+    with gr.Blocks(title="Análise Iridológica Avançada") as interface:
         gr.Markdown("""
-        # Sistema Avançado de Análise Iridológica
-        ### Avaliação de Indicadores de Saúde através da Íris
+        # 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():
-            # Aba de Análise Rápida
-            with gr.Tab("Análise Rápida"):
-                with gr.Row():
-                    with gr.Column():
-                        input_image = gr.Image(label="Upload da Imagem da Íris", type="pil")
-                        analyze_btn = gr.Button("Analisar Íris", variant="primary")
-                    
-                    with gr.Column():
-                        output_image = gr.Image(label="Íris Analisada")
-                        output_text = gr.Textbox(label="Indicadores Identificados", lines=10)
-                
-                analyze_btn.click(
-                    fn=analisar_iris,
-                    inputs=[input_image],
-                    outputs=[output_image, output_text]
+            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
                 )
-            
-            # Aba de Relatório Detalhado
-            with gr.Tab("Relatório Detalhado"):
-                with gr.Row():
-                    with gr.Column():
-                        nome_input = gr.Textbox(label="Nome do Paciente")
-                        idade_input = gr.Number(label="Idade", minimum=0, maximum=120)
-                        data_input = gr.Textbox(label="Data da Análise")
-                        sintomas_input = gr.Textbox(label="Sintomas Relatados", lines=3)
-                        report_image = gr.Image(label="Imagem da Íris", type="pil")
-                        report_btn = gr.Button("Gerar Relatório Completo", variant="primary")
-                    
-                    with gr.Column():
-                        report_output_image = gr.Image(label="Íris Analisada")
-                        report_output = gr.Textbox(label="Relatório de Saúde", lines=15)
                 
-                report_btn.click(
-                    fn=gerar_relatorio_saude,
-                    inputs=[report_image, nome_input, idade_input, data_input, sintomas_input],
-                    outputs=[report_output_image, report_output]
+                analysis_btn.click(
+                    fn=analisar,
+                    inputs=[input_text],
+                    outputs=[output_text]
                 )
             
-            # Aba de Referência
-            with gr.Tab("Guia de Referência"):
+            with gr.Tab("Informações"):
                 gr.Markdown("""
-                ## Guia de Interpretação Iridológica
+                ## Sobre a Análise Iridológica Avançada
                 
-                ### Significados das Análises
-                - Áreas Escuras: Podem indicar congestão ou inflamação
-                - Áreas Claras: Podem indicar deficiência ou hipofunção
-                - Texturas Irregulares: Podem indicar irritação ou estresse
-                - Marcas Radiais: Podem indicar tensão ou sobrecarga
+                Este sistema utiliza algoritmos avançados para:
                 
-                ### Regiões da Íris e Correlações
-                1. Região Superior
-                   - Cérebro e Sistema Nervoso
+                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
                 
-                2. Região Direita
-                   - Fígado
-                   - Vesícula Biliar
-                   - Rim Direito
+                ### Interpretação dos Resultados
                 
-                3. Região Inferior
-                   - Sistema Digestivo
-                   - Intestinos
+                O sistema considera quatro principais categorias de alterações:
                 
-                4. Região Esquerda
-                   - Coração
-                   - Estômago
-                   - Rim Esquerdo
+                * Processos inflamatórios crônicos
+                * Funções reduzidas ou comprometidas
+                * Sinais de desgaste tecidual
+                * Sobrecargas funcionais
                 
                 ### Observações Importantes
-                - A análise iridológica é uma ferramenta complementar
-                - Não substitui diagnósticos médicos convencionais
-                - Deve ser usada em conjunto com outros métodos de avaliação
-                - Consulte sempre profissionais de saúde qualificados
+                
+                * 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
                 """)
     
-    # Iniciar a interface
-    iface.launch(share=True)
+    return interface
 
 if __name__ == "__main__":
-    main()
+    interface = criar_interface()
+    interface.launch(share=True)