Update app.py

app.py

@@ -2,139 +2,85 @@ 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 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))
-
+# --- Funções Matemáticas ---
+def bernstein_poly(i, n, t): return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
 def bezier_curve_3d(points, n_times=20):
-    n_points = len(points)
-    # Quantiza os pontos de controle
-    points_q = [np.array([quantizar(p[0]), quantizar(p[1]), quantizar(p[2])]) for p in points]
+    n_points = len(points); 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 = np.dot(x_points, polynomial_array)
-    y_vals = np.dot(y_points, polynomial_array)
-    z_vals = np.dot(z_points, polynomial_array)
+    x_vals, y_vals, z_vals = np.dot(x_points, polynomial_array), np.dot(y_points, polynomial_array), np.dot(z_points, polynomial_array)
     return x_vals, y_vals, z_vals
-
 def aprender_com_o_eco_3d(pontos_do_eco: list):
     if len(pontos_do_eco) < 2: return {"velocity_vector": np.array([0, 0, 0])}
     p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
     return {"velocity_vector": p2 - p1}
+def quantizar(valor, multiplo=4): return multiplo * round(valor / multiplo)
 
-# --- Função Principal do Gradio (O Motor Elegante) ---
-
+# --- Motor da Simulação ---
 def motor_da_simulacao_infinita(angulo_camera: int):
-    ponto_a = np.array([quantizar(v) for v in [-40., 20., 10.]])
-    vetor_inercia = np.array([quantizar(v) for v in [30., 10., -20.]])
+    ponto_a = np.array([quantizar(v) for v in [0., 0., 0.]])
+    vetor_inercia = np.array([quantizar(v) for v in [10., 10., 10.]])
     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_raw = np.random.rand(3) * 50 - 25
+        ciclo_num += 1; 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]
         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)
-        max_rastro = 150
-        historico_rastro = historico_rastro[-max_rastro:]
-        
-        tamanho_eco = 10
-        pontos_eco = historico_rastro[-tamanho_eco:]
+        historico_rastro = historico_rastro[-150:]
+        pontos_eco = historico_rastro[-10:]
         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='--')
-            ax.view_init(elev=30., azim=angulo_camera)
+            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.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=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Ê ---
+            ax.scatter(*ponto_a, s=150, c='lime', alpha=0.7); ax.scatter(*ponto_b, s=150, c='red', marker='X', alpha=0.9)
+            
+            # --- CORREÇÃO DO RASTRO EM DEGRADÊ ---
             tamanho_rastro_fixo = 12
             indice_global_frame = len(historico_rastro) - len(x_ciclo) + frame
             start_index = max(0, indice_global_frame - tamanho_rastro_fixo)
-            
-            rastro_atual = np.array(historico_rastro[start_index:indice_global_frame+1])
-            
+            rastro_atual = historico_rastro[start_index:indice_global_frame+1]
             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')
-
+                # Desenha cada segmento do rastro com uma transparência diferente
+                for i in range(len(rastro_atual) - 1):
+                    p1 = rastro_atual[i]; p2 = rastro_atual[i+1]
+                    alpha = 0.8 * (i / tamanho_rastro_fixo) # Calcula o alfa para o degradê
+                    ax.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], color='#ff4500', linewidth=4, alpha=alpha)
             # ------------------------------------
 
-            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)}"
-            ax.text2D(0.05, 0.95, info_texto, transform=ax.transAxes, color='white', fontsize=10)
-            
+            ax.plot([x_ciclo[frame]], [y_ciclo[frame]], [z_ciclo[frame]], 'o', color='#ff4500', markersize=8, markeredgecolor='white')
+            info_texto = f"Ciclo: {ciclo_num}\nAlvo: {np.round(ponto_b)}"; ax.text2D(0.05, 0.95, info_texto, transform=ax.transAxes, color='white')
             yield fig
             time.sleep(0.01)
-
         ponto_a = ponto_b
-
     plt.close(fig)
 
-# --- Interface Gradio (Inalterada) ---
+# --- Interface Gradio ---
 with gr.Blocks(theme=gr.themes.Base(primary_hue="purple", secondary_hue="orange")) as demo:
-    gr.Markdown(
-        """
-        # ✨ 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=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")
-
-    start_btn.click(
-        fn=motor_da_simulacao_infinita,
-        inputs=[angulo_camera_slider],
-        outputs=[plot_output]
-    )
+    gr.Markdown("# ✨ Simulador de Convergência Causal ✨"); gr.Markdown("### A Matemática do Próximo Passo")
+    with gr.Tabs():
+        with gr.TabItem("🔬 A Simulação"):
+            with gr.Row():
+                with gr.Column(scale=1):
+                    gr.Markdown("Controle a perspectiva da câmera e inicie a simulação. O agente (bola) irá navegar autonomamente, gerando novos alvos e deixando um rastro de inércia em degradê."); angulo_camera_slider = gr.Slider(-180, 180, value=25, label="Ângulo da Câmera (Fixo)"); start_btn = gr.Button("🚀 Iniciar Simulação", variant="primary")
+                with gr.Column(scale=2):
+                    plot_output = gr.Plot(label="Visualização em Tempo Real")
+        with gr.TabItem("📜 A Teoria"):
+            with open("explanation.md", "r", encoding="utf-8") as f: gr.Markdown(f.read())
+    start_btn.click(fn=motor_da_simulacao_infinita, inputs=[angulo_camera_slider], outputs=[plot_output])
 
 if __name__ == "__main__":
     demo.launch()