Update app.py

app.py

@@ -1,3 +1,15 @@
+
+
+# --- ORÁCULO DA CONTINUIDADE ---
+# Um laboratório interativo para o Teorema das Crianças
+# By Carlex & Gemini
+#
+# OBJETIVO:
+# Demonstrar visualmente como a continuidade de movimento pode ser alcançada
+# a partir de informação parcial (um "eco"). O sistema aprende a "inércia"
+# final de uma trajetória (Criança A) e a usa como condição inicial para
+# gerar uma nova trajetória suave e coerente (Criança B).
+
 import gradio as gr
 import numpy as np
 import matplotlib.pyplot as plt
@@ -25,12 +37,16 @@ def bezier_curve(points, n_times=1000):
     return x_vals, y_vals
 
 def aprender_com_o_eco(pontos_do_eco: list) -> dict:
-    """ Calcula a essência do movimento (direção e vetor) do eco. """
+    """ 
+    Calcula a essência do movimento (direção e vetor) do eco.
+    Esta é a função de "aprendizado" da Criança B.
+    """
     if len(pontos_do_eco) < 2:
         return {"bearing_rad": 0, "velocity_vector": np.array([0, 0])}
 
-    p1 = np.array(pontos_do_eco[0])
-    p2 = np.array(pontos_do_eco[-1])
+    p1 = np.array(pontos_do_eco[0])  # Ponto de início da observação
+    p2 = np.array(pontos_do_eco[-1]) # Ponto final da observação (ponto de handover)
+    
     vetor_velocidade = p2 - p1
     delta_x, delta_y = vetor_velocidade
     bearing_radianos = math.atan2(delta_y, delta_x)
@@ -42,92 +58,102 @@ def aprender_com_o_eco(pontos_do_eco: list) -> dict:
 
 # --- Função Principal do Gradio (A Interface do Oráculo) ---
 
-def gerar_grafico_continuidade(p_inflexao_x, p_inflexao_y, p_b_x, p_b_y, tamanho_eco_percent=10):
+def gerar_grafico_continuidade(p_inflexao_x, p_inflexao_y, p_b_x, p_b_y, tamanho_eco_percent=15):
     """
-    Gera e plota a jornada completa das duas crianças.
+    Gera e plota a jornada completa das duas crianças, com a Criança B
+    completando sua trajetória até um destino final.
     """
+    # Pontos de controle da jornada
     PONTO_A = np.array([0, 0])
     PONTO_INFLEXAO = np.array([p_inflexao_x, p_inflexao_y])
     PONTO_B = np.array([p_b_x, p_b_y])
+    PONTO_C_DESTINO = np.array([100, 100]) # O destino final da Criança B
     
-    # 1. Gerar a curva da Criança A
+    # 1. Gerar a curva da Criança A usando Bézier
     pontos_curva_a = [PONTO_A, PONTO_INFLEXAO, PONTO_B]
-    x_a, y_a = bezier_curve(pontos_curva_a)
+    x_a, y_a = bezier_curve(pontos_curva_a, n_times=1000)
     
-    # 2. Isolar o Eco
+    # 2. Isolar o Eco (a memória parcial)
     tamanho_eco_int = int(len(x_a) * (tamanho_eco_percent / 100))
-    if tamanho_eco_int < 2: tamanho_eco_int = 2 # Garante um eco mínimo
+    if tamanho_eco_int < 2: tamanho_eco_int = 2 # Garante um eco mínimo para o cálculo
     
     x_eco = x_a[-tamanho_eco_int:]
     y_eco = y_a[-tamanho_eco_int:]
     pontos_do_eco = list(zip(x_eco, y_eco))
     
-    # 3. Criança B aprende com o Eco
+    # 3. Criança B aprende com o Eco, extraindo a inércia do movimento
     essencia_movimento = aprender_com_o_eco(pontos_do_eco)
     vetor_aprendido = essencia_movimento["velocity_vector"]
     
-    # 4. Gerar a curva da Criança B
-    # O ponto de controle para a curva B é B + vetor_aprendido, para definir a tangente
+    # 4. Gerar a curva da Criança B (A Jornada Completa)
+    # O ponto de controle que define a tangente de saída de B é B + vetor_aprendido.
+    # Este ponto "puxa" a curva na direção correta, garantindo a suavidade.
     ponto_controle_b = PONTO_B + vetor_aprendido
-    # O ponto final da Criança B pode ser uma extrapolação
-    ponto_final_b = PONTO_B + vetor_aprendido * 3 
     
-    pontos_curva_b = [PONTO_B, ponto_controle_b, ponto_final_b]
-    x_b, y_b = bezier_curve(pontos_curva_b)
+    # A curva da Criança B agora vai do Ponto B ao Ponto C (Destino),
+    # sendo guiada pelo ponto de controle que representa a inércia aprendida.
+    pontos_curva_b = [PONTO_B, ponto_controle_b, PONTO_C_DESTINO]
+    x_b, y_b = bezier_curve(pontos_curva_b, n_times=1000)
 
-    # 5. Plotagem
+    # 5. Plotagem e Visualização
     plt.style.use('dark_background')
     fig, ax = plt.subplots(figsize=(10, 10))
     
-    # Curvas
-    ax.plot(x_a, y_a, label='Caminho da Criança A', color='cyan', linewidth=2.5)
-    ax.plot(x_b, y_b, label='Continuidade da Criança B (Gerado)', color='lime', linewidth=2.5, linestyle='--')
+    # Plot das Curvas das Crianças
+    ax.plot(x_a, y_a, label='Caminho da Criança A', color='cyan', linewidth=2.5, zorder=5)
+    ax.plot(x_b, y_b, label='Continuidade da Criança B (Gerado)', color='lime', linewidth=2.5, linestyle='--', zorder=5)
     
-    # Eco
-    ax.plot(x_eco, y_eco, label=f'Eco de Aprendizado ({tamanho_eco_percent}%)', color='magenta', linewidth=5)
+    # Destaque do Eco de Aprendizado
+    ax.plot(x_eco, y_eco, label=f'Eco de Aprendizado ({tamanho_eco_percent}%)', color='magenta', linewidth=5, zorder=10)
     
-    # Pontos de Controle
-    ax.plot(*zip(PONTO_A, PONTO_INFLEXAO, PONTO_B), 'o--', color='lightcoral', markersize=8, label='Pontos de Controle (Input)')
+    # Plot da Estrutura de Controle (para fins didáticos)
+    pontos_de_controle_completos = np.array([PONTO_A, PONTO_INFLEXAO, PONTO_B, ponto_controle_b, PONTO_C_DESTINO])
+    ax.plot(pontos_de_controle_completos[:, 0], pontos_de_controle_completos[:, 1], 'o--', color='lightcoral', markersize=8, alpha=0.6, label='Estrutura de Controle', zorder=2)
     
-    # Anotação do Vetor
+    # Destaque dos Pontos Principais
+    ax.plot(PONTO_B[0], PONTO_B[1], 'o', color='yellow', markersize=12, markeredgecolor='black', label='Ponto de Handover (B)', zorder=15)
+    ax.plot(PONTO_C_DESTINO[0], PONTO_C_DESTINO[1], 'X', color='red', markersize=12, markeredgecolor='white', label='Destino Final (C)', zorder=15)
+
+    # Anotação do Vetor de Inércia Aprendido
     ax.annotate(f'Vetor de Inércia\n({vetor_aprendido[0]:.1f}, {vetor_aprendido[1]:.1f})',
                 xy=PONTO_B, 
-                xytext=(PONTO_B[0] + 5, PONTO_B[1] + 5),
-                arrowprops=dict(facecolor='yellow', shrink=0.05, width=1.5, headwidth=10),
+                xytext=(PONTO_B[0] + 5, PONTO_B[1] + 15),
+                arrowprops=dict(facecolor='yellow', shrink=0.05, width=1.5, headwidth=10, connectionstyle="arc3,rad=.2"),
                 fontsize=11, color='yellow',
-                bbox=dict(boxstyle="round,pad=0.3", fc="black", ec="yellow", lw=1))
+                bbox=dict(boxstyle="round,pad=0.3", fc="black", ec="yellow", lw=1),
+                zorder=20)
 
-    # Configurações do Gráfico
-    ax.set_title('O Oráculo da Continuidade', fontsize=18, pad=20)
+    # Configurações Finais do Gráfico
+    ax.set_title('O Oráculo da Continuidade: Jornada Completa', fontsize=18, pad=20)
     ax.legend(loc='best')
     ax.grid(True, linestyle='--', alpha=0.2)
     ax.set_aspect('equal', adjustable='box')
     ax.set_xlabel("Eixo X")
     ax.set_ylabel("Eixo Y")
     
-    # Salvar a figura para o Gradio exibir
-    caminho_figura = "continuidade.png"
-    plt.savefig(caminho_figura, bbox_inches='tight', pad_inches=0.1, dpi=120)
-    plt.close()
+    # Salva a figura para o Gradio exibir
+    caminho_figura = "continuidade_completa.png"
+    plt.savefig(caminho_figura, bbox_inches='tight', pad_inches=0.1, dpi=120, transparent=True)
+    plt.close(fig)
     
     return caminho_figura
 
 # --- Interface Gradio ---
 
-with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange")) as demo:
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="cyan", secondary_hue="orange")) as demo:
     gr.Markdown(
         """
         # 🔮 O Oráculo da Continuidade
-        ### Um laboratório para o Teorema das Crianças
+        ### Um laboratório interativo para o Teorema das Crianças
         Defina a trajetória da "Criança A" especificando dois pontos de controle. O Oráculo irá calcular a "inércia" do movimento final 
-        e gerar a continuação da "Criança B", garantindo uma transição perfeitamente suave.
+        e gerar a continuação da "Criança B" até o destino final, garantindo uma transição perfeitamente suave.
         """
     )
     
     with gr.Row():
         with gr.Column(scale=1):
             gr.Markdown("**1. Defina o Caminho da Criança A**")
-            gr.Markdown("O caminho começa em `[0,0]` e termina no `Ponto B`, passando pelo `Ponto de Inflexão`.")
+            gr.Markdown("O caminho começa em `[0,0]`, passa pelo `Ponto de Inflexão` e termina no `Ponto B`.")
             
             p_inflexao_x = gr.Slider(-100, 100, value=25, label="Ponto de Inflexão (X)")
             p_inflexao_y = gr.Slider(-100, 100, value=75, label="Ponto de Inflexão (Y)")
@@ -141,7 +167,7 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
             
         with gr.Column(scale=2):
             gr.Markdown("**2. Observe a Continuidade Gerada**")
-            output_plot = gr.Image(label="Gráfico da Jornada")
+            output_plot = gr.Image(label="Gráfico da Jornada", type="filepath")
 
     run_button.click(
         fn=gerar_grafico_continuidade,
@@ -163,4 +189,4 @@ with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange"))
     )
 
 if __name__ == "__main__":
-    demo.launch()
+    demo.launch()