Update app.py

app.py

@@ -592,35 +592,30 @@ def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas, deci
 
 def cargar_excel(file):
     # Leer el archivo Excel
-    df = pd.read_excel(file.name)
+    df = pd.read_excel(file.name, sheet_name=None)
 
-    # Verificar que el archivo tenga las columnas requeridas
-    if 'Concentración' not in df.columns:
-        return "El archivo debe tener una columna llamada 'Concentración'.", None, None, None, None, None, None
+    # Verificar que el archivo tenga al menos dos pestañas
+    if len(df) < 2:
+        return "El archivo debe tener al menos dos pestañas.", None, None, None, None, None, None
 
-    # Obtener las columnas de absorbancia
-    columnas_absorbancia = [col for col in df.columns if 'Absorbancia' in col]
-
-    if not columnas_absorbancia:
-        return "El archivo debe tener al menos una columna de 'Absorbancia'.", None, None, None, None, None, None
-
-    # Configurar parámetros
-    concentracion_inicial = df['Concentración'].max()
-    unidad_medida = "Absorbancia"
-    n_filas = len(df)
-    n_replicas = len(columnas_absorbancia)
+    # Obtener la primera pestaña como referencia
+    primera_pestaña = next(iter(df.values()))
+    concentracion_inicial = primera_pestaña.iloc[0, 0]
+    unidad_medida = primera_pestaña.columns[0].split('(')[-1].split(')')[0]
+    n_filas = len(primera_pestaña)
+    n_replicas = len(df)
 
     # Generar la tabla base
-    df_base = pd.DataFrame()
-    df_base['Concentración Predicha Numérica'] = df['Concentración']
+    df_base = generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas)
 
-    # Añadir las columnas de absorbancia
-    for i, col in enumerate(columnas_absorbancia, start=1):
-        df_base[f"Concentración Real {i} ({unidad_medida})"] = df[col]
+    # Llenar la tabla con los datos de cada pestaña
+    for i, (sheet_name, sheet_df) in enumerate(df.items(), start=1):
+        col_real = f"Concentración Real {i} ({unidad_medida})"
+        df_base[col_real] = sheet_df.iloc[:, 1].values
 
     return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
 
-def calcular_regresion_tabla_principal(df, unidad_medida, columnas_seleccionadas,
+def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_regresion,
                                        palette_puntos, estilo_puntos,
                                        palette_linea_ajuste, estilo_linea_ajuste,
                                        mostrar_linea_ajuste, mostrar_puntos,
@@ -632,106 +627,203 @@ def calcular_regresion_tabla_principal(df, unidad_medida, columnas_seleccionadas
         return "Datos insuficientes", None, None, None
 
     col_concentracion = "Concentración Predicha Numérica"
+    col_absorbancia = f"Concentración Real Promedio ({unidad_medida})"
+    col_desviacion = f"Desviación Estándar ({unidad_medida})"
+
+    # Calcular promedio y desviación estándar si es necesario
+    n_replicas = len([col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col])
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
+
+    # Convertir columnas a numérico
+    df[col_concentracion] = pd.to_numeric(df[col_concentracion], errors='coerce')
+    df[col_absorbancia] = pd.to_numeric(df[col_absorbancia], errors='coerce')
+    df[col_desviacion] = pd.to_numeric(df[col_desviacion], errors='coerce')
 
-    # Verificar que haya columnas seleccionadas
-    if not columnas_seleccionadas:
-        return "Debe seleccionar al menos una columna de absorbancia.", None, None, None
+    df_valid = df.dropna(subset=[col_concentracion, col_absorbancia])
 
-    graficos = []
-    dfs_resumen = []
+    # Resetear el índice para asegurar que sea secuencial
+    df_valid.reset_index(drop=True, inplace=True)
 
-    for col_absorbancia in columnas_seleccionadas:
-        df_valid = df[[col_concentracion, col_absorbancia]].dropna()
+    # Asegurar que el gráfico original tenga todos los puntos
+    df_original = df_valid.copy()
 
-        # Convertir columnas a numérico
-        df_valid[col_concentracion] = pd.to_numeric(df_valid[col_concentracion], errors='coerce')
-        df_valid[col_absorbancia] = pd.to_numeric(df_valid[col_absorbancia], errors='coerce')
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas_regresion:
+        return "Se necesitan más datos", None, None, None
 
-        if len(df_valid) < 2:
-            continue
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas_regresion]
 
-        # Calcular regresión lineal
-        slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_concentracion], df_valid[col_absorbancia])
+    # Filtrar filas según las seleccionadas para el gráfico personalizado
+    df_valid = df_valid.loc[indices_seleccionados]
 
-        # Generar gráfico
-        sns.set(style="whitegrid")
-        fig, ax = plt.subplots(figsize=(8, 6))
+    if len(df_valid) < 2:
+        return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
 
-        # Obtener colores de las paletas
-        colors_puntos = sns.color_palette(palette_puntos, as_cmap=False)
-        colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False)
+    # Calcular regresión lineal para el gráfico personalizado
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_concentracion], df_valid[col_absorbancia])
 
-        color_puntos = colors_puntos[0]
-        color_linea_ajuste = colors_linea_ajuste[0]
+    # Generar gráfico original (con todos los puntos)
+    sns.set(style="whitegrid")
+    fig_original, ax_original = plt.subplots(figsize=(8, 6))
+
+    ax_original.errorbar(
+        df_original[col_concentracion],
+        df_original[col_absorbancia],
+        yerr=df_original[col_desviacion],
+        fmt='o',
+        color='blue',
+        ecolor='gray',
+        elinewidth=1,
+        capsize=3,
+        label='Datos'
+    )
 
-        if mostrar_puntos:
-            ax.scatter(
-                df_valid[col_concentracion],
-                df_valid[col_absorbancia],
-                color=color_puntos,
-                s=100,
-                marker=estilo_puntos,
-                label='Datos'
-            )
+    # Calcular regresión para todos los puntos
+    slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_concentracion], df_original[col_absorbancia])
 
-        if mostrar_linea_ajuste:
-            ax.plot(
-                df_valid[col_concentracion],
-                intercept + slope * df_valid[col_concentracion],
-                color=color_linea_ajuste,
-                linestyle=estilo_linea_ajuste,
-                label='Ajuste Lineal'
-            )
+    ax_original.plot(
+        df_original[col_concentracion],
+        intercept_all + slope_all * df_original[col_concentracion],
+        color='red',
+        linestyle='-',
+        label='Ajuste Lineal'
+    )
+
+    # Título y etiquetas personalizadas para el gráfico original
+    ax_original.set_xlabel(eje_x_original if eje_x_original else 'Concentración Predicha Numérica')
+    ax_original.set_ylabel(eje_y_original if eje_y_original else f'Concentración Real Promedio ({unidad_medida})')
+    ax_original.set_title(titulo_grafico_original if titulo_grafico_original else 'Regresión Lineal: Concentración Real vs Concentración Predicha (Original)')
+
+    # Posicionar la leyenda según la opción seleccionada (por defecto 'lower right')
+    ax_original.legend(loc=legend_location)
+
+    # Añadir ecuación y R² en el gráfico
+    ax_original.annotate(
+        f'y = {intercept_all:.4f} + {slope_all:.4f}x\n$R^2$ = {r_value_all**2:.4f}',
+        xy=(0.05, 0.95),
+        xycoords='axes fraction',
+        fontsize=12,
+        backgroundcolor='white',
+        verticalalignment='top'
+    )
+
+    # Generar gráfico personalizado
+    sns.set(style="whitegrid")
+    fig_personalizado, ax_personalizado = plt.subplots(figsize=(8, 6))
+
+    # Obtener colores de las paletas
+    colors_puntos = sns.color_palette(palette_puntos, as_cmap=False)
+    colors_linea_ajuste = sns.color_palette(palette_linea_ajuste, as_cmap=False)
+
+    color_puntos = colors_puntos[0]
+    color_linea_ajuste = colors_linea_ajuste[0]
 
-        # Título y etiquetas personalizadas
-        ax.set_xlabel(eje_x_personalizado if eje_x_personalizado else 'Concentración')
-        ax.set_ylabel(eje_y_personalizado if eje_y_personalizado else f'{col_absorbancia}')
-        ax.set_title(titulo_grafico_personalizado if titulo_grafico_personalizado else f'Regresión Lineal: {col_absorbancia}')
-
-        # Posicionar la leyenda según la opción seleccionada
-        ax.legend(loc=legend_location)
-
-        # Añadir ecuación y R² en el gráfico
-        ax.annotate(
-            f'y = {intercept:.4f} + {slope:.4f}x\n$R^2$ = {r_value**2:.4f}',
-            xy=(0.05, 0.95),
-            xycoords='axes fraction',
-            fontsize=12,
-            backgroundcolor='white',
-            verticalalignment='top'
+    if mostrar_puntos:
+        ax_personalizado.errorbar(
+            df_valid[col_concentracion],
+            df_valid[col_absorbancia],
+            yerr=df_valid[col_desviacion],
+            fmt=estilo_puntos,
+            color=color_puntos,
+            ecolor='gray',
+            elinewidth=1,
+            capsize=3,
+            label='Datos'
+        )
+
+    if mostrar_linea_ajuste:
+        ax_personalizado.plot(
+            df_valid[col_concentracion],
+            intercept + slope * df_valid[col_concentracion],
+            color=color_linea_ajuste,
+            linestyle=estilo_linea_ajuste,
+            label='Ajuste Lineal'
         )
 
-        graficos.append(fig)
+    # Título y etiquetas personalizadas para el gráfico personalizado
+    ax_personalizado.set_xlabel(eje_x_personalizado if eje_x_personalizado else 'Concentración Predicha Numérica')
+    ax_personalizado.set_ylabel(eje_y_personalizado if eje_y_personalizado else f'Concentración Real Promedio ({unidad_medida})')
+    ax_personalizado.set_title(titulo_grafico_personalizado if titulo_grafico_personalizado else 'Regresión Lineal Personalizada')
 
-        # Crear tabla resumida
-        df_resumen = df_valid[[col_concentracion, col_absorbancia]].copy()
-        df_resumen.columns = ['Concentración', f'{col_absorbancia}']
-        dfs_resumen.append(df_resumen)
+    # Posicionar la leyenda según la opción seleccionada
+    ax_personalizado.legend(loc=legend_location)
+
+    # Añadir ecuación y R² en el gráfico
+    ax_personalizado.annotate(
+        f'y = {intercept:.4f} + {slope:.4f}x\n$R^2$ = {r_value**2:.4f}',
+        xy=(0.05, 0.95),
+        xycoords='axes fraction',
+        fontsize=12,
+        backgroundcolor='white',
+        verticalalignment='top'
+    )
 
-    if not graficos:
-        return "No se pudo calcular la regresión para las columnas seleccionadas.", None, None, None
+    # Crear tabla resumida
+    df_resumen = df_valid[[col_concentracion, col_absorbancia, col_desviacion]].copy()
+    df_resumen.columns = ['Concentración Predicha', 'Absorbancia Promedio', 'Desviación Estándar']
 
-    return "Regresión calculada exitosamente", graficos, None, dfs_resumen
+    return "Regresión calculada exitosamente", fig_original, fig_personalizado, df_resumen
 
-def actualizar_opciones_columnas(df):
+# Función corregida para actualizar las opciones de filas
+def actualizar_opciones_filas(df):
     if df is None or df.empty:
         update = gr.update(choices=[], value=[])
     else:
-        columnas_absorbancia = [col for col in df.columns if 'Absorbancia' in col or 'Concentración Real' in col]
-        update = gr.update(choices=columnas_absorbancia, value=columnas_absorbancia)
-    return update
+        opciones = [f"Fila {i+1}" for i in df.index]
+        update = gr.update(choices=opciones, value=opciones)
+    return update, update
 
 # Interfaz Gradio
 with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     gr.Markdown("""
     # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
-    Cargue un archivo Excel con múltiples columnas de absorbancia y seleccione cuáles desea incluir en el análisis.
+    Configure los parámetros, edite los valores en la tabla y luego presione "Calcular" para obtener el análisis.
     """)
 
     with gr.Tab("📝 Datos de Calibración"):
         with gr.Row():
-            cargar_excel_btn = gr.UploadButton("📂 Cargar Excel", file_types=[".xlsx"], variant="primary")
+            concentracion_input = gr.Number(
+                value=2000000,
+                label="Concentración Inicial",
+                precision=0
+            )
+            unidad_input = gr.Textbox(
+                value="UFC",
+                label="Unidad de Medida",
+                placeholder="UFC, OD, etc..."
+            )
+            filas_slider = gr.Slider(
+                minimum=1,
+                maximum=20,
+                value=7,
+                step=1,
+                label="Número de filas"
+            )
+            decimales_slider = gr.Slider(
+                minimum=0,
+                maximum=5,
+                value=3,
+                step=1,
+                label="Número de Decimales"
+            )
+            replicas_slider = gr.Slider(
+                minimum=1,
+                maximum=10,
+                value=1,
+                step=1,
+                label="Número de Réplicas"
+            )
+
+        with gr.Row():
+            calcular_btn = gr.Button("🔄 Calcular", variant="primary")
             limpiar_btn = gr.Button("🗑 Limpiar Datos", variant="secondary")
+            ajustar_decimales_btn = gr.Button("🛠 Ajustar Decimales", variant="secondary")
+
+        with gr.Row():
+            ejemplo_ufc_btn = gr.Button("📋 Cargar Ejemplo UFC", variant="secondary")
+            ejemplo_od_btn = gr.Button("📋 Cargar Ejemplo OD", variant="secondary")
+            sinteticos_btn = gr.Button("🧪 Generar Datos Sintéticos", variant="secondary")
+            cargar_excel_btn = gr.UploadButton("📂 Cargar Excel", file_types=[".xlsx"], variant="secondary")
 
         tabla_output = gr.DataFrame(
             wrap=True,
@@ -740,12 +832,82 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             type="pandas",
         )
 
-    with gr.Tab("📈 Análisis de Regresión"):
-        gr.Markdown("## Ajuste de Regresión utilizando datos seleccionados")
+    with gr.Tab("📊 Análisis y Reporte"):
+        estado_output = gr.Textbox(label="Estado", interactive=False)
+        graficos_output = gr.Plot(label="Gráficos de Análisis")
 
-        # Casillas para seleccionar columnas
-        columnas_seleccionadas = gr.CheckboxGroup(
-            label="Seleccione las columnas de absorbancia a incluir en el análisis de regresión",
+        # Reemplazar Multiselect por CheckboxGroup
+        filas_seleccionadas = gr.CheckboxGroup(
+            label="Seleccione las filas a incluir en el análisis",
+            choices=[],
+            value=[],
+        )
+
+        # Opciones y botones debajo del gráfico
+        with gr.Row():
+            # Paletas de colores disponibles en Seaborn
+            paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
+
+            palette_puntos_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="deep",
+                label="Paleta para Puntos"
+            )
+            estilo_puntos_dropdown = gr.Dropdown(
+                choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"],
+                value="o",
+                label="Estilo de Puntos"
+            )
+            palette_linea_ajuste_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="muted",
+                label="Paleta Línea de Ajuste"
+            )
+            estilo_linea_ajuste_dropdown = gr.Dropdown(
+                choices=["-", "--", "-.", ":"],
+                value="-",
+                label="Estilo Línea de Ajuste"
+            )
+
+        with gr.Row():
+            palette_linea_ideal_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="bright",
+                label="Paleta Línea Ideal"
+            )
+            estilo_linea_ideal_dropdown = gr.Dropdown(
+                choices=["--", "-", "-.", ":"],
+                value="--",
+                label="Estilo Línea Ideal"
+            )
+            palette_barras_error_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="pastel",
+                label="Paleta Barras de Error"
+            )
+            mostrar_linea_ajuste = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste")
+            mostrar_linea_ideal = gr.Checkbox(value=False, label="Mostrar Línea Ideal")  # Desmarcado por defecto
+            mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos")
+            graficar_btn = gr.Button("📊 Graficar", variant="primary")
+
+        with gr.Row():
+            copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary")
+            exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary")
+            exportar_latex_btn = gr.Button("💾 Exportar Informe LaTeX", variant="primary")
+
+        with gr.Row():
+            exportar_word_file = gr.File(label="Informe en Word")
+            exportar_latex_file = gr.File(label="Informe en LaTeX")
+
+        # Informe al final
+        informe_output = gr.Markdown(elem_id="informe_output")
+
+    with gr.Tab("📈 Regresión Absorbancia vs Concentración"):
+        gr.Markdown("## Ajuste de Regresión utilizando datos de la Tabla Principal")
+
+        # Casillas para seleccionar filas
+        filas_seleccionadas_regresion = gr.CheckboxGroup(
+            label="Seleccione las filas a incluir en el análisis de regresión",
             choices=[],
             value=[],
         )
@@ -789,61 +951,245 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
         # Campos de texto para personalizar título y ejes
         with gr.Row():
+            titulo_grafico_original = gr.Textbox(
+                label="Título del Gráfico Original",
+                placeholder="Regresión Lineal: Concentración Real vs Concentración Predicha (Original)"
+            )
             titulo_grafico_personalizado = gr.Textbox(
-                label="Título del Gráfico",
-                placeholder="Regresión Lineal"
+                label="Título del Gráfico Personalizado",
+                placeholder="Regresión Lineal Personalizada"
+            )
+
+        with gr.Row():
+            eje_x_original = gr.Textbox(
+                label="Etiqueta del Eje X (Gráfico Original)",
+                placeholder="Concentración Predicha Numérica"
+            )
+            eje_y_original = gr.Textbox(
+                label="Etiqueta del Eje Y (Gráfico Original)",
+                placeholder=f"Concentración Real Promedio ({unidad_input.value})"
             )
 
         with gr.Row():
             eje_x_personalizado = gr.Textbox(
-                label="Etiqueta del Eje X",
-                placeholder="Concentración"
+                label="Etiqueta del Eje X (Gráfico Personalizado)",
+                placeholder="Concentración Predicha Numérica"
             )
             eje_y_personalizado = gr.Textbox(
-                label="Etiqueta del Eje Y",
-                placeholder="Absorbancia"
+                label="Etiqueta del Eje Y (Gráfico Personalizado)",
+                placeholder=f"Concentración Real Promedio ({unidad_input.value})"
             )
 
         calcular_regresion_btn = gr.Button("Calcular Regresión")
 
         # Salidas
         estado_regresion_output = gr.Textbox(label="Estado de la Regresión", interactive=False)
-        graficos_output = gr.Gallery(label="Gráficos Generados").style(grid=2, height='auto')
-        tabla_resumen_output = gr.DataFrame(label="Tablas Resumidas")
+        grafico_original_output = gr.Plot(label="Gráfico Original")
+        grafico_personalizado_output = gr.Plot(label="Gráfico Personalizado")
+        tabla_resumen_output = gr.DataFrame(label="Tabla Resumida")
 
-    # Eventos
+    # Eventos para actualizar las opciones de filas
+    tabla_output.change(
+        fn=actualizar_opciones_filas,
+        inputs=[tabla_output],
+        outputs=[filas_seleccionadas, filas_seleccionadas_regresion]
+    )
+
+    # Evento al presionar el botón Calcular
+    calcular_btn.click(
+        fn=actualizar_analisis,
+        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
+        outputs=[estado_output, graficos_output, informe_output, tabla_output]
+    )
+
+    # Evento para graficar con opciones seleccionadas
+    graficar_btn.click(
+        fn=actualizar_graficos,
+        inputs=[
+            tabla_output, replicas_slider, unidad_input,
+            palette_puntos_dropdown, estilo_puntos_dropdown,
+            palette_linea_ajuste_dropdown, estilo_linea_ajuste_dropdown,
+            palette_linea_ideal_dropdown, estilo_linea_ideal_dropdown,
+            palette_barras_error_dropdown,
+            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+            filas_seleccionadas, decimales_slider
+        ],
+        outputs=graficos_output
+    )
+
+    # Asegurar que la línea ideal esté desmarcada por defecto
+    def resetear_linea_ideal():
+        return gr.update(value=False)
+
+    # Desmarcar 'Mostrar Línea Ideal' en eventos de botones
+    calcular_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    limpiar_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    ajustar_decimales_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    sinteticos_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+
+    # Eventos de los botones adicionales, como limpiar, cargar ejemplos, ajustar decimales, etc.
+    # Evento para limpiar datos
+    limpiar_btn.click(
+        fn=limpiar_datos,
+        inputs=[replicas_slider],
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+    )
+
+    # Eventos de los botones de ejemplo
+    ejemplo_ufc_btn.click(
+        fn=cargar_ejemplo_ufc,
+        inputs=[replicas_slider],
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
+    )
+
+    ejemplo_od_btn.click(
+        fn=cargar_ejemplo_od,
+        inputs=[replicas_slider],
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output]
+    )
+
+    # Evento para generar datos sintéticos
+    sinteticos_btn.click(
+        fn=generar_datos_sinteticos_evento,
+        inputs=[tabla_output, replicas_slider, unidad_input],
+        outputs=tabla_output
+    )
+
+    # Evento para cargar archivo Excel
     cargar_excel_btn.upload(
         fn=cargar_excel,
         inputs=[cargar_excel_btn],
-        outputs=[None, None, None, None, tabla_output, None, None, None]
+        outputs=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
-    tabla_output.change(
-        fn=actualizar_opciones_columnas,
-        inputs=[tabla_output],
-        outputs=[columnas_seleccionadas]
+    # Evento al presionar el botón Ajustar Decimales
+    ajustar_decimales_btn.click(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
+    )
+
+    # Actualizar tabla al cambiar los parámetros (sin borrar "Concentración Real")
+    def actualizar_tabla_wrapper(df, filas, conc, unidad, replicas, decimales):
+        return actualizar_tabla_evento(df, filas, conc, unidad, replicas, decimales)
+
+    concentracion_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    unidad_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
     )
 
+    filas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    replicas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    decimales_slider.change(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
+    )
+
+    # Evento de copiar informe utilizando JavaScript
+    copiar_btn.click(
+        None,
+        [],
+        [],
+        js="""
+        function() {
+            const informeElement = document.querySelector('#informe_output');
+            const range = document.createRange();
+            range.selectNode(informeElement);
+            window.getSelection().removeAllRanges();
+            window.getSelection().addRange(range);
+            document.execCommand('copy');
+            window.getSelection().removeAllRanges();
+            alert('Informe copiado al portapapeles');
+        }
+        """
+    )
+
+    # Eventos de exportar informes
+    exportar_word_btn.click(
+        fn=exportar_word,
+        inputs=[tabla_output, informe_output, unidad_input, filas_seleccionadas],
+        outputs=exportar_word_file
+    )
+
+    exportar_latex_btn.click(
+        fn=exportar_latex,
+        inputs=[tabla_output, informe_output, filas_seleccionadas],
+        outputs=exportar_latex_file
+    )
+
+    # Inicializar la interfaz con el ejemplo base
+    def iniciar_con_ejemplo():
+        n_replicas = 1
+        df = generar_tabla(7, 2000000, "UFC", n_replicas)
+        # Valores reales de ejemplo
+        df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
+        # Calcular promedio y desviación estándar
+        df = calcular_promedio_desviacion(df, n_replicas, "UFC", 3)
+        filas_seleccionadas_inicial = [f"Fila {i+1}" for i in df.index]
+        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC", filas_seleccionadas_inicial, 3)
+        return (
+            2000000,
+            "UFC",
+            7,
+            df,
+            estado,
+            fig,
+            informe,
+            filas_seleccionadas_inicial,
+            3  # Número de decimales
+        )
+
+    interfaz.load(
+        fn=iniciar_con_ejemplo,
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider]
+    )
+
+    # Evento al presionar el botón de calcular regresión
     calcular_regresion_btn.click(
         fn=calcular_regresion_tabla_principal,
         inputs=[
-            tabla_output, None, columnas_seleccionadas,
+            tabla_output, unidad_input, filas_seleccionadas_regresion,
             palette_puntos_regresion, estilo_puntos_regresion,
             palette_linea_ajuste_regresion, estilo_linea_ajuste_regresion,
             mostrar_linea_ajuste_regresion, mostrar_puntos_regresion,
-            legend_location_dropdown, None,
-            None, titulo_grafico_personalizado,
-            None, None,
+            legend_location_dropdown, decimales_slider,
+            titulo_grafico_original, titulo_grafico_personalizado,
+            eje_x_original, eje_y_original,
             eje_x_personalizado, eje_y_personalizado
         ],
-        outputs=[estado_regresion_output, graficos_output, None, tabla_resumen_output]
-    )
-
-    limpiar_btn.click(
-        fn=lambda: (None, gr.update(value=None)),
-        inputs=[],
-        outputs=[tabla_output, columnas_seleccionadas]
+        outputs=[estado_regresion_output, grafico_original_output, grafico_personalizado_output, tabla_resumen_output]
     )
 
+# Lanzar la interfaz
 if __name__ == "__main__":
     interfaz.launch()