Update app.py

app.py

@@ -6,15 +6,13 @@ from matplotlib.animation import FuncAnimation
 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=60): # Fixo em 60 vetores/frames
+def bezier_curve_3d(points, n_times=60):
     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)
@@ -27,114 +25,104 @@ 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 Estúdio de Animação) ---
+# --- Função Principal do Gradio (O Estúdio da Jornada Contínua) ---
 
-def gerar_sequencia_completa(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
+def gerar_jornada_completa(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
     """
-    Gera uma sequência de 10 ciclos, renderiza cada um como um vídeo
-    e os concatena em um resultado final.
+    Gera uma única trajetória contínua para 10 ciclos e a renderiza
+    como um único vídeo animado.
     """
     NUM_CICLOS = 10
-    clipes_de_video = []
     
+    # Listas para armazenar a jornada completa
+    x_jornada_total, y_jornada_total, z_jornada_total = [], [], []
+    checkpoints = []
+
+    # Estado inicial da simulação
     estado = {
         "ponto_b": np.array([-40., 20., 10.]),
         "vetor_inercia": np.array([30., 10., -20.])
     }
+    checkpoints.append(estado["ponto_b"])
 
-    for ciclo_atual in range(NUM_CICLOS):
-        progress(ciclo_atual / NUM_CICLOS, desc=f"Processando Ciclo {ciclo_atual + 1}/{NUM_CICLOS}")
-        
+    progress(0, desc="Calculando trajetória para 10 ciclos...")
+    # --- 1. CALCULAR TUDO PRIMEIRO ---
+    for i in range(NUM_CICLOS):
         ponto_a = estado["ponto_b"]
         vetor_inercia_anterior = estado["vetor_inercia"]
         ponto_b = np.random.rand(3) * 120 - 60
-
+        checkpoints.append(ponto_b)
+        
         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)
-        total_frames = len(x_traj)
+        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva)
+        
+        x_jornada_total.extend(x_ciclo); y_jornada_total.extend(y_ciclo); z_jornada_total.extend(z_ciclo)
 
         tamanho_eco = 20
-        # --- CORREÇÃO DO SYNTAXERROR AQUI ---
-        pontos_eco = list(zip(x_traj[-tamanho_eco:], y_traj[-tamanho_eco:], z_traj[-tamanho_eco:]))
-        # ------------------------------------
+        pontos_eco = list(zip(x_ciclo[-tamanho_eco:], y_ciclo[-tamanho_eco:], z_ciclo[-tamanho_eco:]))
         vetor_inercia_novo = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
-        
         estado = {"ponto_b": ponto_b, "vetor_inercia": vetor_inercia_novo}
 
-        fig = plt.figure(figsize=(8, 8)); ax = fig.add_subplot(111, projection='3d')
-        
-        cor_fundo = '#0a0a0a'; fig.patch.set_facecolor(cor_fundo); ax.set_facecolor(cor_fundo)
-        ax.xaxis.pane.fill = False; ax.yaxis.pane.fill = False; ax.zaxis.pane.fill = False
-        ax.grid(color='#222222', linestyle='--')
-
-        ax.plot(x_traj, y_traj, z_traj, color='cyan', linewidth=1.5, alpha=0.2) # Trajetória completa mais sutil
-        ax.scatter(*ponto_a, s=150, c='lime', alpha=0.9, edgecolors='w', linewidth=0.5)
-        ax.scatter(*ponto_b, s=150, c='yellow', marker='X', alpha=0.9, edgecolors='w', linewidth=0.5)
-        ax.view_init(elev=30., azim=angulo_camera)
-        ax.set_xlim(-70, 70); ax.set_ylim(-70, 70); ax.set_zlim(-70, 70)
-        ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
-        
-        bola, = ax.plot([], [], [], 'o', color='#ff4500', markersize=8, markeredgecolor='white', linewidth=2)
-        
-        # --- AJUSTE ESTÉTICO: RASTRO DA BOLA ---
-        rastro, = ax.plot([], [], [], '-', color='#ff4500', linewidth=4, alpha=0.6)
-        tamanho_rastro = 25 # O rastro terá 25 vetores de comprimento
-        # ------------------------------------
-
-        def update(frame):
-            bola.set_data_3d([x_traj[frame]], [y_traj[frame]], [z_traj[frame]])
-            
-            # Atualiza o rastro para mostrar os últimos 'tamanho_rastro' pontos
-            start_index = max(0, frame - tamanho_rastro)
-            rastro.set_data_3d(x_traj[start_index:frame+1], y_traj[start_index:frame+1], z_traj[start_index:frame+1])
-            
-            return bola, rastro,
-
-        ani = FuncAnimation(fig, update, frames=total_frames, interval=33, blit=True)
-        clip_filename = f"clip_{ciclo_atual}.mp4"
-        ani.save(clip_filename, writer='ffmpeg', fps=30, dpi=120)
-        plt.close(fig)
-        clipes_de_video.append(clip_filename)
-
-    progress(0.95, desc="Concatenando 10 clipes em um vídeo final...")
+    total_frames = len(x_jornada_total)
+    progress(0.2, desc=f"Trajetória de {total_frames} vetores calculada. Iniciando renderização...")
     
-    with open("lista_de_clipes.txt", "w") as f:
-        for clip in clipes_de_video:
-            f.write(f"file '{os.path.abspath(clip)}'\n")
-            
-    video_final = "sequencia_convergencia_final.mp4"
-    comando = f"ffmpeg -y -f concat -safe 0 -i lista_de_clipes.txt -c copy {video_final}"
-    subprocess.run(comando, shell=True, check=True, stdout=subprocess.DEVNULL, stderr=subprocess.DEVNULL)
-
-    for clip in clipes_de_video: os.remove(clip)
-    os.remove("lista_de_clipes.txt")
+    # --- 2. RENDERIZAÇÃO ÚNICA ---
+    fig = plt.figure(figsize=(8, 8)); ax = fig.add_subplot(111, projection='3d')
+    cor_fundo = '#0a0a0a'; fig.patch.set_facecolor(cor_fundo); ax.set_facecolor(cor_fundo)
+    ax.xaxis.pane.fill = False; ax.yaxis.pane.fill = False; ax.zaxis.pane.fill = False
+    ax.grid(color='#222222', linestyle='--')
+    ax.view_init(elev=30., azim=angulo_camera)
+    ax.set_xlim(-70, 70); ax.set_ylim(-70, 70); ax.set_zlim(-70, 70)
+    ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
+    
+    # Desenha todos os checkpoints
+    checkpoints_np = np.array(checkpoints)
+    ax.scatter(checkpoints_np[0,0], checkpoints_np[0,1], checkpoints_np[0,2], s=150, c='yellow', marker='X', alpha=0.9, label='')
+    ax.scatter(checkpoints_np[1:,0], checkpoints_np[1:,1], checkpoints_np[1:,2], s=150, c='yellow', marker='X', alpha=0.9, label='')
+
+    # Inicializa os elementos animados
+    bola, = ax.plot([], [], [], 'o', color='#ff4500', markersize=8, markeredgecolor='white', linewidth=2)
+    rastro, = ax.plot([], [], [], '-', color='#ff4500', linewidth=4, alpha=0.6)
+    tamanho_rastro = 40
+
+    def update(frame):
+        bola.set_data_3d([x_jornada_total[frame]], [y_jornada_total[frame]], [z_jornada_total[frame]])
+        start_index = max(0, frame - tamanho_rastro)
+        rastro.set_data_3d(x_jornada_total[start_index:frame+1], y_jornada_total[start_index:frame+1], z_jornada_total[start_index:frame+1])
+        return bola, rastro,
+
+    # --- 3. UMA ÚNICA ANIMAÇÃO E UM ÚNICO VÍDEO ---
+    ani = FuncAnimation(fig, update, frames=total_frames, interval=33, blit=True)
+    video_final = "jornada_continua.mp4"
+    ani.save(video_final, writer='ffmpeg', fps=30, dpi=120, progress_callback=lambda i, n: progress(0.2 + 0.8 * (i/n), desc=f"Renderizando vetor {i+1}/{n}"))
+    plt.close(fig)
     
     return video_final
 
 # --- Interface Gradio (Inalterada) ---
 
-with gr.Blocks(theme=gr.themes.Base(primary_hue="blue")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="orange")) as demo:
     gr.Markdown(
         """
-        # 🎬 Estúdio de Animação de Convergência 3D
-        Clique no botão para gerar uma sequência contínua de **10 ciclos**. Cada ciclo tem **60 vetores**.
-        O sistema irá renderizar cada ciclo e concatenar todos em um único vídeo de demonstração.
+        # 🎬 Estúdio da Jornada Contínua 3D
+        Clique no botão para gerar uma **jornada ininterrupta de 10 ciclos**.
+        O sistema irá calcular toda a trajetória e renderizá-la como um único vídeo, mostrando a continuidade do rastro da bola.
         """
     )
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 🎮 Controles")
-            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo da Câmera (Fixo)")
-            generate_btn = gr.Button("🚀 Gerar Sequência Completa (10 Ciclos)", variant="primary")
+            angulo_camera_slider = gr.Slider(-180, 180, value=30, label="Ângulo da Câmera (Fixo)")
+            generate_btn = gr.Button("🚀 Gerar Jornada Completa", variant="primary")
             
         with gr.Column(scale=2):
             gr.Markdown("### 📽️ Vídeo Final")
-            video_output = gr.Video(label="Animação da Sequência Completa", autoplay=True)
+            video_output = gr.Video(label="Animação da Jornada Contínua", autoplay=True)
 
     generate_btn.click(
-        fn=gerar_sequencia_completa,
+        fn=gerar_jornada_completa,
         inputs=[angulo_camera_slider],
         outputs=[video_output]
     )