Create app.py

app.py

@@ -0,0 +1,166 @@
+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) ---
+
+def bernstein_poly(i, n, t):
+    """ O polinômio de Bernstein, base para as curvas de Bézier. """
+    return comb(n, i) * (t**(i)) * ((1 - t)**(n - i))
+
+def bezier_curve(points, n_times=1000):
+    """ Gera uma curva de Bézier a partir de uma lista de pontos de controle. """
+    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. """
+    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])
+    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
+    }
+
+# --- 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):
+    """
+    Gera e plota a jornada completa das duas crianças.
+    """
+    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])
+    
+    # 1. Gerar a curva da Criança A
+    pontos_curva_a = [PONTO_A, PONTO_INFLEXAO, PONTO_B]
+    x_a, y_a = bezier_curve(pontos_curva_a)
+    
+    # 2. Isolar o Eco
+    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
+    
+    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
+    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
+    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)
+
+    # 5. Plotagem
+    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='--')
+    
+    # Eco
+    ax.plot(x_eco, y_eco, label=f'Eco de Aprendizado ({tamanho_eco_percent}%)', color='magenta', linewidth=5)
+    
+    # Pontos de Controle
+    ax.plot(*zip(PONTO_A, PONTO_INFLEXAO, PONTO_B), 'o--', color='lightcoral', markersize=8, label='Pontos de Controle (Input)')
+    
+    # Anotação do Vetor
+    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),
+                fontsize=11, color='yellow',
+                bbox=dict(boxstyle="round,pad=0.3", fc="black", ec="yellow", lw=1))
+
+    # Configurações do Gráfico
+    ax.set_title('O Oráculo da Continuidade', 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()
+    
+    return caminho_figura
+
+# --- Interface Gradio ---
+
+with gr.Blocks(theme=gr.themes.Soft(primary_hue="teal", secondary_hue="orange")) as demo:
+    gr.Markdown(
+        """
+        # 🔮 O Oráculo da Continuidade
+        ### Um laboratório 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.
+        """
+    )
+    
+    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`.")
+            
+            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")
+
+    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
+    )
+
+if __name__ == "__main__":
+    demo.launch()