Update app.py

app.py

@@ -4,7 +4,6 @@ import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
 import math
 from scipy.special import comb
-import json
 import time
 
 # --- Funções Matemáticas (Inalteradas) ---
@@ -24,101 +23,57 @@ 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 Loop Infinito) ---
-def motor_da_simulacao(estado_json: str, angulo_camera: int):
-    # 1. Carrega ou inicializa o estado
-    if estado_json:
-        estado = json.loads(estado_json)
-        ponto_a = np.array(estado["ponto_b"])
-        vetor_inercia = np.array(estado["vetor_inercia"])
-        historico_rastro = estado.get("historico_rastro", [ponto_a.tolist()])
-    else:
-        ponto_a = np.array([-40., 20., 10.])
-        vetor_inercia = np.array([30., 10., -20.])
-        historico_rastro = [ponto_a.tolist()]
+# --- Função Principal do Gradio (O Motor da Simulação Infinita) ---
 
-    ponto_b = np.random.rand(3) * 120 - 60
-    ponto_controle = ponto_a + vetor_inercia
-    pontos_curva = [ponto_a, ponto_controle, ponto_b]
-    x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva)
-    
-    novos_pontos_rastro = list(zip(x_ciclo, y_ciclo, z_ciclo))
-    historico_rastro.extend(novos_pontos_rastro)
+def motor_da_simulacao_infinita(angulo_camera: int):
+    """
+    Esta função é um gerador que roda em um loop infinito, 'yieldando'
+    um novo frame do gráfico para a UI a cada passo.
+    """
+    # 1. Inicializa o estado da simulação
+    ponto_a = np.array([-40., 20., 10.])
+    vetor_inercia = np.array([30., 10., -20.])
+    historico_rastro = [ponto_a.tolist()] # O rastro começa no ponto inicial
 
-    max_rastro = 500
-    historico_rastro = historico_rastro[-max_rastro:]
-
-    tamanho_eco = 20
-    pontos_eco = historico_rastro[-tamanho_eco:]
-    novo_vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
-
-    proximo_estado = {
-        "ponto_b": ponto_b.tolist(),
-        "vetor_inercia": novo_vetor_inercia.tolist(),
-        "historico_rastro": historico_rastro
-    }
-    
+    # Prepara a figura do Matplotlib uma única vez
     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)
-    
-    # --- AQUI ESTÁ A CORREÇÃO DE SINTAXE E LÓGICA ---
-    # Convertemos o rastro para Numpy array aqui, em sua própria linha.
-    rastro_np = np.array(historico_rastro)
-    
-    # O loop de animação começa depois da preparação dos dados.
-    for frame in range(len(x_ciclo)):
-        ax.cla()
-        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 + (len(historico_rastro) - len(x_ciclo) + frame) * 0.1)
-        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.scatter(*ponto_a, s=150, c='lime', alpha=0.7)
-        ax.scatter(*ponto_b, s=150, c='red', marker='X', alpha=0.9)
 
-        # O índice para o rastro deve ser calculado corretamente
-        indice_inicio_rastro_global = len(historico_rastro) - len(x_ciclo)
-        rastro_frame_atual = rastro_np[:indice_inicio_rastro_global + frame + 1]
+    # --- 2. O LOOP INFINITO ---
+    ciclo_num = 0
+    while True:
+        ciclo_num += 1
         
-        ax.plot(rastro_frame_atual[:,0], rastro_frame_atual[:,1], rastro_frame_atual[:,2], '-', color='#ff4500', linewidth=4, alpha=0.6)
+        # Gera um novo checkpoint B aleatório
+        ponto_b = np.random.rand(3) * 120 - 60
         
-        ax.plot([x_ciclo[frame]], [y_ciclo[frame]], [z_ciclo[frame]], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
-        
-        info = f"Ciclo Atual\nInício (A): {np.round(ponto_a, 1)}\nDestino (B): {np.round(ponto_b, 1)}"
-        yield fig, json.dumps(proximo_estado), info
-        time.sleep(0.01)
-        
-    plt.close(fig)
+        # Calcula a trajetória para o ciclo atual
+        ponto_controle = ponto_a + vetor_inercia
+        pontos_curva = [ponto_a, ponto_controle, ponto_b]
+        x_ciclo, y_ciclo, z_ciclo = bezier_curve_3d(pontos_curva)
 
-# --- Interface Gradio (Inalterada) ---
-with gr.Blocks(theme=gr.themes.Base(primary_hue="pink")) as demo:
-    gr.Markdown(
-        """
-        # ♾️ Simulador de Jornada Infinita (Tempo Real)
-        Clique em "Iniciar / Próximo Ciclo" para que o agente (bola) comece sua jornada.
-        A simulação continuará em um loop infinito, gerando novos alvos e mantendo um rastro contínuo do seu percurso.
-        """
-    )
-    with gr.Row():
-        with gr.Column(scale=1):
-            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo Inicial da Câmera")
-            info_output = gr.Textbox(label="Dados do Ciclo Atual", lines=3, interactive=False)
-            run_btn = gr.Button("🚀 Iniciar / Próximo Ciclo", variant="primary")
-        with gr.Column(scale=2):
-            plot_output = gr.Plot(label="Visualização da Simulação")
+        # Adiciona os novos pontos do ciclo ao histórico do rastro
+        novos_pontos_rastro = list(zip(x_ciclo, y_ciclo, z_ciclo))
+        historico_rastro.extend(novos_pontos_rastro)
 
-    state = gr.State()
+        # Limita o tamanho do rastro para não consumir memória infinita
+        max_rastro = 500
+        historico_rastro = historico_rastro[-max_rastro:]
+        
+        # Aprende o "eco" para o PRÓXIMO ciclo
+        tamanho_eco = 20
+        pontos_eco = list(zip(x_ciclo[-tamanho_eco:], y_ciclo[-tamanho_eco:], z_ciclo[-tamanho_eco:]))
+        vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
 
-    run_btn.click(
-        fn=motor_da_simulacao,
-        inputs=[state, angulo_camera_slider],
-        outputs=[plot_output, state, info_output]
-    ).then(
-        fn=motor_da_simulacao,
-        inputs=[state, angulo_camera_slider],
-        outputs=[plot_output, state, info_output]
-    )
+        # Loop de renderização para o ciclo atual
+        for frame in range(len(x_ciclo)):
+            ax.cla() # Limpa o gráfico para o próximo frame
+            
+            # Reconfigura o 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([])
 
-if __name__ == "__main__":
-    demo.launch(),
+