Update app.py

app.py

@@ -15,7 +15,7 @@ from PIL import Image
 def bernstein_poly(i, n, t):
     return comb(n, i) * (t**i) * ((1-t)**(n-i))
 
-def bezier_curve(points, n_times=20):  # original usa 20
+def bezier_curve(points, n_times=20):
     points = np.array(points)
     t = np.linspace(0, 1, n_times)
     n = len(points) - 1
@@ -34,7 +34,7 @@ def learn_from_echo(echo_points):
     return p2 - p1
 
 # ============================================================
-# SIMULAÇÃO COM RASTRO IDÊNTICO AO ORIGINAL
+# SIMULAÇÃO COM RASTRO IDÊNTICO AO ORIGINAL + ESFERA TRANSPARENTE
 # ============================================================
 
 class CometSimulation:
@@ -69,24 +69,26 @@ class CometSimulation:
         dpi = 100
         fig = plt.figure(figsize=(12, 8), dpi=dpi)
         
-        # Layout: 3D à esquerda, info à direita
+        # Layout: 3D à esquerda (2/3), painéis à direita (1/3)
         gs = fig.add_gridspec(2, 3, hspace=0.3, wspace=0.3)
         
         ax_3d = fig.add_subplot(gs[:, 0:2], projection='3d')
-        ax_info = fig.add_subplot(gs[0, 2])
-        ax_stats = fig.add_subplot(gs[1, 2])
+        ax_info = fig.add_subplot(gs[0, 2])   # estatísticas de inércia
+        ax_stats = fig.add_subplot(gs[1, 2])  # posição atual
         
         bg_color = '#0a0a0a'
         fig.patch.set_facecolor(bg_color)
         for ax in [ax_3d, ax_info, ax_stats]:
             ax.set_facecolor(bg_color)
         
-        # Esfera transparente de referência
+        # ========== ESFERA TRANSPARENTE (MELHORIA VISUAL) ==========
+        # Malha da esfera – referência espacial sem poluir
         u = np.linspace(0, 2*np.pi, 20)
         v = np.linspace(0, np.pi, 15)
         sphere_x = 28 * np.outer(np.cos(u), np.sin(v))
         sphere_y = 28 * np.outer(np.sin(u), np.sin(v))
         sphere_z = 28 * np.outer(np.ones_like(u), np.cos(v))
+        # ============================================================
         
         cycle = 0
         frame_global = 0
@@ -94,7 +96,7 @@ class CometSimulation:
         while self.running:
             cycle += 1
             
-            # Ângulo da câmera
+            # Ângulo da câmera (com rotação automática opcional)
             if auto_rotate:
                 current_angle = (camera_angle + frame_global * 0.8) % 360
             else:
@@ -146,19 +148,17 @@ class CometSimulation:
                 ax_3d.set_yticklabels([])
                 ax_3d.set_zticklabels([])
                 
-                # Esfera transparente (adicional, não atrapalha)
+                # ========== DESENHA A ESFERA TRANSPARENTE ==========
                 ax_3d.plot_wireframe(sphere_x, sphere_y, sphere_z, 
                                     color='#4488ff', alpha=0.1, linewidth=0.5)
+                # ===================================================
                 
                 # ===== ELEMENTOS ESTÁTICOS (igual ao original) =====
-                # Ponto atual (início do ciclo) - verde no original
-                ax_3d.scatter(*current_point, s=150, c='lime', alpha=0.7)
-                
-                # Alvo - X vermelho
-                ax_3d.scatter(*target, s=150, c='red', marker='X', alpha=0.9)
+                ax_3d.scatter(*current_point, s=150, c='lime', alpha=0.7)  # ponto inicial do ciclo
+                ax_3d.scatter(*target, s=150, c='red', marker='X', alpha=0.9)  # alvo
                 
                 # ===== RASTRO IDÊNTICO AO ORIGINAL =====
-                # Calcula índices do rastro (últimos 12 pontos ANTES do atual)
+                # Índices: últimos 12 pontos antes do frame atual
                 trail_end = len(history) - len(x_cycle) + frame_idx
                 trail_start = max(0, trail_end - 12)
                 trail_segment = history[trail_start:trail_end+1]
@@ -166,7 +166,7 @@ class CometSimulation:
                 if len(trail_segment) > 1:
                     for i in range(len(trail_segment) - 1):
                         p1, p2 = trail_segment[i], trail_segment[i+1]
-                        # Alpha = 0.8 * (i/12) - EXATAMENTE como no original
+                        # Alpha = 0.8 * (i/12) – exatamente como no original
                         alpha = 0.8 * (i / 12)
                         ax_3d.plot([p1[0], p2[0]], [p1[1], p2[1]], [p1[2], p2[2]], 
                                   color='#ff4500', linewidth=4, alpha=alpha)
@@ -181,35 +181,28 @@ class CometSimulation:
                             color='white', fontsize=10,
                             bbox=dict(boxstyle='round', facecolor='#222222', alpha=0.7))
                 
-                # ===== PAINEL INFO =====
-                ax_info.set_title('📊 ESTATÍSTICAS', color='white', fontsize=11)
+                # ===== PAINEL INFO (MELHORIA) =====
+                ax_info.set_title('📊 INÉRCIA', color='white', fontsize=11)
                 ax_info.axis('off')
-                
-                inertia_text = f"""INÉRCIA:
+                inertia_text = f"""Vetor:
 ({inertia[0]:.1f}, {inertia[1]:.1f}, {inertia[2]:.1f})
 
-HISTÓRICO: {len(history)} pontos
-
-ECO: {len(echo_points)} pontos"""
-                
+Histórico: {len(history)} pontos
+Eco: {len(echo_points)} pontos"""
                 ax_info.text(0.1, 0.8, inertia_text, transform=ax_info.transAxes,
                             color='#ffaa00', fontsize=9, verticalalignment='top')
                 
-                # ===== PAINEL STATS =====
-                ax_stats.set_title('📍 POSIÇÃO ATUAL', color='white', fontsize=11)
+                # ===== PAINEL STATS (MELHORIA) =====
+                ax_stats.set_title('📍 POSIÇÃO', color='white', fontsize=11)
                 ax_stats.axis('off')
-                
                 pos_text = f"""X: {x_cycle[frame_idx]:.1f}
 Y: {y_cycle[frame_idx]:.1f}
 Z: {z_cycle[frame_idx]:.1f}"""
-                
                 ax_stats.text(0.1, 0.6, pos_text, transform=ax_stats.transAxes,
                              color='#88ccff', fontsize=12, fontweight='bold')
                 
-                # Renderiza
+                # Renderiza e envia
                 fig.canvas.draw()
-                
-                # Converte para array
                 buf = io.BytesIO()
                 fig.savefig(buf, format='png', dpi=dpi, 
                            facecolor=bg_color, bbox_inches='tight',
@@ -220,19 +213,18 @@ Z: {z_cycle[frame_idx]:.1f}"""
                     self.queue.put(buf)
                 
                 time.sleep(0.01)  # igual ao original
-                
+            
             # Prepara próximo ciclo
             pos = target
 
 # ============================================================
-# INTERFACE
+# INTERFACE GRADIO (COM ROTAÇÃO E PAINÉIS)
 # ============================================================
 
 simulation = CometSimulation()
 
 def get_frame(camera_angle, auto_rotate):
     queue = simulation.start(camera_angle, auto_rotate)
-    
     try:
         while True:
             buf = queue.get(timeout=1.0)
@@ -243,18 +235,13 @@ def get_frame(camera_angle, auto_rotate):
     finally:
         simulation.stop()
 
-# Interface
-with gr.Blocks(theme=gr.themes.Base(
-    primary_hue="purple", 
-    secondary_hue="orange",
-)) as demo:
-    
+with gr.Blocks(theme=gr.themes.Base(primary_hue="purple", secondary_hue="orange")) as demo:
     gr.HTML("""
     <div style="text-align: center; margin-bottom: 15px;">
         <h1 style="color: #ff4500; font-size: 2.2rem; margin: 0;">
             ✨ CAUSAL CONVERGENCE SIMULATOR ✨
         </h1>
-        <p style="color: #cccccc;">rastro idêntico ao original • esfera transparente</p>
+        <p style="color: #cccccc;">rastro original • esfera transparente • estatísticas</p>
     </div>
     """)