Update app.py

app.py

@@ -2,21 +2,31 @@ import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
 from mpl_toolkits.mplot3d import Axes3D
+from matplotlib.collections import LineCollection
+from matplotlib.colors import LinearSegmentedColormap
 import math
 from scipy.special import comb
 import time
 
-# --- Funções Matemáticas ---
+# --- Funções Matemáticas e Utilitários ---
+
+def quantizar(valor, multiplo=4):
+    """Arredonda um valor para o múltiplo mais próximo."""
+    return multiplo * round(valor / multiplo)
 
 def bernstein_poly(i, n, t):
     return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 
-def bezier_curve_3d(points, n_times=20): # 20 vetores para alta velocidade
+def bezier_curve_3d(points, n_times=20):
     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])
+    # Quantiza os pontos de controle
+    points_q = [np.array([quantizar(p[0]), quantizar(p[1]), quantizar(p[2])]) for p in points]
+    x_points, y_points, z_points = np.array([p[0] for p in points_q]), np.array([p[1] for p in points_q]), np.array([p[2] for p in points_q])
     t = np.linspace(0.0, 1.0, n_times)
     polynomial_array = np.array([bernstein_poly(i, n_points - 1, t) for i in range(n_points)])
-    x_vals, y_vals, z_vals = np.dot(x_points, polynomial_array), np.dot(y_points, polynomial_array), np.dot(z_points, polynomial_array)
+    x_vals = np.dot(x_points, polynomial_array)
+    y_vals = np.dot(y_points, polynomial_array)
+    z_vals = np.dot(z_points, polynomial_array)
     return x_vals, y_vals, z_vals
 
 def aprender_com_o_eco_3d(pontos_do_eco: list):
@@ -24,25 +34,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 (Motor Hyperdrive com Ambiente Fixo) ---
+# --- Função Principal do Gradio (O Motor Elegante) ---
 
 def motor_da_simulacao_infinita(angulo_camera: int):
-    """
-    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([12., 12., 12.])
+    ponto_a = np.array([quantizar(v) for v in [-40., 20., 10.]])
+    vetor_inercia = np.array([quantizar(v) for v in [30., 10., -20.]])
     historico_rastro = [ponto_a.tolist()]
 
     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)
+    
+    # --- NOVO: Setup para o Rastro em Degradê ---
+    cor_rastro = '#ff4500'
+    cmap = LinearSegmentedColormap.from_list("rastro_cmap", [(0, 0, 0, 0), cor_rastro], N=256)
+    # ---------------------------------------------
 
     ciclo_num = 0
     while True:
         ciclo_num += 1
         
-        ponto_b = np.random.rand(3) * 60 - 24 # Universo compacto
+        ponto_b_raw = np.random.rand(3) * 50 - 25
+        ponto_b = np.array([quantizar(v) for v in ponto_b_raw])
 
         ponto_controle = ponto_a + vetor_inercia
         pontos_curva = [ponto_a, ponto_controle, ponto_b]
@@ -50,59 +62,71 @@ 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 = 8
+        max_rastro = 150
         historico_rastro = historico_rastro[-max_rastro:]
         
-        tamanho_eco = 8
-        pontos_eco = list(zip(x_ciclo[-tamanho_eco:], y_ciclo[-tamanho_eco:], z_ciclo[-tamanho_eco:]))
+        tamanho_eco = 10
+        pontos_eco = historico_rastro[-tamanho_eco:]
         vetor_inercia = aprender_com_o_eco_3d(pontos_eco)["velocity_vector"]
-
-        rastro_np = np.array(historico_rastro)
         
         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='--')
-            
-            # --- 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=32., azim=angulo_camera)
-            # ------------------------------------------
-            
-            ax.set_xlim(-32, 32); ax.set_ylim(-32, 32); ax.set_zlim(-32, 32)
+            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([])
 
-            ax.scatter(*ponto_a, s=320, c='lime', alpha=0.4)
-            ax.scatter(*ponto_b, s=320, c='red', marker='X', alpha=0.8)
+            ax.scatter(*ponto_a, s=150, c='lime', alpha=0.7)
+            ax.scatter(*ponto_b, s=150, c='red', marker='X', alpha=0.9)
 
+            # --- LÓGICA DO RASTRO EM DEGRADÊ ---
+            tamanho_rastro_fixo = 12
             indice_global_frame = len(historico_rastro) - len(x_ciclo) + frame
-            ax.plot(rastro_np[:indice_global_frame+1, 0], rastro_np[:indice_global_frame+1, 1], rastro_np[:indice_global_frame+1, 2], '-', color='#ff4500', linewidth=4, alpha=0.6)
+            start_index = max(0, indice_global_frame - tamanho_rastro_fixo)
+            
+            rastro_atual = np.array(historico_rastro[start_index:indice_global_frame+1])
             
-            ax.plot([x_ciclo[frame]], [y_ciclo[frame]], [z_ciclo[frame]], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
+            if len(rastro_atual) > 1:
+                pontos = rastro_atual.reshape(-1, 1, 3)
+                segmentos = np.concatenate([pontos[:-1], pontos[1:]], axis=1)
+                
+                # Cria um array de cores com transparência crescente
+                alphas = np.linspace(0.0, 0.8, len(segmentos))
+                cores = cmap(np.arange(256))
+                cores[:,-1] = np.linspace(0, 1, 256)
+                grad_cmap = LinearSegmentedColormap.from_list('custom_alpha', cores)
+
+                lc = LineCollection(segmentos, cmap=grad_cmap, linewidth=4)
+                lc.set_array(np.linspace(0, 1, len(segmentos)))
+                ax.add_collection3d(lc, zs=rastro_atual[:, 2], zdir='z')
+
+            # ------------------------------------
+
+            ax.plot([x_ciclo[frame]], [y_ciclo[frame]], [z_ciclo[frame]], 'o', color=cor_rastro, markersize=8, markeredgecolor='white')
             
-            info_texto = f"Ciclo: {ciclo_num}\nAlvo: {np.round(ponto_b, 1)}"
-            ax.text2D(0.04, 0.88, info_texto, transform=ax.transAxes, color='white', fontsize=12)
+            info_texto = f"Ciclo: {ciclo_num}\nAlvo: {np.round(ponto_b)}"
+            ax.text2D(0.05, 0.95, info_texto, transform=ax.transAxes, color='white', fontsize=10)
             
             yield fig
-            time.sleep(0.008)
+            time.sleep(0.01)
 
         ponto_a = ponto_b
 
     plt.close(fig)
 
-# --- Interface Gradio ---
-with gr.Blocks(theme=gr.themes.Base(primary_hue="teal", secondary_hue="green")) as demo:
+# --- Interface Gradio (Inalterada) ---
+with gr.Blocks(theme=gr.themes.Base(primary_hue="purple", secondary_hue="orange")) as demo:
     gr.Markdown(
         """
-        # ⚡ 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**.
+        # ✨ Simulador Elegante 3D de Convergência
+        Uma simulação autônoma com física "quantizada" e um rastro de 12 vetores em degradê.
         """
     )
     with gr.Row():
         with gr.Column(scale=1):
-            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")
+            angulo_camera_slider = gr.Slider(-180, 180, value=25, label="Ângulo da Câmera (Fixo)")
+            start_btn = gr.Button("🚀 Iniciar Simulação Elegante", variant="primary")
         with gr.Column(scale=2):
             plot_output = gr.Plot(label="Visualização em Tempo Real")