Update app.py

app.py

@@ -1,124 +1,122 @@
 import gradio as gr
 import numpy as np
-import matplotlib.pyplot as plt
+import plotly.graph_objects as go
 import math
 from scipy.special import comb
 
-# --- Funções Matemáticas (O Coração do Teorema - sem alterações) ---
+# --- Funções Matemáticas (Adaptadas para 3D) ---
 
 def bernstein_poly(i, n, t):
-    """ O polinômio de Bernstein, base para as curvas de Bézier. """
+    """ O polinômio de Bernstein (base para 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. """
+def bezier_curve_3d(points, n_times=100):
+    """ Gera uma curva de Bézier 3D a partir 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])
+    z_points = np.array([p[2] 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)])
+    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)
-    return x_vals, y_vals
+    z_vals = np.dot(z_points, polynomial_array)
+    return x_vals, y_vals, z_vals
 
-def aprender_com_o_eco(pontos_do_eco: list) -> dict:
-    """ Calcula a essência do movimento (direção e vetor) do eco. """
+def aprender_com_o_eco_3d(pontos_do_eco: list) -> dict:
+    """ Calcula a essência do movimento 3D (vetor) do eco. """
     if len(pontos_do_eco) < 2:
-        return {"bearing_rad": 0, "velocity_vector": np.array([0, 0])}
+        return {"velocity_vector": np.array([0, 0, 0])}
     p1, p2 = np.array(pontos_do_eco[0]), np.array(pontos_do_eco[-1])
     vetor_velocidade = p2 - p1
-    bearing_radianos = math.atan2(vetor_velocidade[1], vetor_velocidade[0])
-    return {"bearing_rad": bearing_radianos, "velocity_vector": vetor_velocidade}
+    return {"velocity_vector": vetor_velocidade}
 
-# --- Função Principal do Gradio (A Interface do Laboratório Completo) ---
+# --- Função Principal do Gradio (O Laboratório 3D Interativo) ---
 
-def gerar_grafico_dinamico(inflexao1_x, inflexao1_y, inflexao2_x, inflexao2_y, destino_x, destino_y, eco_vetores):
+def gerar_grafico_3d_dinamico(
+    inflexao1_x, inflexao1_y, inflexao1_z,
+    inflexao2_x, inflexao2_y, inflexao2_z,
+    eco_vetores
+):
     """
-    Gera e plota a jornada com os caminhos da Criança A e B sendo totalmente dinâmicos.
+    Gera e plota a jornada 3D completa com base nos inputs da UI.
     """
-    # 1. DEFINIÇÃO DOS PONTOS DA JORNADA, AGORA QUASE TODOS DINÂMICOS
-    p1_inicio = np.array([0, 0])
+    # 1. DEFINIÇÃO DOS PONTOS DA JORNADA
+    p1_inicio = np.array([0, 0, 0])
+    p2_inflexao1 = np.array([inflexao1_x, inflexao1_y, inflexao1_z])
+    p3_inflexao2 = np.array([inflexao2_x, inflexao2_y, inflexao2_z])
+    p4_encontro = np.array([75, 45, 10])
     
-    # Pontos de inflexão da Criança A (vindo da UI)
-    p2_inflexao1 = np.array([inflexao1_x, inflexao1_y])
-    p3_inflexao2 = np.array([inflexao2_x, inflexao2_y])
+    # Para o loop, o destino final deve ser o ponto de início.
+    p5_destino = p1_inicio
     
-    # Ponto de encontro é o ponto final da Criança A e o inicial da B.
-    # Vamos fixá-lo para manter um ponto de referência estável.
-    p4_encontro = np.array([75, 45])
-    
-    # Destino da Criança B (vindo da UI)
-    p5_destino = np.array([destino_x, destino_y])
-    
-    # 2. GERAR A CURVA DINÂMICA DA CRIANÇA A
+    # 2. GERAR A CURVA DA CRIANÇA A
     pontos_curva_a = [p1_inicio, p2_inflexao1, p3_inflexao2, p4_encontro]
-    x_a, y_a = bezier_curve(pontos_curva_a, n_times=1000)
-    
-    # 3. ISOLAR O ECO
-    NUMERO_DE_VETORES_ECO = int(eco_vetores)
-    if NUMERO_DE_VETORES_ECO < 2: NUMERO_DE_VETORES_ECO = 2
-    
-    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))
-    
-    # 4. CRIANÇA B APRENDE COM O ECO
-    essencia_movimento = aprender_com_o_eco(pontos_do_eco)
-    vetor_aprendido = essencia_movimento["velocity_vector"]
-    
-    # 5. GERAR A CURVA DINÂMICA DA CRIANÇA B
+    x_a, y_a, z_a = bezier_curve_3d(pontos_curva_a)
+    caminho_a = list(zip(x_a, y_a, z_a))
+
+    # 3. APRENDER COM O ECO
+    num_eco = int(eco_vetores)
+    if num_eco < 2: num_eco = 2
+    pontos_do_eco = caminho_a[-num_eco:]
+    vetor_aprendido = aprender_com_o_eco_3d(pontos_do_eco)["velocity_vector"]
+
+    # 4. GERAR A CURVA DA CRIANÇA B
     ponto_controle_b = p4_encontro + vetor_aprendido
-    pontos_curva_b = [p4_encontro, ponto_controle_b, p5_destino]
-    x_b, y_b = bezier_curve(pontos_curva_b, n_times=1000)
-    
-    # 6. PLOTAGEM COMPLETA
-    fig, ax = plt.subplots(figsize=(12, 9))
-    fig.patch.set_facecolor('black')
-    ax.set_facecolor('black')
-
-    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')
-
-    ax.plot(x_a, y_a, label='Caminho da Criança A (Seu Input)', color='cyan', linewidth=2)
-    ax.plot(x_b, y_b, label='Continuidade da Criança B (Gerado)', color='lime', linewidth=2, linestyle='--')
-    ax.plot(x_eco, y_eco, label=f'Eco de Memória ({NUMERO_DE_VETORES_ECO} vetores)', color='magenta', linewidth=4)
-    
-    pontos_controle_completos = np.array([p1_inicio, p2_inflexao1, p3_inflexao2, p4_encontro, ponto_controle_b, p5_destino])
-    ax.plot(pontos_controle_completos[:, 0], pontos_controle_completos[:, 1], 'o--', color='lightcoral', markersize=8, alpha=0.6, label='Estrutura de Controle')
-    
-    ax.plot(p4_encontro[0], p4_encontro[1], 'o', color='yellow', markersize=12, markeredgecolor='black', label='Ponto de Encontro (Fixo)')
-    ax.plot(p5_destino[0], p5_destino[1], 'X', color='red', markersize=12, markeredgecolor='white', label='Destino da Criança B')
-
-    ax.set_title('Laboratório de Continuidade Causal', 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='#111111', edgecolor='white', framealpha=0.5)
-    for text in legend.get_texts():
-        text.set_color('white')
-
-    ax.grid(True, linestyle='--', color='gray', alpha=0.3)
-    ax.set_aspect('equal', adjustable='box')
+    ponto_inflexao_retorno = p1_inicio - vetor_aprendido * 0.5
+    pontos_curva_b = [p4_encontro, ponto_controle_b, ponto_inflexao_retorno, p5_destino]
+    x_b, y_b, z_b = bezier_curve_3d(pontos_curva_b)
+
+    # 5. PREPARAR DADOS PARA O PLOTLY
+    
+    # Caminho A
+    trace_a = go.Scatter3d(x=x_a, y=y_a, z=z_a, mode='lines', line=dict(color='cyan', width=5), name='Caminho A (Passado)')
+    
+    # Caminho B
+    trace_b = go.Scatter3d(x=x_b, y=y_b, z=z_b, mode='lines', line=dict(color='lime', width=5, dash='dash'), name='Caminho B (Convergência)')
+    
+    # Eco de Memória
+    x_eco, y_eco, z_eco = zip(*pontos_do_eco)
+    trace_eco = go.Scatter3d(x=x_eco, y=y_eco, z=z_eco, mode='lines', line=dict(color='magenta', width=10), name=f'Eco de Memória ({num_eco} vetores)')
+    
+    # Pontos de Controle e Waypoints
+    pontos_controle = np.array([p1_inicio, p2_inflexao1, p3_inflexao2, p4_encontro, ponto_controle_b, ponto_inflexao_retorno, p5_destino])
+    trace_controle = go.Scatter3d(x=pontos_controle[:,0], y=pontos_controle[:,1], z=pontos_controle[:,2], mode='markers', marker=dict(color='lightcoral', size=5), name='Estrutura de Controle')
+    
+    waypoints = np.array([p1_inicio, p4_encontro])
+    trace_waypoints = go.Scatter3d(x=waypoints[:,0], y=waypoints[:,1], z=waypoints[:,2], mode='markers', marker=dict(color=['cyan', 'yellow'], size=12, symbol=['circle', 'diamond']), name='Waypoints (Início/Encontro)')
+
+    # 6. CRIAR A FIGURA PLOTLY
+    layout = go.Layout(
+        title=dict(text='Laboratório de Continuidade Causal 3D', font=dict(color='white')),
+        scene=dict(
+            xaxis_title='Eixo X',
+            yaxis_title='Eixo Y',
+            zaxis_title='Eixo Z',
+            xaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
+            yaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
+            zaxis=dict(gridcolor='gray', zerolinecolor='gray', color='white'),
+            bgcolor='#111111'
+        ),
+        paper_bgcolor='#111111',
+        legend=dict(font=dict(color='white'))
+    )
     
-    caminho_figura = "laboratorio_completo.png"
-    plt.savefig(caminho_figura, bbox_inches='tight', pad_inches=0.1, dpi=100, transparent=True)
-    plt.close(fig)
+    fig = go.Figure(data=[trace_a, trace_b, trace_eco, trace_controle, trace_waypoints], layout=layout)
     
-    info_vetor = f"Vetor de Inércia Aprendido: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f}) | Direção: {math.degrees(essencia_movimento['bearing_rad']):.2f}°"
+    info_vetor = f"Vetor de Inércia Aprendido: ({vetor_aprendido[0]:.2f}, {vetor_aprendido[1]:.2f}, {vetor_aprendido[2]:.2f})"
     
-    return caminho_figura, info_vetor
+    return fig, info_vetor
 
 # --- Interface Gradio ---
 
-with gr.Blocks(theme=gr.themes.Base(primary_hue="teal")) as demo:
+with gr.Blocks(theme=gr.themes.Base(primary_hue="green", secondary_hue="blue")) as demo:
     gr.Markdown(
         """
-        # 🔬 Laboratório de Continuidade Causal (Versão Completa)
-        Molde a trajetória completa! Use os controles para definir tanto o **caminho da Criança A** (o passado) quanto o **destino da Criança B** (o futuro).
-        Observe como a inércia é calculada e aplicada para qualquer estilo de movimento.
+        # 🔬 Laboratório de Continuidade Causal 3D Interativo
+        Molde a trajetória no espaço! Use os sliders para definir os pontos de inflexão da "Criança A".
+        O sistema irá aprender a inércia (vetor de movimento) a partir do "Eco de Memória" (em magenta) e projetar a trajetória contínua da "Criança B" de volta ao início, formando um loop.
+        **Use o mouse para girar e dar zoom no gráfico 3D.**
         """
     )
     
@@ -126,34 +124,38 @@ with gr.Blocks(theme=gr.themes.Base(primary_hue="teal")) as demo:
         with gr.Column(scale=1):
             gr.Markdown("### 🎮 Controles da Simulação")
             
-            with gr.Accordion("Definir Caminho da Criança A (O Passado)", open=True):
-                gr.Markdown("Começa em `[0,0]` e termina no ponto fixo de encontro `[75,45]`.")
-                inflexao1_x = gr.Slider(-50, 150, value=25, label="Vetor 2 (Inflexão 1) - X", visible=False)
-                inflexao1_y = gr.Slider(-50, 150, value=15, label="Vetor 2 (Inflexão 1) - Y")
-                inflexao2_x = gr.Slider(-50, 150, value=50, label="Vetor 3 (Inflexão 2) - X", visible=False)
-                inflexao2_y = gr.Slider(-50, 150, value=30, label="Vetor 3 (Inflexão 2) - Y")
-
-            with gr.Accordion("Definir Caminho da Criança B (O Futuro)", open=True):
-                destino_x_input = gr.Slider(-50, 150, value=100, label="Destino Final (X)", visible=False)
-                destino_y_input = gr.Slider(-50, 150, value=90, label="Destino Final (Y)")
-
-            with gr.Accordion("Configurações do Aprendizado", open=False):
-                eco_input = gr.Slider(2, 300, value=150, step=1, label="Nº de Vetores no Eco de Memória")
+            with gr.Accordion("Definir Ponto de Inflexão 1", open=True):
+                inflexao1_x = gr.Slider(-50, 150, value=25, label="Posição X")
+                inflexao1_y = gr.Slider(-50, 150, value=60, label="Posição Y")
+                inflexao1_z = gr.Slider(-50, 150, value=50, label="Posição Z (Altura)")
+
+            with gr.Accordion("Definir Ponto de Inflexão 2", open=True):
+                inflexao2_x = gr.Slider(-50, 150, value=60, label="Posição X")
+                inflexao2_y = gr.Slider(-50, 150, value=20, label="Posição Y")
+                inflexao2_z = gr.Slider(-50, 150, value=-30, label="Posição Z (Altura)")
+            
+            with gr.Accordion("Configurações do Aprendizado", open=True):
+                eco_input = gr.Slider(2, 100, value=50, step=1, label="Tamanho do Eco de Memória (Nº de Vetores)")
             
-        with gr.Column(scale=2):
-            gr.Markdown("### 📊 Visualização da Jornada")
             info_output = gr.Textbox(label="Dados do Aprendizado (Calculado)", interactive=False)
-            plot_output = gr.Image(label="Gráfico da Continuidade", type="filepath")
 
-    # Lista completa de componentes de entrada
-    inputs = [inflexao1_x, inflexao1_y, inflexao2_x, inflexao2_y, destino_x_input, destino_y_input, eco_input]
+        with gr.Column(scale=3):
+            gr.Markdown("### 📊 Visualização da Jornada 3D")
+            # Usamos gr.Plot para renderizar a figura do Plotly
+            plot_output = gr.Plot()
+
+    inputs = [
+        inflexao1_x, inflexao1_y, inflexao1_z,
+        inflexao2_x, inflexao2_y, inflexao2_z,
+        eco_input
+    ]
     
     # Conecta todos os sliders à função para atualização em tempo real
     for component in inputs:
-        component.change(fn=gerar_grafico_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+        component.change(fn=gerar_grafico_3d_dinamico, inputs=inputs, outputs=[plot_output, info_output])
     
     # Carga inicial do aplicativo
-    demo.load(fn=gerar_grafico_dinamico, inputs=inputs, outputs=[plot_output, info_output])
+    demo.load(fn=gerar_grafico_3d_dinamico, inputs=inputs, outputs=[plot_output, info_output])
 
 if __name__ == "__main__":
     demo.launch()