Update app.py

app.py

@@ -8,11 +8,11 @@ from scipy.special import comb
 import random
 import json
 
-# --- Funções Matemáticas (as mesmas que já dominamos) ---
+# --- Funções Matemáticas (Inalteradas) ---
 def bernstein_poly(i, n, t):
     return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 
-def bezier_curve_3d(points, n_times=100):
+def bezier_curve_3d(points, n_times=120): # Fixo em 120 vetores/frames
     n_points = len(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)
@@ -25,32 +25,31 @@ def aprender_com_o_eco_3d(pontos_do_eco: list):
     p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
     return {"velocity_vector": p2 - p1}
 
-# --- Função Principal do Gradio (O Gerador de Ciclos) ---
+# --- Função Principal do Gradio (Gerador de Diagrama Animado) ---
 
-def gerar_proximo_ciclo(estado_anterior_json: str, progress=gr.Progress(track_tqdm=True)):
+def gerar_diagrama_animado(estado_anterior_json: str, angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
     """
-    Gera um único trecho da jornada (de A para B) e o renderiza como um vídeo.
+    Gera um ciclo da jornada com ambiente estático e movimento discreto da bola.
     """
     progress(0, desc="Decodificando estado anterior...")
-    
-    # 1. Carrega o estado do ciclo anterior (ou cria um novo se for o primeiro)
+    # 1. Carrega ou inicializa o estado
     if estado_anterior_json:
         estado = json.loads(estado_anterior_json)
-        ponto_a = np.array(estado["ponto_b"]) # O destino se torna a origem
+        ponto_a = np.array(estado["ponto_b"])
         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.])
+        ponto_a = np.array([-40., 20., 10.])
+        vetor_inercia_anterior = np.array([30., 10., -20.])
 
     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...")
+    progress(0.2, desc="Calculando trajetória (120 vetores)...")
     # 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
+    x_traj, y_traj, z_traj = bezier_curve_3d(pontos_curva) # Gera 120 vetores
     total_frames = len(x_traj)
 
     # 4. Aprende o "eco" para o próximo ciclo
@@ -58,41 +57,37 @@ def gerar_proximo_ciclo(estado_anterior_json: str, progress=gr.Progress(track_tq
     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()
-    }
+    # 5. Salva o novo estado
+    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')
     
-    bola, = ax.plot([], [], [], 'o', color='red', markersize=10, markeredgecolor='white')
+    # --- A MUDANÇA PRINCIPAL: Ambiente Fixo ---
+    # Desenha a cena estática UMA VEZ
+    ax.plot(x_traj, y_traj, z_traj, color='cyan', linewidth=2, alpha=0.4, label='Trajetória (Linhas ABC)')
+    ax.scatter(*ponto_a, s=400, c='lime', alpha=0.7, label='Checkpoint A (Início)')
+    ax.scatter(*ponto_b, s=400, c='yellow', marker='X', alpha=0.7, label='Checkpoint B (Destino)')
+    ax.view_init(elev=30., azim=angulo_camera) # Usa o ângulo da UI
     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.legend()
+    
+    # Inicializa apenas a bola, que é o único elemento que se move
+    bola, = ax.plot([], [], [], 'o', color='red', markersize=10, markeredgecolor='white')
 
     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='A')
-        ax.scatter(*ponto_b, s=400, c='yellow', marker='X', alpha=0.7, label='B')
-        
-        # Anima a bola
+        # A bola avança um vetor (frame) de cada vez
         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}"))
+    ani = FuncAnimation(fig, update, frames=total_frames, interval=33, blit=True)
+    output_filename = "diagrama_animado.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 vetor {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)}"
@@ -101,27 +96,25 @@ def gerar_proximo_ciclo(estado_anterior_json: str, progress=gr.Progress(track_tq
 
 # --- Interface Gradio ---
 
-with gr.Blocks(theme=gr.themes.Base(primary_hue="lime")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="cyan")) as demo:
     gr.Markdown(
         """
-        # 🌀 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.
+        # 📈 Diagrama 3D Animado de Convergência
+        Gere um ciclo da simulação. O ambiente (câmera, checkpoints, trajetória ABC) é FIXO.
+        A animação mostra apenas a **bola vermelha se movendo no tempo**, avançando um vetor a cada frame, sobre o caminho pré-calculado.
         """
     )
     
     with gr.Row():
         with gr.Column(scale=1):
             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)
-            
+            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo da Câmera (Azimute)")
             info_output = gr.Textbox(label="Dados do Ciclo Atual", lines=4, interactive=False)
             
-            # 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")
+            with gr.Row():
+                start_btn = gr.Button("🚀 Iniciar Simulação", variant="primary")
+                next_btn = gr.Button("➡️ Gerar Próximo Ciclo", variant="secondary")
             
         with gr.Column(scale=2):
             gr.Markdown("### 📽️ Visualização do Ciclo")
@@ -129,14 +122,14 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue="lime")) as demo:
 
     # Conexões dos botões
     start_btn.click(
-        fn=lambda: gerar_proximo_ciclo(None), # Passa None para indicar o primeiro ciclo
-        inputs=None,
+        fn=lambda angulo: gerar_diagrama_animado(None, angulo),
+        inputs=[angulo_camera_slider],
         outputs=[video_output, estado_oculto, info_output]
     )
     
     next_btn.click(
-        fn=gerar_proximo_ciclo,
-        inputs=[estado_oculto],
+        fn=gerar_diagrama_animado,
+        inputs=[estado_oculto, angulo_camera_slider],
         outputs=[video_output, estado_oculto, info_output]
     )