Update app.py

app.py

@@ -1,3 +1,4 @@
+import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 import math
@@ -29,55 +30,41 @@ def aprender_com_o_eco(pontos_do_eco: list) -> dict:
     bearing_radianos = math.atan2(vetor_velocidade[1], vetor_velocidade[0])
     return {"bearing_rad": bearing_radianos, "velocity_vector": vetor_velocidade}
 
-# --- Simulação com os Dados de Entrada Fornecidos ---
+# --- Função Principal do Gradio (A Interface do Laboratório) ---
 
-def simular_jornada_especifica():
+def gerar_grafico_dinamico(destino_x, destino_y, eco_vetores):
     """
-    Executa a simulação com os pontos-chave definidos pelo Arquiteto
-    e plota o resultado.
+    Gera e plota a jornada com o caminho da Criança A fixo
+    e o destino da Criança B dinâmico.
     """
     # 1. DEFINIÇÃO DOS PONTOS DA JORNADA
-    # A trajetória da Criança A é definida por estes 4 vetores (pontos)
-    p1 = np.array([0, 0])      # Vetor x1, y=0
-    p2 = np.array([25, 15])     # Vetor x2, y=15 (Assumindo um X para visualização)
-    p3 = np.array([50, 30])     # Vetor x3, y=30 (Assumindo um X para visualização)
-    p4_encontro = np.array([75, 45]) # Vetor x4, y=45 (Ponto de Handover)
-
-    # O destino da Criança B
-    p5_destino = np.array([100, 90]) # Vetor final, y=90 (Assumindo um X para o destino)
-    
-    # Número de pontos a serem usados como "eco de memória"
-    NUMERO_DE_VETORES_ECO = 150 # Equivalente a 15% de 1000 pontos
+    # Caminho da Criança A é fixo e representa o passado
+    p1 = np.array([0, 0])
+    p2 = np.array([25, 15])
+    p3 = np.array([50, 30])
+    p4_encontro = np.array([75, 45])
     
-    print(f"--- DADOS DE ENTRADA ---")
-    print(f"Caminho da Criança A definido por: {p1}, {p2}, {p3}, {p4_encontro}")
-    print(f"Destino da Criança B: {p5_destino}")
-    print(f"Número de vetores no Eco de Memória: {NUMERO_DE_VETORES_ECO}")
-    print("------------------------\n")
+    # Destino da Criança B é dinâmico, vindo da UI
+    p5_destino = np.array([destino_x, destino_y])
     
-    # 2. GERAR A CURVA DA CRIANÇA A
-    # Usamos os 4 pontos para criar uma curva de Bézier cúbica, mais complexa.
+    # 2. GERAR A CURVA FIXA DA CRIANÇA A
     pontos_curva_a = [p1, p2, p3, p4_encontro]
     x_a, y_a = bezier_curve(pontos_curva_a, n_times=1000)
     
     # 3. ISOLAR O ECO
+    NUMERO_DE_VETORES_ECO = int(eco_vetores)
+    if NUMERO_DE_VETORES_ECO < 2: NUMERO_DE_VETORES_ECO = 2
+    
     x_eco = x_a[-NUMERO_DE_VETORES_ECO:]
     y_eco = y_a[-NUMERO_DE_VETORES_ECO:]
     pontos_do_eco = list(zip(x_eco, y_eco))
     
-    # 4. CRIANÇA B APRENDE COM O ECO
+    # 4. CRIANÇA B APRENDE COM O ECO (mesma lógica de sempre)
     essencia_movimento = aprender_com_o_eco(pontos_do_eco)
     vetor_aprendido = essencia_movimento["velocity_vector"]
     
-    print("--- APRENDIZADO DA CRIANÇA B ---")
-    print(f"Vetor de Inércia aprendido no Eco: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f})")
-    print(f"Direção final da Criança A: {math.degrees(essencia_movimento['bearing_rad']):.2f} graus")
-    print("------------------------------\n")
-    
-    # 5. GERAR A CURVA DA CRIANÇA B
-    # O ponto de controle que define a tangente de saída é o ponto de encontro + o vetor aprendido
+    # 5. GERAR A CURVA DINÂMICA DA CRIANÇA B
     ponto_controle_b = p4_encontro + vetor_aprendido
-    # A curva vai do ponto de encontro ao destino, guiada pelo ponto de controle
     pontos_curva_b = [p4_encontro, ponto_controle_b, p5_destino]
     x_b, y_b = bezier_curve(pontos_curva_b, n_times=1000)
     
@@ -86,7 +73,6 @@ def simular_jornada_especifica():
     fig.patch.set_facecolor('black')
     ax.set_facecolor('black')
 
-    # Configuração dos eixos para serem visíveis
     ax.spines['bottom'].set_color('white')
     ax.spines['left'].set_color('white')
     ax.spines['top'].set_color('black')
@@ -94,31 +80,76 @@ def simular_jornada_especifica():
     ax.tick_params(axis='x', colors='white')
     ax.tick_params(axis='y', colors='white')
 
-    # Plot das curvas
-    ax.plot(x_a, y_a, label='Caminho da Criança A', color='cyan', linewidth=2)
-    ax.plot(x_b, y_b, label='Continuidade da Criança B', color='lime', linewidth=2, linestyle='--')
-    
-    # Destaque do Eco
+    ax.plot(x_a, y_a, label='Caminho da Criança A (Passado Fixo)', color='cyan', linewidth=2)
+    ax.plot(x_b, y_b, label='Continuidade da Criança B (Futuro Gerado)', color='lime', linewidth=2, linestyle='--')
     ax.plot(x_eco, y_eco, label=f'Eco de Memória ({NUMERO_DE_VETORES_ECO} vetores)', color='magenta', linewidth=4)
     
-    # Plot dos pontos chave
-    pontos_chave = np.array([p1, p2, p3, p4_encontro, p5_destino])
-    ax.plot(pontos_chave[:,0], pontos_chave[:,1], 'o', color='red', markersize=8, label='Pontos-Chave Definidos')
-    ax.plot(p4_encontro[0], p4_encontro[1], 'o', color='yellow', markersize=10, label='Ponto de Encontro')
+    pontos_chave_a = np.array([p1, p2, p3, p4_encontro])
+    ax.plot(pontos_chave_a[:,0], pontos_chave_a[:,1], 'o', color='gray', markersize=8, label='Controle da Criança A')
+    ax.plot(p4_encontro[0], p4_encontro[1], 'o', color='yellow', markersize=12, markeredgecolor='black', label='Ponto de Encontro')
+    ax.plot(p5_destino[0], p5_destino[1], 'X', color='red', markersize=12, markeredgecolor='white', label='Destino da Criança B (Seu Input)')
 
-    # Títulos e legendas
-    ax.set_title('Demonstração do Teorema da Continuidade', color='white', fontsize=16)
+    ax.set_title('Laboratório de Continuidade Causal', color='white', fontsize=16)
     ax.set_xlabel('Eixo X', color='white', fontsize=12)
     ax.set_ylabel('Eixo Y', color='white', fontsize=12)
-    legend = ax.legend(facecolor='gray', edgecolor='white', framealpha=0.1)
+    legend = ax.legend(facecolor='#111111', edgecolor='white', framealpha=0.5)
     for text in legend.get_texts():
         text.set_color('white')
 
-    ax.grid(True, linestyle='--', color='gray', alpha=0.5)
+    ax.grid(True, linestyle='--', color='gray', alpha=0.3)
     ax.set_aspect('equal', adjustable='box')
     
-    plt.show()
+    caminho_figura = "laboratorio_continuidade.png"
+    plt.savefig(caminho_figura, bbox_inches='tight', pad_inches=0.1, dpi=100, transparent=True)
+    plt.close(fig)
+    
+    # Retorna o caminho da imagem e o vetor aprendido para a UI
+    info_vetor = f"Vetor de Inércia Aprendido: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f}) | Direção: {math.degrees(essencia_movimento['bearing_rad']):.2f}°"
+    
+    return caminho_figura, info_vetor
+
+# --- Interface Gradio ---
+
+with gr.Blocks(theme=gr.themes.Base(primary_hue="teal")) as demo:
+    gr.Markdown(
+        """
+        # 🔬 Laboratório de Continuidade Causal
+        O caminho da "Criança A" (em ciano) é fixo, representando um evento passado.
+        Use os controles para definir o **destino da Criança B** e o **tamanho da memória (eco)**.
+        Observe como o sistema calcula a inércia do passado para gerar uma trajetória futura perfeitamente contínua.
+        """
+    )
+    
+    with gr.Row():
+        with gr.Column(scale=1):
+            gr.Markdown("### 🎮 Controles da Simulação")
+            
+            gr.Markdown("**Defina o Destino da Criança B:**")
+            destino_x_input = gr.Slider(-50, 150, value=100, label="Destino Final (X)")
+            destino_y_input = gr.Slider(-50, 150, value=90, label="Destino Final (Y)")
+            
+            gr.Markdown("**Defina a Memória:**")
+            eco_input = gr.Slider(2, 300, value=150, step=1, label="Nº de Vetores no Eco de Memória")
+            
+            # Botão não é estritamente necessário com live=True, mas é bom ter
+            run_button = gr.Button("Calcular e Gerar Gráfico", variant="primary")
+            
+        with gr.Column(scale=2):
+            gr.Markdown("### 📊 Visualização da Jornada")
+            info_output = gr.Textbox(label="Dados do Aprendizado (Calculado)", interactive=False)
+            plot_output = gr.Image(label="Gráfico da Continuidade", type="filepath")
+
+    # Lista de componentes de entrada para a função
+    inputs = [destino_x_input, destino_y_input, eco_input]
+    
+    # Conecta os sliders e o botão à função
+    for component in inputs:
+        component.change(fn=gerar_grafico_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+    run_button.click(fn=gerar_grafico_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+    
+    # Gera o gráfico inicial ao carregar a página
+    demo.load(fn=gerar_grafico_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+
 
-# --- Execução do Script ---
 if __name__ == "__main__":
-    simular_jornada_especifica()
+    demo.launch()