Update app.py

app.py

@@ -7,12 +7,14 @@ import math
 from scipy.special import comb
 import random
 import json
+import os
+import subprocess
 
 # --- 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=120): # Fixo em 120 vetores/frames
+def bezier_curve_3d(points, n_times=60): # Fixo em 60 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,113 +27,36 @@ 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 (Gerador de Diagrama Animado) ---
+# --- Função Principal do Gradio (O Estúdio de Animação) ---
 
-def gerar_diagrama_animado(estado_anterior_json: str, angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
+def gerar_sequencia_completa(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
     """
-    Gera um ciclo da jornada com ambiente estático e movimento discreto da bola.
+    Gera uma sequência de 10 ciclos, renderiza cada um como um vídeo
+    e os concatena em um resultado final.
     """
-    progress(0, desc="Decodificando estado anterior...")
-    # 1. Carrega ou inicializa o estado
-    if estado_anterior_json:
-        estado = json.loads(estado_anterior_json)
-        ponto_a = np.array(estado["ponto_b"])
-        vetor_inercia_anterior = np.array(estado["vetor_inercia"])
-    else: # Primeiro ciclo
-        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 (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) # Gera 120 vetores
-    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
-    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')
-    
-    # --- 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):
-        # A bola avança um vetor (frame) de cada vez
-        bola.set_data_3d([x_traj[frame]], [y_traj[frame]], [z_traj[frame]])
-        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=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)}"
-    
-    return output_filename, estado_novo_json, info_ciclo
-
-# --- Interface Gradio ---
-
-with gr.Blocks(theme=gr.themes.Base(primary_hue="cyan")) as demo:
-    gr.Markdown(
-        """
-        # 📈 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")
-            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)
-            
-            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")
-            video_output = gr.Video(label="Animação do Ciclo Atual", autoplay=True)
-
-    # Conexões dos botões
-    start_btn.click(
-        fn=lambda angulo: gerar_diagrama_animado(None, angulo),
-        inputs=[angulo_camera_slider],
-        outputs=[video_output, estado_oculto, info_output]
-    )
+    NUM_CICLOS = 10
+    clipes_de_video = []
     
-    next_btn.click(
-        fn=gerar_diagrama_animado,
-        inputs=[estado_oculto, angulo_camera_slider],
-        outputs=[video_output, estado_oculto, info_output]
-    )
-
-if __name__ == "__main__":
-    demo.launch()
+    # Estado inicial da simulação
+    estado = {
+        "ponto_b": np.array([-40., 20., 10.]),
+        "vetor_inercia": np.array([30., 10., -20.])
+    }
+
+    for ciclo_atual in range(NUM_CICLOS):
+        progress(ciclo_atual / NUM_CICLOS, desc=f"Processando Ciclo {ciclo_atual + 1}/{NUM_CICLOS}")
+        
+        # 1. Atualiza o estado para o novo ciclo
+        ponto_a = estado["ponto_b"]
+        vetor_inercia_anterior = estado["vetor_inercia"]
+        ponto_b = np.random.rand(3) * 120 - 60
+
+        # 2. Calcula a 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) # 60 vetores
+        total_frames = len(x_traj)
+
+        # 3. Aprende o eco para o próximo ciclo
+        tamanho_eco = 20 # Eco menor para trajetórias mais curtas
+        pontos_eco = list(zip(x_traj[-tamanho