Update app.py

app.py

@@ -192,7 +192,7 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
     ax2.legend(loc='upper right', fontsize=10)
 
     plt.tight_layout()
-    # plt.savefig('grafico.png')  # Si deseas guardar el gráfico
+    plt.savefig('grafico.png')  # Guardar el gráfico para incluirlo en el informe
     return fig
 
 def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
@@ -315,82 +315,658 @@ def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas):
 
     return estado, fig, informe, df
 
-# Definir la interfaz de Gradio
-import gradio as gr
+def actualizar_graficos(df, n_replicas, unidad_medida,
+                        palette_puntos, estilo_puntos,
+                        palette_linea_ajuste, estilo_linea_ajuste,
+                        palette_linea_ideal, estilo_linea_ideal,
+                        palette_barras_error,
+                        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+                        filas_seleccionadas):
+    if df is None or df.empty:
+        return None
 
-with gr.Blocks() as interfaz:
-    gr.Markdown("# Generador de Tabla de Diluciones y Análisis de Calibración")
+    # Asegurarse de que los cálculos estén actualizados
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
 
-    with gr.Tab("Generar Tabla"):
-        gr.Markdown("## Parámetros de la Tabla")
-        with gr.Row():
-            n_filas = gr.Number(label="Número de filas", value=7, precision=0)
-            concentracion_inicial = gr.Number(label="Concentración Inicial", value=100)
-            unidad_medida = gr.Textbox(label="Unidad de Medida", value="mg/L")
-            n_replicas = gr.Number(label="Número de réplicas", value=3, precision=0)
-        btn_generar_tabla = gr.Button("Generar Tabla")
-        tabla = gr.DataFrame(label="Tabla Generada", editable=True)
-
-        btn_generar_tabla.click(
-            generar_tabla,
-            inputs=[n_filas, concentracion_inicial, unidad_medida, n_replicas],
-            outputs=tabla
-        )
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
-    with gr.Tab("Ajustar Decimales"):
-        gr.Markdown("## Ajustar Decimales")
-        decimales = gr.Number(label="Número de decimales", value=2, precision=0)
-        btn_ajustar_decimales = gr.Button("Ajustar Decimales")
-        tabla_ajustada = gr.DataFrame(label="Tabla Ajustada", editable=True)
+    # Convertir columnas a numérico
+    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
-        btn_ajustar_decimales.click(
-            ajustar_decimales_evento,
-            inputs=[tabla, decimales],
-            outputs=tabla_ajustada
-        )
+    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
+
+    # Resetear el índice para asegurar que sea secuencial
+    df_valid.reset_index(drop=True, inplace=True)
+
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas:
+        return None
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
+
+    # Filtrar filas según las seleccionadas
+    df_valid = df_valid.loc[indices_seleccionados]
+
+    if len(df_valid) < 2:
+        return None
+
+    # Generar gráfico con opciones seleccionadas
+    fig = generar_graficos(
+        df_valid, n_replicas, unidad_medida,
+        palette_puntos, estilo_puntos,
+        palette_linea_ajuste, estilo_linea_ajuste,
+        palette_linea_ideal, estilo_linea_ideal,
+        palette_barras_error,
+        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos
+    )
+
+    return fig
+
+def exportar_informe_word(df_valid, informe_md, unidad_medida):
+    # Crear documento Word
+    doc = docx.Document()
+
+    # Estilos APA 7
+    style = doc.styles['Normal']
+    font = style.font
+    font.name = 'Times New Roman'
+    font.size = Pt(12)
+
+    # Título centrado
+    titulo = doc.add_heading('Informe de Calibración', 0)
+    titulo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+    # Fecha
+    fecha = doc.add_paragraph(f"Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}")
+    fecha.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+    # Insertar gráfico
+    if os.path.exists('grafico.png'):
+        doc.add_picture('grafico.png', width=Inches(6))
+        ultimo_parrafo = doc.paragraphs[-1]
+        ultimo_parrafo.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+
+        # Leyenda del gráfico en estilo APA 7
+        leyenda = doc.add_paragraph('Figura 1. Gráfico de calibración.')
+        leyenda_format = leyenda.paragraph_format
+        leyenda_format.alignment = WD_PARAGRAPH_ALIGNMENT.CENTER
+        leyenda.style = doc.styles['Caption']
+
+    # Agregar contenido del informe
+    doc.add_heading('Resumen Estadístico', level=1)
+    for linea in informe_md.split('\n'):
+        if linea.startswith('##'):
+            doc.add_heading(linea.replace('##', '').strip(), level=2)
+        else:
+            doc.add_paragraph(linea)
+
+    # Añadir tabla de datos
+    doc.add_heading('Tabla de Datos de Calibración', level=1)
+
+    # Convertir DataFrame a lista de listas
+    tabla_datos = df_valid.reset_index(drop=True)
+    tabla_datos = tabla_datos.round(4)  # Redondear a 4 decimales si es necesario
+    columnas = tabla_datos.columns.tolist()
+    registros = tabla_datos.values.tolist()
+
+    # Crear tabla en Word
+    tabla = doc.add_table(rows=1 + len(registros), cols=len(columnas))
+    tabla.style = 'Table Grid'
+
+    # Añadir los encabezados
+    hdr_cells = tabla.rows[0].cells
+    for idx, col_name in enumerate(columnas):
+        hdr_cells[idx].text = col_name
+
+    # Añadir los registros
+    for i, registro in enumerate(registros):
+        row_cells = tabla.rows[i + 1].cells
+        for j, valor in enumerate(registro):
+            row_cells[j].text = str(valor)
+
+    # Formatear fuente de la tabla
+    for row in tabla.rows:
+        for cell in row.cells:
+            for paragraph in cell.paragraphs:
+                paragraph.style = doc.styles['Normal']
+
+    # Guardar documento
+    filename = 'informe_calibracion.docx'
+    doc.save(filename)
+    return filename
+
+def exportar_informe_latex(df_valid, informe_md):
+    # Generar código LaTeX
+    informe_tex = r"""\documentclass{article}
+\usepackage[spanish]{babel}
+\usepackage{amsmath}
+\usepackage{graphicx}
+\usepackage{booktabs}
+\begin{document}
+"""
+    informe_tex += informe_md.replace('#', '').replace('**', '\\textbf{').replace('*', '\\textit{')
+    informe_tex += r"""
+\end{document}
+"""
+    filename = 'informe_calibracion.tex'
+    with open(filename, 'w') as f:
+        f.write(informe_tex)
+    return filename
+
+def exportar_word(df, informe_md, unidad_medida, filas_seleccionadas):
+    df_valid = df.copy()
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+
+    # Convertir columnas a numérico
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+
+    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
+
+    # Resetear el índice
+    df_valid.reset_index(drop=True, inplace=True)
+
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas:
+        return None
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
+
+    # Filtrar filas según las seleccionadas
+    df_valid = df_valid.loc[indices_seleccionados]
+
+    if df_valid.empty:
+        return None
+
+    filename = exportar_informe_word(df_valid, informe_md, unidad_medida)
+
+    return filename  # Retornamos el nombre del archivo
+
+def exportar_latex(df, informe_md, filas_seleccionadas):
+    df_valid = df.copy()
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = [col for col in df_valid.columns if 'Real Promedio' in col][0]
+
+    # Convertir columnas a numérico
+    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
+
+    df_valid = df_valid.dropna(subset=[col_predicha_num, col_real_promedio])
+
+    # Resetear el índice
+    df_valid.reset_index(drop=True, inplace=True)
+
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas:
+        return None
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
+
+    # Filtrar filas según las seleccionadas
+    df_valid = df_valid.loc[indices_seleccionados]
+
+    if df_valid.empty:
+        return None
+
+    filename = exportar_informe_latex(df_valid, informe_md)
+
+    return filename  # Retornamos el nombre del archivo
+
+def cargar_ejemplo_ufc(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [2000000 - (i - 1) * 10000, 1600000 - (i - 1) * 8000, 1200000 - (i - 1) * 6000,
+                          800000 - (i - 1) * 4000, 400000 - (i - 1) * 2000, 200000 - (i - 1) * 1000,
+                          100000 - (i - 1) * 500]
+        df[f"Concentración Real {i} (UFC)"] = valores_reales
+    return 2000000, "UFC", 7, df
+
+def cargar_ejemplo_od(n_replicas):
+    df = generar_tabla(7, 1.0, "OD", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        valores_reales = [1.00 - (i - 1) * 0.05, 0.80 - (i - 1) * 0.04, 0.60 - (i - 1) * 0.03,
+                          0.40 - (i - 1) * 0.02, 0.20 - (i - 1) * 0.01, 0.10 - (i - 1) * 0.005,
+                          0.05 - (i - 1) * 0.002]
+        df[f"Concentración Real {i} (OD)"] = valores_reales
+    return 1.0, "OD", 7, df
+
+def limpiar_datos(n_replicas):
+    df = generar_tabla(7, 2000000, "UFC", n_replicas)
+    return (
+        2000000,   # Concentración Inicial
+        "UFC",     # Unidad de Medida
+        7,         # Número de filas
+        df,        # Tabla Output
+        "",        # Estado Output
+        None,      # Gráficos Output
+        ""         # Informe Output
+    )
+
+def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
+    df = df.copy()
+    col_predicha_num = "Concentración Predicha Numérica"
+
+    # Generar datos sintéticos para cada réplica
+    for i in range(1, n_replicas + 1):
+        col_real = f"Concentración Real {i} ({unidad_medida})"
+        df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+        desviacion_std = 0.05 * df[col_predicha_num].mean()  # 5% de la media como desviación estándar
+        valores_predichos = df[col_predicha_num].astype(float).values
+        datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
+        datos_sinteticos = np.maximum(0, datos_sinteticos)  # Asegurar que no haya valores negativos
+        datos_sinteticos = np.round(datos_sinteticos, 2)
+        df[col_real] = datos_sinteticos
+
+    return df
+
+def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
+    # Actualizar tabla sin borrar "Concentración Real"
+    df_new = generar_tabla(n_filas, concentracion, unidad, n_replicas)
+
+    # Mapear columnas
+    col_real_new = [col for col in df_new.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
+    col_real_old = [col for col in df.columns if 'Concentración Real' in col and 'Promedio' not in col and 'Desviación' not in col]
+
+    # Reemplazar valores existentes en "Concentración Real"
+    for col_new, col_old in zip(col_real_new, col_real_old):
+        df_new[col_new] = None
+        for idx in df_new.index:
+            if idx in df.index:
+                df_new.at[idx, col_new] = df.at[idx, col_old]
+
+    return df_new
+
+def cargar_excel(file):
+    # Leer el archivo Excel
+    df = pd.read_excel(file.name, sheet_name=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 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 = generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas)
 
-    with gr.Tab("Ingresar Concentraciones Reales"):
-        gr.Markdown("## Ingresar Concentraciones Reales")
-        gr.Markdown("Ingrese los valores de concentración real en las columnas correspondientes de la tabla.")
-        tabla_input = gr.DataFrame(label="Tabla con Concentraciones Reales", editable=True)
+    # 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
 
-        # Sincronizar tabla_ajustada con tabla_input
-        tabla_ajustada.change(
-            lambda df: df,
-            inputs=tabla_ajustada,
-            outputs=tabla_input
+    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
+
+# Función para calcular la regresión y generar el gráfico
+def calcular_regresion(conc_data, abs_data):
+    if conc_data is None or abs_data is None:
+        return "Datos insuficientes", None
+
+    df_conc = pd.DataFrame(conc_data, columns=["Concentración"])
+    df_abs = pd.DataFrame(abs_data, columns=["Absorbancia"])
+
+    if df_conc.empty or df_abs.empty or len(df_conc) != len(df_abs):
+        return "Los datos de concentración y absorbancia deben tener el mismo número de puntos", None
+
+    df = pd.concat([df_conc, df_abs], axis=1)
+    df = df.dropna()
+
+    if len(df) < 2:
+        return "Se requieren al menos dos puntos para calcular la regresión", None
+
+    # Calcular regresión lineal
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df["Concentración"], df["Absorbancia"])
+
+    # Generar gráfico
+    fig, ax = plt.subplots(figsize=(8, 6))
+    ax.scatter(df["Concentración"], df["Absorbancia"], color='blue', label='Datos')
+    ax.plot(df["Concentración"], intercept + slope * df["Concentración"], 'r', label='Ajuste Lineal')
+    ax.set_xlabel('Concentración')
+    ax.set_ylabel('Absorbancia')
+    ax.set_title('Regresión Lineal: Absorbancia vs Concentración')
+    ax.legend()
+
+    # 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'
+    )
+
+    return "Regresión calculada exitosamente", fig
+
+# Interfaz Gradio
+with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
+    gr.Markdown("""
+    # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
+    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():
+            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=0,
+                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,
+            label="Tabla de Datos",
+            interactive=True,
+            type="pandas",
         )
 
-    with gr.Tab("Análisis"):
-        gr.Markdown("## Seleccionar Filas para Análisis")
+    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")
+
+        # Reemplazar Multiselect por CheckboxGroup
         filas_seleccionadas = gr.CheckboxGroup(
-            label="Seleccione las filas a incluir en el análisis"
+            label="Seleccione las filas a incluir en el análisis",
+            choices=[],
+            value=[],
         )
-        btn_actualizar_filas = gr.Button("Actualizar Opciones de Filas")
 
-        # Actualizar las opciones de filas basadas en el número de filas de la tabla
-        def actualizar_opciones_filas(df):
-            opciones = [f"Fila {i+1}" for i in range(len(df))]
-            return gr.CheckboxGroup.update(choices=opciones)
+        # 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"]
 
-        btn_actualizar_filas.click(
-            actualizar_opciones_filas,
-            inputs=tabla_input,
-            outputs=filas_seleccionadas
-        )
+            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=True, label="Mostrar Línea Ideal")
+            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")
 
-        btn_analizar = gr.Button("Realizar Análisis")
+        # Informe al final
+        informe_output = gr.Markdown(elem_id="informe_output")
 
-        estado = gr.Textbox(label="Estado del Análisis")
-        grafico = gr.Plot(label="Gráfico")
-        informe = gr.Markdown(label="Informe")
+    with gr.Tab("📈 Regresión Absorbancia vs Concentración"):
+        gr.Markdown("## Ajuste de Regresión entre Absorbancia y Concentración")
 
-        btn_analizar.click(
-            actualizar_analisis,
-            inputs=[tabla_input, n_replicas, unidad_medida, filas_seleccionadas],
-            outputs=[estado, grafico, informe, tabla_input]
+        # Crear componentes para ingresar datos
+        with gr.Row():
+            concentracion_abs_input = gr.Dataframe(
+                headers=["Concentración"],
+                label="Datos de Concentración",
+                interactive=True
+            )
+            absorbancia_input = gr.Dataframe(
+                headers=["Absorbancia"],
+                label="Datos de Absorbancia",
+                interactive=True
+            )
+
+        calcular_regresion_btn = gr.Button("Calcular Regresión")
+
+        # Salidas
+        estado_regresion_output = gr.Textbox(label="Estado de la Regresión", interactive=False)
+        grafico_regresion_output = gr.Plot(label="Gráfico de Regresión")
+
+    # Eventos para actualizar las opciones de filas
+    def actualizar_opciones_filas(df):
+        if df is None or df.empty:
+            return gr.update(choices=[], value=[])
+        else:
+            opciones = [f"Fila {i+1}" for i in df.index]
+            return gr.update(choices=opciones, value=opciones)
+
+    tabla_output.change(
+        fn=actualizar_opciones_filas,
+        inputs=[tabla_output],
+        outputs=filas_seleccionadas
+    )
+
+    # Evento al presionar el botón Calcular
+    calcular_btn.click(
+        fn=actualizar_analisis,
+        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas],
+        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
+        ],
+        outputs=graficos_output
+    )
+
+    # 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=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
+    )
+
+    # 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):
+        return actualizar_tabla_evento(df, filas, conc, unidad, replicas)
+
+    concentracion_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    unidad_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    filas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider],
+        outputs=tabla_output
+    )
+
+    replicas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_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]
+        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)
+        return (
+            2000000,
+            "UFC",
+            7,
+            df,
+            estado,
+            fig,
+            informe,
+            filas_seleccionadas_inicial
         )
 
+    interfaz.load(
+        fn=iniciar_con_ejemplo,
+        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas]
+    )
+
+    # Evento al presionar el botón de calcular regresión
+    calcular_regresion_btn.click(
+        fn=calcular_regresion,
+        inputs=[concentracion_abs_input, absorbancia_input],
+        outputs=[estado_regresion_output, grafico_regresion_output]
+    )
+
 # Lanzar la interfaz
 if __name__ == "__main__":
     interfaz.launch()