Update app.py

app.py

@@ -1,22 +1,11 @@
 
 
-# --- 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
 import math
 from scipy.special import comb
 
-# --- Funções Matemáticas (O Coração do Teorema) ---
+# --- Funções Matemáticas (O Coração do Teorema - sem alterações) ---
 
 def bernstein_poly(i, n, t):
     """ O polinômio de Bernstein, base para as curvas de Bézier. """
@@ -27,166 +16,111 @@ def bezier_curve(points, n_times=1000):
     n_points = len(points)
     x_points = np.array([p[0] for p in points])
     y_points = np.array([p[1] for p in points])
-
     t = np.linspace(0.0, 1.0, n_times)
     polynomial_array = np.array([bernstein_poly(i, n_points - 1, t) for i in range(0, n_points)])
-
     x_vals = np.dot(x_points, polynomial_array)
     y_vals = np.dot(y_points, polynomial_array)
-
     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.
-    Esta é a função de "aprendizado" da Criança B.
-    """
+    """ Calcula a essência do movimento (direção e vetor) do eco. """
     if len(pontos_do_eco) < 2:
         return {"bearing_rad": 0, "velocity_vector": np.array([0, 0])}
-
-    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)
-    
+    p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
     vetor_velocidade = p2 - p1
-    delta_x, delta_y = vetor_velocidade
-    bearing_radianos = math.atan2(delta_y, delta_x)
-    
-    return {
-        "bearing_rad": bearing_radianos,
-        "velocity_vector": vetor_velocidade
-    }
+    bearing_radianos = math.atan2(vetor_velocidade[1], vetor_velocidade[0])
+    return {"bearing_rad": bearing_radianos, "velocity_vector": vetor_velocidade}
 
-# --- Função Principal do Gradio (A Interface do Oráculo) ---
+# --- Simulação com os Dados de Entrada Fornecidos ---
 
-def gerar_grafico_continuidade(p_inflexao_x, p_inflexao_y, p_b_x, p_b_y, tamanho_eco_percent=15):
+def simular_jornada_especifica():
     """
-    Gera e plota a jornada completa das duas crianças, com a Criança B
-    completando sua trajetória até um destino final.
+    Executa a simulação com os pontos-chave definidos pelo Arquiteto
+    e plota o resultado.
     """
-    # 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. DEFINIÇÃO DOS PONTOS DA JORNADA
+    # A trajetória da Criança A é definida por estes 4 vetores (pontos)
+    p1 = np.array([0, 0])      # Vetor x1, y=0
+    p2 = np.array([25, 15])     # Vetor x2, y=15 (Assumindo um X para visualização)
+    p3 = np.array([50, 30])     # Vetor x3, y=30 (Assumindo um X para visualização)
+    p4_encontro = np.array([75, 45]) # Vetor x4, y=45 (Ponto de Handover)
+
+    # O destino da Criança B
+    p5_destino = np.array([100, 90]) # Vetor final, y=90 (Assumindo um X para o destino)
     
-    # 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, n_times=1000)
+    # Número de pontos a serem usados como "eco de memória"
+    NUMERO_DE_VETORES_ECO = 150 # Equivalente a 15% de 1000 pontos
     
-    # 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 para o cálculo
+    print(f"--- DADOS DE ENTRADA ---")
+    print(f"Caminho da Criança A definido por: {p1}, {p2}, {p3}, {p4_encontro}")
+    print(f"Destino da Criança B: {p5_destino}")
+    print(f"Número de vetores no Eco de Memória: {NUMERO_DE_VETORES_ECO}")
+    print("------------------------\n")
+    
+    # 2. GERAR A CURVA DA CRIANÇA A
+    # Usamos os 4 pontos para criar uma curva de Bézier cúbica, mais complexa.
+    pontos_curva_a = [p1, p2, p3, p4_encontro]
+    x_a, y_a = bezier_curve(pontos_curva_a, n_times=1000)
     
-    x_eco = x_a[-tamanho_eco_int:]
-    y_eco = y_a[-tamanho_eco_int:]
+    # 3. ISOLAR O ECO
+    x_eco = x_a[-NUMERO_DE_VETORES_ECO:]
+    y_eco = y_a[-NUMERO_DE_VETORES_ECO:]
     pontos_do_eco = list(zip(x_eco, y_eco))
     
-    # 3. Criança B aprende com o Eco, extraindo a inércia do movimento
+    # 4. CRIANÇA B APRENDE COM O ECO
     essencia_movimento = aprender_com_o_eco(pontos_do_eco)
     vetor_aprendido = essencia_movimento["velocity_vector"]
     
-    # 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
+    print("--- APRENDIZADO DA CRIANÇA B ---")
+    print(f"Vetor de Inércia aprendido no Eco: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f})")
+    print(f"Direção final da Criança A: {math.degrees(essencia_movimento['bearing_rad']):.2f} graus")
+    print("------------------------------\n")
     
-    # 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]
+    # 5. GERAR A CURVA DA CRIANÇA B
+    # O ponto de controle que define a tangente de saída é o ponto de encontro + o vetor aprendido
+    ponto_controle_b = p4_encontro + vetor_aprendido
+    # A curva vai do ponto de encontro ao destino, guiada pelo ponto de controle
+    pontos_curva_b = [p4_encontro, ponto_controle_b, p5_destino]
     x_b, y_b = bezier_curve(pontos_curva_b, n_times=1000)
-
-    # 5. Plotagem e Visualização
-    plt.style.use('dark_background')
-    fig, ax = plt.subplots(figsize=(10, 10))
-    
-    # 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)
     
-    # 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)
+    # 6. PLOTAGEM COM FUNDO PRETO E EIXOS VISÍVEIS
+    fig, ax = plt.subplots(figsize=(12, 9))
+    fig.patch.set_facecolor('black')
+    ax.set_facecolor('black')
+
+    # Configuração dos eixos para serem visíveis
+    ax.spines['bottom'].set_color('white')
+    ax.spines['left'].set_color('white')
+    ax.spines['top'].set_color('black')
+    ax.spines['right'].set_color('black')
+    ax.tick_params(axis='x', colors='white')
+    ax.tick_params(axis='y', colors='white')
+
+    # Plot das curvas
+    ax.plot(x_a, y_a, label='Caminho da Criança A', color='cyan', linewidth=2)
+    ax.plot(x_b, y_b, label='Continuidade da Criança B', color='lime', linewidth=2, linestyle='--')
     
-    # 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)
+    # Destaque do Eco
+    ax.plot(x_eco, y_eco, label=f'Eco de Memória ({NUMERO_DE_VETORES_ECO} vetores)', color='magenta', linewidth=4)
     
-    # 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] + 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),
-                zorder=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)
+    # Plot dos pontos chave
+    pontos_chave = np.array([p1, p2, p3, p4_encontro, p5_destino])
+    ax.plot(pontos_chave[:,0], pontos_chave[:,1], 'o', color='red', markersize=8, label='Pontos-Chave Definidos')
+    ax.plot(p4_encontro[0], p4_encontro[1], 'o', color='yellow', markersize=10, label='Ponto de Encontro')
+
+    # Títulos e legendas
+    ax.set_title('Demonstração do Teorema da Continuidade', color='white', fontsize=16)
+    ax.set_xlabel('Eixo X', color='white', fontsize=12)
+    ax.set_ylabel('Eixo Y', color='white', fontsize=12)
+    legend = ax.legend(facecolor='gray', edgecolor='white', framealpha=0.1)
+    for text in legend.get_texts():
+        text.set_color('white')
+
+    ax.grid(True, linestyle='--', color='gray', alpha=0.5)
     ax.set_aspect('equal', adjustable='box')
-    ax.set_xlabel("Eixo X")
-    ax.set_ylabel("Eixo Y")
-    
-    # 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="cyan", secondary_hue="orange")) as demo:
-    gr.Markdown(
-        """
-        # 🔮 O Oráculo da Continuidade
-        ### 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" 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]`, 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)")
-            
-            p_b_x = gr.Slider(-100, 100, value=50, label="Ponto B (Final da Criança A)")
-            p_b_y = gr.Slider(-100, 100, value=50, label="Ponto B (Final da Criança A)")
-            
-            tamanho_eco_percent = gr.Slider(1, 50, value=15, step=1, label="Tamanho do Eco de Aprendizado (%)")
-            
-            run_button = gr.Button("Gerar Continuidade", variant="primary")
-            
-        with gr.Column(scale=2):
-            gr.Markdown("**2. Observe a Continuidade Gerada**")
-            output_plot = gr.Image(label="Gráfico da Jornada", type="filepath")
-
-    run_button.click(
-        fn=gerar_grafico_continuidade,
-        inputs=[p_inflexao_x, p_inflexao_y, p_b_x, p_b_y, tamanho_eco_percent],
-        outputs=output_plot
-    )
-
-    gr.Examples(
-        examples=[
-            [50, 100, 100, 0, 10],
-            [-50, 50, 0, 100, 20],
-            [80, 20, 40, 90, 5],
-            [25, -75, 75, -25, 30]
-        ],
-        inputs=[p_inflexao_x, p_inflexao_y, p_b_x, p_b_y, tamanho_eco_percent],
-        outputs=output_plot,
-        fn=gerar_grafico_continuidade,
-        cache_examples=True
-    )
+    plt.show()
 
+# --- Execução do Script ---
 if __name__ == "__main__":
-    demo.launch()
+    simular_jornada_especifica()