Update app.py

app.py

@@ -1,161 +1,144 @@
 import gradio as gr
 import numpy as np
-import plotly.graph_objects as go
+import matplotlib.pyplot as plt
+from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.animation import FuncAnimation
 import math
 from scipy.special import comb
+import random
+import json
 
-# --- Funções Matemáticas (Adaptadas para 3D) ---
-
+# --- Funções Matemáticas (as mesmas que já dominamos) ---
 def bernstein_poly(i, n, t):
-    """ O polinômio de Bernstein (base para Bézier). """
     return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 
 def bezier_curve_3d(points, n_times=100):
-    """ Gera uma curva de Bézier 3D a partir de pontos de controle. """
     n_points = len(points)
-    x_points = np.array([p[0] for p in points])
-    y_points = np.array([p[1] for p in points])
-    z_points = np.array([p[2] for p in points])
+    x_points, y_points, z_points = np.array([p[0] for p in points]), np.array([p[1] for p in points]), np.array([p[2] for p in points])
     t = np.linspace(0.0, 1.0, n_times)
     polynomial_array = np.array([bernstein_poly(i, n_points - 1, t) for i in range(n_points)])
-    x_vals = np.dot(x_points, polynomial_array)
-    y_vals = np.dot(y_points, polynomial_array)
-    z_vals = np.dot(z_points, polynomial_array)
+    x_vals, y_vals, z_vals = np.dot(x_points, polynomial_array), np.dot(y_points, polynomial_array), np.dot(z_points, polynomial_array)
     return x_vals, y_vals, z_vals
 
-def aprender_com_o_eco_3d(pontos_do_eco: list) -> dict:
-    """ Calcula a essência do movimento 3D (vetor) do eco. """
-    if len(pontos_do_eco) < 2:
-        return {"velocity_vector": np.array([0, 0, 0])}
+def aprender_com_o_eco_3d(pontos_do_eco: list):
+    if len(pontos_do_eco) < 2: return {"velocity_vector": np.array([0, 0, 0])}
     p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
-    vetor_velocidade = p2 - p1
-    return {"velocity_vector": vetor_velocidade}
+    return {"velocity_vector": p2 - p1}
 
-# --- Função Principal do Gradio (O Laboratório 3D Interativo) ---
+# --- Função Principal do Gradio (O Gerador de Ciclos) ---
 
-def gerar_grafico_3d_dinamico(
-    inflexao1_x, inflexao1_y, inflexao1_z,
-    inflexao2_x, inflexao2_y, inflexao2_z,
-    eco_vetores
-):
+def gerar_proximo_ciclo(estado_anterior_json: str, progress=gr.Progress(track_tqdm=True)):
     """
-    Gera e plota a jornada 3D completa com base nos inputs da UI.
+    Gera um único trecho da jornada (de A para B) e o renderiza como um vídeo.
     """
-    # 1. DEFINIÇÃO DOS PONTOS DA JORNADA
-    p1_inicio = np.array([0, 0, 0])
-    p2_inflexao1 = np.array([inflexao1_x, inflexao1_y, inflexao1_z])
-    p3_inflexao2 = np.array([inflexao2_x, inflexao2_y, inflexao2_z])
-    p4_encontro = np.array([75, 45, 10])
-    
-    # Para o loop, o destino final deve ser o ponto de início.
-    p5_destino = p1_inicio
-    
-    # 2. GERAR A CURVA DA CRIANÇA A
-    pontos_curva_a = [p1_inicio, p2_inflexao1, p3_inflexao2, p4_encontro]
-    x_a, y_a, z_a = bezier_curve_3d(pontos_curva_a)
-    caminho_a = list(zip(x_a, y_a, z_a))
-
-    # 3. APRENDER COM O ECO
-    num_eco = int(eco_vetores)
-    if num_eco < 2: num_eco = 2
-    pontos_do_eco = caminho_a[-num_eco:]
-    vetor_aprendido = aprender_com_o_eco_3d(pontos_do_eco)["velocity_vector"]
-
-    # 4. GERAR A CURVA DA CRIANÇA B
-    ponto_controle_b = p4_encontro + vetor_aprendido
-    ponto_inflexao_retorno = p1_inicio - vetor_aprendido * 0.5
-    pontos_curva_b = [p4_encontro, ponto_controle_b, ponto_inflexao_retorno, p5_destino]
-    x_b, y_b, z_b = bezier_curve_3d(pontos_curva_b)
-
-    # 5. PREPARAR DADOS PARA O PLOTLY
-    
-    # Caminho A
-    trace_a = go.Scatter3d(x=x_a, y=y_a, z=z_a, mode='lines', line=dict(color='cyan', width=5), name='Caminho A (Passado)')
-    
-    # Caminho B
-    trace_b = go.Scatter3d(x=x_b, y=y_b, z=z_b, mode='lines', line=dict(color='lime', width=5, dash='dash'), name='Caminho B (Convergência)')
-    
-    # Eco de Memória
-    x_eco, y_eco, z_eco = zip(*pontos_do_eco)
-    trace_eco = go.Scatter3d(x=x_eco, y=y_eco, z=z_eco, mode='lines', line=dict(color='magenta', width=10), name=f'Eco de Memória ({num_eco} vetores)')
+    progress(0, desc="Decodificando estado anterior...")
     
-    # Pontos de Controle e Waypoints
-    pontos_controle = np.array([p1_inicio, p2_inflexao1, p3_inflexao2, p4_encontro, ponto_controle_b, ponto_inflexao_retorno, p5_destino])
-    trace_controle = go.Scatter3d(x=pontos_controle[:,0], y=pontos_controle[:,1], z=pontos_controle[:,2], mode='markers', marker=dict(color='lightcoral', size=5), name='Estrutura de Controle')
+    # 1. Carrega o estado do ciclo anterior (ou cria um novo se for o primeiro)
+    if estado_anterior_json:
+        estado = json.loads(estado_anterior_json)
+        ponto_a = np.array(estado["ponto_b"]) # O destino se torna a origem
+        vetor_inercia_anterior = np.array(estado["vetor_inercia"])
+    else: # Primeiro ciclo
+        ponto_a = np.array([0., 0., 0.])
+        vetor_inercia_anterior = np.array([10., 10., 10.])
+
+    progress(0.1, desc="Gerando novo checkpoint aleatório...")
+    # 2. Gera um novo destino (Ponto B)
+    ponto_b = np.random.rand(3) * 120 - 60
+
+    progress(0.2, desc="Calculando trajetória com convergência...")
+    # 3. Calcula a nova trajetória
+    ponto_controle = ponto_a + vetor_inercia_anterior
+    pontos_curva = [ponto_a, ponto_controle, ponto_b]
+    x_traj, y_traj, z_traj = bezier_curve_3d(pontos_curva, n_times=120) # 120 frames
+    total_frames = len(x_traj)
+
+    # 4. Aprende o "eco" para o próximo ciclo
+    tamanho_eco = 30
+    pontos_eco = list(zip(x_traj[-tamanho_eco:], y_traj[-tamanho_eco:], z_traj[-tamanho_eco:]))
+    vetor_inercia_novo = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
+
+    # 5. Salva o novo estado para o próximo clique do botão
+    estado_novo = {
+        "ponto_a": ponto_a.tolist(),
+        "ponto_b": ponto_b.tolist(),
+        "vetor_inercia": vetor_inercia_novo.tolist()
+    }
+    estado_novo_json = json.dumps(estado_novo)
+
+    # 6. Setup da Animação
+    fig = plt.figure(figsize=(8, 8)); ax = fig.add_subplot(111, projection='3d')
+    fig.patch.set_facecolor('#111111'); ax.set_facecolor('#111111')
     
-    waypoints = np.array([p1_inicio, p4_encontro])
-    trace_waypoints = go.Scatter3d(x=waypoints[:,0], y=waypoints[:,1], z=waypoints[:,2], mode='markers', marker=dict(color=['cyan', 'yellow'], size=12, symbol=['circle', 'diamond']), name='Waypoints (Início/Encontro)')
-
-    # 6. CRIAR A FIGURA PLOTLY
-    layout = go.Layout(
-        title=dict(text='Laboratório de Continuidade Causal 3D', font=dict(color='white')),
-        scene=dict(
-            xaxis_title='Eixo X',
-            yaxis_title='Eixo Y',
-            zaxis_title='Eixo Z',
-            xaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
-            yaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
-            zaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
-            bgcolor='#111111'
-        ),
-        paper_bgcolor='#111111',
-        legend=dict(font=dict(color='white'))
-    )
-    
-    fig = go.Figure(data=[trace_a, trace_b, trace_eco, trace_controle, trace_waypoints], layout=layout)
-    
-    info_vetor = f"Vetor de Inércia Aprendido: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f}, {vetor_aprendido[2]:.2f})"
+    bola, = ax.plot([], [], [], 'o', color='red', markersize=10, markeredgecolor='white')
+    ax.set_xlim(-70, 70); ax.set_ylim(-70, 70); ax.set_zlim(-70, 70)
+    ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
+
+    def update(frame):
+        # Desenha a cena estática em cada frame
+        ax.cla() # Limpa o eixo para redesenhar
+        ax.set_xlim(-70, 70); ax.set_ylim(-70, 70); ax.set_zlim(-70, 70)
+        ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
+        ax.plot(x_traj, y_traj, z_traj, color='cyan', linewidth=2, alpha=0.5)
+        ax.scatter(*ponto_a, s=400, c='lime', alpha=0.7, label='Ponto A (Início)')
+        ax.scatter(*ponto_b, s=400, c='yellow', marker='X', alpha=0.7, label='Ponto B (Destino)')
+        
+        # Anima a bola
+        bola.set_data_3d([x_traj[frame]], [y_traj[frame]], [z_traj[frame]])
+        ax.view_init(elev=30., azim=frame * 0.7)
+        return bola,
+
+    # 7. Renderiza e Salva o Vídeo
+    progress(0.5, desc="Renderizando animação do ciclo...")
+    ani = FuncAnimation(fig, update, frames=total_frames, interval=33, blit=False)
+    output_filename = "ciclo_atual.mp4"
+    ani.save(output_filename, writer='ffmpeg', fps=30, dpi=100, progress_callback=lambda i, n: progress(0.5 + 0.5 * (i/n), desc=f"Renderizando frame {i+1}/{n}"))
+    plt.close(fig)
+
+    info_ciclo = f"Ciclo Concluído.\nInício (A): {np.round(ponto_a, 1)}\nDestino (B): {np.round(ponto_b, 1)}\nInércia Aprendida: {np.round(vetor_inercia_novo, 1)}"
     
-    return fig, info_vetor
+    return output_filename, estado_novo_json, info_ciclo
 
 # --- Interface Gradio ---
 
-with gr.Blocks(theme=gr.themes.Base(primary_hue="green", secondary_hue="blue")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="lime")) as demo:
     gr.Markdown(
         """
-        # 🔬 Laboratório de Continuidade Causal 3D Interativo
-        Molde a trajetória no espaço! Use os sliders para definir os pontos de inflexão da "Criança A".
-        O sistema irá aprender a inércia (vetor de movimento) a partir do "Eco de Memória" (em magenta) e projetar a trajetória contínua da "Criança B" de volta ao início, formando um loop.
-        **Use o mouse para girar e dar zoom no gráfico 3D.**
+        # 🌀 Simulador de Convergência Causal 3D Interativo
+        Clique em "Gerar Próximo Ciclo" para ver o agente (bola vermelha) viajar do checkpoint A (verde) para um novo checkpoint B (amarelo) aleatório.
+        A trajetória é guiada pela inércia aprendida do ciclo anterior. Cada clique gera a continuação da jornada.
         """
     )
     
     with gr.Row():
         with gr.Column(scale=1):
-            gr.Markdown("### 🎮 Controles da Simulação")
+            gr.Markdown("### ��� Controles")
+            # O estado é armazenado em um Textbox invisível
+            estado_oculto = gr.Textbox(label="Estado da Simulação (JSON)", interactive=True, visible=False)
             
-            with gr.Accordion("Definir Ponto de Inflexão 1", open=True):
-                inflexao1_x = gr.Slider(-50, 150, value=25, label="Posição X")
-                inflexao1_y = gr.Slider(-50, 150, value=60, label="Posição Y")
-                inflexao1_z = gr.Slider(-50, 150, value=50, label="Posição Z (Altura)")
-
-            with gr.Accordion("Definir Ponto de Inflexão 2", open=True):
-                inflexao2_x = gr.Slider(-50, 150, value=60, label="Posição X")
-                inflexao2_y = gr.Slider(-50, 150, value=20, label="Posição Y")
-                inflexao2_z = gr.Slider(-50, 150, value=-30, label="Posição Z (Altura)")
+            info_output = gr.Textbox(label="Dados do Ciclo Atual", lines=4, interactive=False)
             
-            with gr.Accordion("Configurações do Aprendizado", open=True):
-                eco_input = gr.Slider(2, 100, value=50, step=1, label="Tamanho do Eco de Memória (Nº de Vetores)")
+            # Botão para iniciar o primeiro ciclo (sem estado anterior)
+            start_btn = gr.Button("🚀 Iniciar Simulação (Primeiro Ciclo)", variant="primary")
+            # Botão para continuar a simulação (usa o estado anterior)
+            next_btn = gr.Button("➡️ Gerar Próximo Ciclo", variant="secondary")
             
-            info_output = gr.Textbox(label="Dados do Aprendizado (Calculado)", interactive=False)
-
-        with gr.Column(scale=3):
-            gr.Markdown("### 📊 Visualização da Jornada 3D")
-            # Usamos gr.Plot para renderizar a figura do Plotly
-            plot_output = gr.Plot()
-
-    inputs = [
-        inflexao1_x, inflexao1_y, inflexao1_z,
-        inflexao2_x, inflexao2_y, inflexao2_z,
-        eco_input
-    ]
-    
-    # Conecta todos os sliders à função para atualização em tempo real
-    for component in inputs:
-        component.change(fn=gerar_grafico_3d_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+        with gr.Column(scale=2):
+            gr.Markdown("### 📽️ Visualização do Ciclo")
+            video_output = gr.Video(label="Animação do Ciclo Atual", autoplay=True)
+
+    # Conexões dos botões
+    start_btn.click(
+        fn=lambda: gerar_proximo_ciclo(None), # Passa None para indicar o primeiro ciclo
+        inputs=None,
+        outputs=[video_output, estado_oculto, info_output]
+    )
     
-    # Carga inicial do aplicativo
-    demo.load(fn=gerar_grafico_3d_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+    next_btn.click(
+        fn=gerar_proximo_ciclo,
+        inputs=[estado_oculto],
+        outputs=[video_output, estado_oculto, info_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()