Update app.py

app.py

@@ -5,8 +5,6 @@ from mpl_toolkits.mplot3d import Axes3D
 from matplotlib.animation import FuncAnimation
 import math
 from scipy.special import comb
-import random
-import os
 
 # --- Funções Matemáticas (Inalteradas) ---
 def bernstein_poly(i, n, t):
@@ -25,49 +23,50 @@ 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 da Jornada Contínua) ---
+# --- Função Principal do Gradio (O Simulador Inteligente) ---
 
-def gerar_jornada_completa(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
+def gerar_simulacao_inteligente(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
     """
-    Gera uma única trajetória contínua para 10 ciclos e a renderiza
-    como um único vídeo animado.
+    Gera uma jornada contínua com checkpoints dinâmicos e um loop perfeito.
     """
     NUM_CICLOS = 10
+    VETORES_POR_CICLO = 60
+    
+    # --- 1. CALCULAR A JORNADA COMPLETA E OS CHECKPOINTS ---
+    progress(0, desc="Calculando trajetória completa para 10 ciclos...")
     
-    # 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"])
+    checkpoints = [np.array([-40., 20., 10.])]
+    vetor_inercia = np.array([30., 10., -20.])
 
-    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
+        ponto_a = checkpoints[-1]
+        
+        # --- LÓGICA DO LOOP PERFEITO ---
+        if i < NUM_CICLOS - 1:
+            ponto_b = np.random.rand(3) * 120 - 60
+        else: # Último ciclo
+            ponto_b = checkpoints[0] # O alvo é o primeiro checkpoint
+        # -----------------------------
+            
         checkpoints.append(ponto_b)
         
-        ponto_controle = ponto_a + vetor_inercia_anterior
-        pontos_curva = [ponto_a, ponto_controle, ponto_b]
-        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva)
+        ponto_controle = ponto_a + vetor_inercia
+        # Para o loop final, adicionamos um ponto de controle extra para suavizar a chegada
+        pontos_curva = [ponto_a, ponto_controle, ponto_b] if i < NUM_CICLOS - 1 else [ponto_a, ponto_controle, checkpoints[1], ponto_b]
+
+        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva, n_times=VETORES_POR_CICLO)
         
         x_jornada_total.extend(x_ciclo); y_jornada_total.extend(y_ciclo); z_jornada_total.extend(z_ciclo)
 
         tamanho_eco = 20
         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}
+        vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
 
     total_frames = len(x_jornada_total)
     progress(0.2, desc=f"Trajetória de {total_frames} vetores calculada. Iniciando renderização...")
-    
-    # --- 2. RENDERIZAÇÃO ÚNICA ---
+
+    # --- 2. RENDERIZAÇÃO INTELIGENTE ---
     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
@@ -76,56 +75,61 @@ def gerar_jornada_completa(angulo_camera: int, progress=gr.Progress(track_tqdm=T
     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)
+    bola, = ax.plot([], [], [], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
     rastro, = ax.plot([], [], [], '-', color='#ff4500', linewidth=4, alpha=0.6)
+    checkpoints_passados_scatter = ax.scatter([], [], [], s=150, c='lime', alpha=0.7)
+    proximo_checkpoint_scatter = ax.scatter([], [], [], s=150, c='red', marker='X', alpha=0.9)
     tamanho_rastro = 40
 
     def update(frame):
+        # Atualiza a bola e o rastro
         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,
+
+        # --- LÓGICA DOS CHECKPOINTS DINÂMICOS ---
+        ciclo_atual = frame // VETORES_POR_CICLO
+        
+        # Mostra todos os checkpoints que já foram visitados (em verde)
+        pontos_passados = np.array(checkpoints[:ciclo_atual + 1])
+        checkpoints_passados_scatter._offsets3d = (pontos_passados[:,0], pontos_passados[:,1], pontos_passados[:,2])
+
+        # Mostra o próximo alvo (em vermelho), mas apenas se não for o último
+        if ciclo_atual + 1 < len(checkpoints):
+            proximo_ponto = checkpoints[ciclo_atual + 1]
+            proximo_checkpoint_scatter._offsets3d = ([proximo_ponto[0]], [proximo_ponto[1]], [proximo_ponto[2]])
+        else: # Se chegou no final, esconde o marcador de alvo
+            proximo_checkpoint_scatter._offsets3d = ([], [], [])
+            
+        return bola, rastro, checkpoints_passados_scatter, proximo_checkpoint_scatter
 
     # --- 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 = FuncAnimation(fig, update, frames=total_frames, interval=33, blit=False) # blit=False é mais robusto para 3D
+    video_final = "simulacao_inteligente.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="orange")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="purple")) as demo:
     gr.Markdown(
         """
-        # 🎬 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.
+        # 🧠 Simulador de Jornada Inteligente 3D
+        Gere uma jornada contínua de **10 ciclos**. Os checkpoints (alvos em vermelho) só aparecem quando a bola se aproxima.
+        Checkpoints visitados se tornam verdes. A trajetória final é calculada para criar um **loop perfeito**.
         """
     )
-    
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("### 🎮 Controles")
             angulo_camera_slider = gr.Slider(-180, 180, value=30, label="Ângulo da Câmera (Fixo)")
-            generate_btn = gr.Button("🚀 Gerar Jornada Completa", variant="primary")
-            
+            generate_btn = gr.Button("🚀 Gerar Jornada Inteligente", variant="primary")
         with gr.Column(scale=2):
             gr.Markdown("### 📽️ Vídeo Final")
             video_output = gr.Video(label="Animação da Jornada Contínua", autoplay=True)
-
-    generate_btn.click(
-        fn=gerar_jornada_completa,
-        inputs=[angulo_camera_slider],
-        outputs=[video_output]
-    )
+    generate_btn.click(fn=gerar_simulacao_inteligente, inputs=[angulo_camera_slider], outputs=[video_output])
 
 if __name__ == "__main__":
     demo.launch()