Update app.py

app.py

@@ -2,9 +2,9 @@ import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
-from matplotlib.animation import FuncAnimation
 import math
 from scipy.special import comb
+import time
 
 # --- Funções Matemáticas (Inalteradas) ---
 def bernstein_poly(i, n, t):
@@ -23,38 +23,27 @@ 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 Simulador Inteligente) ---
+# --- Função Principal do Gradio (Renderização em Tempo Real) ---
 
-def gerar_simulacao_inteligente(angulo_camera: int, progress=gr.Progress(track_tqdm=True)):
+def gerar_simulacao_em_tempo_real(angulo_camera: int):
     """
-    Gera uma jornada contínua com checkpoints dinâmicos e um loop perfeito.
+    Gera a jornada completa e a 'yielda' frame a frame para a UI do Gradio.
     """
     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...")
-    
+    # 1. Calcula a jornada completa
     x_jornada_total, y_jornada_total, z_jornada_total = [], [], []
     checkpoints = [np.array([-40., 20., 10.])]
     vetor_inercia = np.array([30., 10., -20.])
 
     for i in range(NUM_CICLOS):
         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
-        # -----------------------------
-            
+        ponto_b = np.random.rand(3) * 120 - 60 if i < NUM_CICLOS - 1 else checkpoints[0]
         checkpoints.append(ponto_b)
         
         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)
@@ -64,72 +53,63 @@ def gerar_simulacao_inteligente(angulo_camera: int, progress=gr.Progress(track_t
         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 INTELIGENTE ---
+    # 2. Setup do Gráfico (será reutilizado no loop)
     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([])
     
-    # Inicializa os elementos animados
-    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])
-
-        # --- LÓGICA DOS CHECKPOINTS DINÂMICOS ---
-        ciclo_atual = frame // VETORES_POR_CICLO
+    # --- 3. LOOP DE RENDERIZAÇÃO E YIELD ---
+    for frame in range(total_frames):
+        ax.cla() # Limpa o gráfico para o próximo frame
         
-        # Mostra todos os checkpoints que já foram visitados (em verde)
+        # Configurações do ambiente fixo
+        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([])
+
+        # Lógica dos checkpoints dinâmicos
+        ciclo_atual = frame // VETORES_POR_CICLO
         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
+        ax.scatter(pontos_passados[:,0], pontos_passados[:,1], pontos_passados[:,2], s=150, c='lime', alpha=0.7)
         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
+            ax.scatter(proximo_ponto[0], proximo_ponto[1], proximo_ponto[2], s=150, c='red', marker='X', alpha=0.9)
 
-    # --- 3. UMA ÚNICA ANIMAÇÃO E UM ÚNICO VÍDEO ---
-    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
+        # Desenha a bola e o rastro
+        tamanho_rastro = 40
+        start_index = max(0, frame - tamanho_rastro)
+        ax.plot(x_jornada_total[start_index:frame+1], y_jornada_total[start_index:frame+1], z_jornada_total[start_index:frame+1], '-', color='#ff4500', linewidth=4, alpha=0.6)
+        ax.plot([x_jornada_total[frame]], [y_jornada_total[frame]], [z_jornada_total[frame]], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
+        
+        # O comando mágico: envia o gráfico atual para a UI
+        yield fig
+        
+    plt.close(fig) # Libera a memória no final
+
+# --- Interface Gradio ---
 
-# --- Interface Gradio (Inalterada) ---
-with gr.Blocks(theme=gr.themes.Base(primary_hue="purple")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="red")) as demo:
     gr.Markdown(
         """
-        # 🧠 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**.
+        # 🧠 Simulador de Jornada Inteligente 3D (Tempo Real)
+        Clique em "Gerar" para iniciar a simulação. O gráfico será renderizado frame a frame diretamente na UI.
         """
     )
     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 Inteligente", variant="primary")
+            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo da Câmera (Azimute)")
+            generate_btn = gr.Button("🚀 Gerar Simulação em Tempo Real", 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_simulacao_inteligente, inputs=[angulo_camera_slider], outputs=[video_output])
+            # Usamos gr.Plot para exibir os gráficos do Matplotlib
+            plot_output = gr.Plot(label="Visualização da Simulação")
+
+    generate_btn.click(
+        fn=gerar_simulacao_em_tempo_real,
+        inputs=[angulo_camera_slider],
+        outputs=[plot_output]
+    )
 
 if __name__ == "__main__":
     demo.launch()