movimiento_parabolico.py

 
!pip install gradio matplotlib pillow  # Instalar las bibliotecas necesarias
!pip install huggingface_hub
import numpy as np
import gradio as gr
import matplotlib.pyplot as plt
from PIL import Image

# Cargar la imagen del logo (asegúrate de que el archivo esté en la ruta correcta)
logo_image = "/content/LOGOCIPDOQUEBRADAS.png"

def calcular_movimiento_parabolico(v0, angulo, h_inicial):
    g = 9.81  # Aceleración debido a la gravedad (m/s^2)
    angulo_rad = np.radians(angulo)

    # Tiempo de vuelo considerando altura inicial
    t_vuelo = (v0 * np.sin(angulo_rad) + np.sqrt((v0 * np.sin(angulo_rad))**2 + 2 * g * h_inicial)) / g

    # Tiempo en intervalos
    t = np.linspace(0, t_vuelo, num=500)

    # Trayectoria
    x = v0 * np.cos(angulo_rad) * t
    y = h_inicial + v0 * np.sin(angulo_rad) * t - 0.5 * g * t**2

    # Altura máxima
    h_max = h_inicial + (v0**2 * np.sin(angulo_rad)**2) / (2 * g)

    # Alcance máximo
    alcance_max = v0 * np.cos(angulo_rad) * t_vuelo

    return x, y, h_max, alcance_max, t_vuelo

def graficar(v0, angulo, h_inicial):
    x, y, h_max, alcance_max, t_vuelo = calcular_movimiento_parabolico(v0, angulo, h_inicial)

    plt.figure(figsize=(10, 5))
    plt.plot(x, y, label='Trayectoria', color='purple')
    plt.title('Movimiento Parabólico')
    plt.xlabel('Distancia (m)')
    plt.ylabel('Altura (m)')
    plt.grid(True)

    # Cálculo de componentes de velocidad
    vx = v0 * np.cos(np.radians(angulo))
    vy = v0 * np.sin(np.radians(angulo))

    # Añadir vectores
    plt.quiver(0, h_inicial, vx, vy, angles='xy', scale_units='xy', scale=1, color='r', label='Vector de Lanzamiento (V0)')
    plt.quiver(0, h_inicial, vx, 0, angles='xy', scale_units='xy', scale=1, color='g', label='Componente x (Vx)')
    plt.quiver(0, h_inicial, 0, vy, angles='xy', scale_units='xy', scale=1, color='b', label='Componente y (Vy)')

    plt.axhline(0, color='k', linewidth=0.5, linestyle='--')
    plt.axvline(0, color='k', linewidth=0.5, linestyle='--')

    plt.xlim(0, alcance_max * 1.1)
    plt.ylim(0, h_max * 1.1)

    # Dibujar el arco del ángulo
    angulo_rad = np.arctan2(vy, vx)
    arco_x = np.linspace(0, vx, 100)
    arco_y = h_inicial + (arco_x * np.tan(angulo_rad))
    plt.plot(arco_x, arco_y, color='orange', label='Ángulo de Lanzamiento')
    plt.text(vx / 2, h_inicial + 2, f'Ángulo: {angulo}°', fontsize=12, color='orange', ha='center')

    plt.legend()
    plt.savefig('plot.png')  # Guardar la gráfica
    plt.close()

    # Formatear la salida del texto con las ecuaciones en formato LaTeX
    resultado = (
        "**Ecuaciones del Movimiento Parabólico:**  \n"
        "$$ h_{max} = h_0 + \\frac{v_0^2 \\sin^2(\\theta)}{2g} $$  \n"
        "$$ R = \\frac{v_0 \\cos(\\theta)}{g} \\left( v_0 \\sin(\\theta) + \\sqrt{(v_0 \\sin(\\theta))^2 + 2gh_0} \\right) $$  \n"
        "$$ t_{vuelo} = \\frac{v_0 \\sin(\\theta) + \\sqrt{(v_0 \\sin(\\theta))^2 + 2gh_0}}{g} $$  \n"
        "Ecuaciones de posición:  \n"
        "$$ x(t) = v_0 \\cos(\\theta) \\cdot t $$  \n"
        "$$ y(t) = h_0 + v_0 \\sin(\\theta) \\cdot t - \\frac{1}{2} g \\cdot t^2 $$  \n\n"
        "**Valores calculados:**  \n"
        f"- Altura máxima (h_max): {h_max:.2f} m  \n"
        f"- Alcance máximo (R): {alcance_max:.2f} m  \n"
        f"- Tiempo de vuelo (t_vuelo): {t_vuelo:.2f} s"
    )

    return Image.open('plot.png'), resultado, 'plot.png'  # Devolver la ruta del archivo

# Crear la interfaz de Gradio
with gr.Blocks() as interfaz:
    # Mostrar el logo en la parte superior con tamaño ajustado
    with gr.Row():
        gr.Image(logo_image, show_label=False, interactive=False, width=300, height=150)  # Ajusta los valores según sea necesario

    # Título de la interfaz
    gr.Markdown("## **Simulación de Movimiento Parabólico - UNAD CIP Dosquebradas ECBTI**")
    gr.Markdown("**Ingrese los valores para la simulación**")

    # Entradas para velocidad, ángulo y altura inicial usando sliders
    with gr.Row():
        v0_input = gr.Slider(label="Velocidad Inicial (m/s)", minimum=0, maximum=100, value=20, step=1)
        angulo_input = gr.Slider(label="Ángulo de Lanzamiento (grados)", minimum=0, maximum=90, value=45, step=1)
        h_inicial_input = gr.Number(label="Altura Inicial (m)", value=0)

    # Salidas para la gráfica y resultados
    output_image = gr.Image(type="pil")
    output_markdown = gr.Markdown(label="Ecuaciones y Valores Calculados")

    # Botón para generar gráfica
    boton_graficar = gr.Button("Generar Gráfica")
    boton_descargar = gr.File(label="Descargar Gráfica", type="filepath")  # Cambiado a filepath

    # Funcionalidad del botón
    boton_graficar.click(fn=graficar, inputs=[v0_input, angulo_input, h_inicial_input], outputs=[output_image, output_markdown, boton_descargar])

# Lanzar la interfaz
interfaz.launch()