Update app.py

app.py

@@ -11,8 +11,7 @@ import time
 def bernstein_poly(i, n, t):
     return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 
-# --- MUDANÇA #1: CICLOS ULTRA-RÁPIDOS (Menos Vetores) ---
-def bezier_curve_3d(points, n_times=20): # Apenas 20 vetores por ciclo!
+def bezier_curve_3d(points, n_times=20): # 20 vetores para alta velocidade
     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)
@@ -25,12 +24,12 @@ 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 (Motor Hyperdrive) ---
+# --- Função Principal do Gradio (Motor Hyperdrive com Ambiente Fixo) ---
 
 def motor_da_simulacao_infinita(angulo_camera: int):
     """
-    Motor da simulação que roda em um loop infinito, com um universo compacto
-    e velocidade de movimento extrema.
+    Motor da simulação que roda em um loop infinito, com um universo compacto,
+    velocidade extrema e um AMBIENTE FIXO.
     """
     ponto_a = np.array([0., 0., 0.])
     vetor_inercia = np.array([10., 10., 10.])
@@ -43,9 +42,7 @@ def motor_da_simulacao_infinita(angulo_camera: int):
     while True:
         ciclo_num += 1
         
-        # --- MUDANÇA #2: UNIVERSO COMPACTO ---
-        # Alvos aleatórios em um espaço de -25 a 25 (4x menor que o anterior)
-        ponto_b = np.random.rand(3) * 50 - 25
+        ponto_b = np.random.rand(3) * 50 - 25 # Universo compacto
 
         ponto_controle = ponto_a + vetor_inercia
         pontos_curva = [ponto_a, ponto_controle, ponto_b]
@@ -53,10 +50,10 @@ def motor_da_simulacao_infinita(angulo_camera: int):
 
         novos_pontos_rastro = list(zip(x_ciclo, y_ciclo, z_ciclo))
         historico_rastro.extend(novos_pontos_rastro)
-        max_rastro = 5 # Rastro mais curto para um visual mais limpo
+        max_rastro = 150
         historico_rastro = historico_rastro[-max_rastro:]
         
-        tamanho_eco = 10 # Eco menor para trajetórias mais curtas
+        tamanho_eco = 10
         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"]
 
@@ -66,9 +63,12 @@ def motor_da_simulacao_infinita(angulo_camera: int):
             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=25., azim=angulo_camera + (len(historico_rastro) - len(x_ciclo) + frame) * 0.5) # Rotação de câmera mais rápida
             
-            # --- MUDANÇA #2 (Continuação): Limites do gráfico para o universo compacto ---
+            # --- A MUDANÇA PRINCIPAL: AMBIENTE FIXO ---
+            # A câmera não gira mais com base no frame. Ela usa o ângulo fixo da UI.
+            ax.view_init(elev=30., azim=angulo_camera)
+            # ------------------------------------------
+            
             ax.set_xlim(-30, 30); ax.set_ylim(-30, 30); ax.set_zlim(-30, 30)
             ax.set_xticklabels([]); ax.set_yticklabels([]); ax.set_zticklabels([])
 
@@ -84,26 +84,25 @@ def motor_da_simulacao_infinita(angulo_camera: int):
             ax.text2D(0.05, 0.95, info_texto, transform=ax.transAxes, color='white', fontsize=10)
             
             yield fig
-            # --- MUDANÇA #3: ATUALIZAÇÃO MAIS RÁPIDA ---
-            time.sleep(0.01) # Pausa mínima para a UI respirar
+            time.sleep(0.01)
 
         ponto_a = ponto_b
 
     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="teal", secondary_hue="green")) as demo:
     gr.Markdown(
         """
-        # ⚡ Simulador Autônomo 3D (Modo Hyperdrive)
-        Clique em "Iniciar" para dar partida no motor da simulação. O agente irá navegar em **velocidade extrema**
-        por um universo compacto, gerando novos alvos aleatórios em um loop infinito.
+        # ⚡ Simulador Autônomo 3D (Hyperdrive Estático)
+        Defina um ângulo para a câmera e clique em "Iniciar". O agente (bola) irá navegar em
+        **velocidade extrema** por um universo compacto com um **ponto de vista fixo**.
         """
     )
     with gr.Row():
         with gr.Column(scale=1):
-            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo Inicial da Câmera")
-            start_btn = gr.Button("🚀 Iniciar Simulação (Hyperdrive)", variant="primary")
+            angulo_camera_slider = gr.Slider(-180, 180, value=45, label="Ângulo da Câmera (Fixo)")
+            start_btn = gr.Button("🚀 Iniciar Simulação (Ambiente Fixo)", variant="primary")
         with gr.Column(scale=2):
             plot_output = gr.Plot(label="Visualização em Tempo Real")