Update app.py

app.py

@@ -4,6 +4,7 @@ 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) ---
@@ -23,92 +24,114 @@ 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 (Renderização em Tempo Real) ---
+# --- Função Principal do Gradio (O Gerador de Loop Infinito) ---
 
-def gerar_simulacao_em_tempo_real(angulo_camera: int):
+def motor_da_simulacao(estado_json: str, angulo_camera: int):
     """
-    Gera a jornada completa e a 'yielda' frame a frame para a UI do Gradio.
+    Esta função é um gerador. Ela executa um ciclo e 'yielda' um frame de cada vez.
     """
-    NUM_CICLOS = 10
-    VETORES_POR_CICLO = 60
-    
-    # 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.])
+    # 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"])
+        # Mantém o histórico do rastro
+        historico_rastro = estado.get("historico_rastro", {"x": [ponto_a[0]], "y": [ponto_a[1]], "z": [ponto_a[2]]})
+    else: # Primeiro ciclo
+        ponto_a = np.array([-40., 20., 10.])
+        vetor_inercia = np.array([30., 10., -20.])
+        historico_rastro = {"x": [ponto_a[0]], "y": [ponto_a[1]], "z": [ponto_a[2]]}
 
-    for i in range(NUM_CICLOS):
-        ponto_a = checkpoints[-1]
-        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
-        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)
+    # 2. Gera o próximo checkpoint
+    ponto_b = np.random.rand(3) * 120 - 60
+    
+    # 3. Calcula a trajetória do 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)
 
-        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"]
+    # 4. 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:]))
+    novo_vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
 
-    total_frames = len(x_jornada_total)
+    # 5. Prepara o estado que será salvo no final deste ciclo
+    proximo_estado = {
+        "ponto_b": ponto_b.tolist(),
+        "vetor_inercia": novo_vetor_inercia.tolist(),
+        "historico_rastro": {
+            "x": historico_rastro["x"] + list(x_ciclo),
+            "y": historico_rastro["y"] + list(y_ciclo),
+            "z": historico_rastro["z"] + list(z_ciclo)
+        }
+    }
+    
+    # Limita o tamanho do rastro para não consumir memória infinita
+    max_rastro = 500
+    for axis in ["x", "y", "z"]:
+        proximo_estado["historico_rastro"][axis] = proximo_estado["historico_rastro"][-max_rastro:]
 
-    # 2. Setup do Gráfico (será reutilizado no loop)
+    # 6. Setup do Gráfico
     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)
     
-    # --- 3. LOOP DE RENDERIZAÇÃO E YIELD ---
-    for frame in range(total_frames):
-        ax.cla() # Limpa o gráfico para o próximo frame
-        
-        # Configurações do ambiente fixo
+    # 7. Loop de Animação e Yield
+    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)
+        ax.view_init(elev=30., azim=angulo_camera + frame*0.1) # Câmera gira lentamente
         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])
-        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]
-            ax.scatter(proximo_ponto[0], proximo_ponto[1], proximo_ponto[2], s=150, c='red', marker='X', alpha=0.9)
+        # Desenha checkpoints
+        ax.scatter(*ponto_a, s=150, c='lime', alpha=0.7)
+        ax.scatter(*ponto_b, s=150, c='red', marker='X', alpha=0.9)
 
-        # 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')
+        # Desenha o rastro contínuo
+        rastro_atual_x = proximo_estado["historico_rastro"]["x"][:len(historico_rastro["x"]) + frame]
+        rastro_atual_y = proximo_estado["historico_rastro"]["y"][:len(historico_rastro["y"]) + frame]
+        rastro_atual_z = proximo_estado["historico_rastro"]["z"][:len(historico_rastro["z"]) + frame]
+        ax.plot(rastro_atual_x, rastro_atual_y, rastro_atual_z, '-', color='#ff4500', linewidth=4, alpha=0.6)
+        
+        # Desenha a bola
+        ax.plot([x_ciclo[frame]], [y_ciclo[frame]], [z_ciclo[frame]], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
         
-        # O comando mágico: envia o gráfico atual para a UI
-        yield fig
+        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) # Pequena pausa para não sobrecarregar o navegador
         
-    plt.close(fig) # Libera a memória no final
+    plt.close(fig)
 
 # --- Interface Gradio ---
-
-with gr.Blocks(theme=gr.themes.Base(primary_hue="red")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="pink")) as demo:
     gr.Markdown(
         """
-        # 🧠 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.
+        # ♾️ 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 da Câmera (Azimute)")
-            generate_btn = gr.Button("🚀 Gerar Simulação em Tempo Real", variant="primary")
+            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):
-            # 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]
+    # O estado é a nossa memória
+    state = gr.State()
+
+    # O evento .then() é o motor do nosso loop infinito
+    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]
     )
 
 if __name__ == "__main__":