Update app.py

app.py

@@ -11,11 +11,11 @@ from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
 
 def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
-    valores_base = [1.00, 0.80, 0.60, 0.40, 0.20, 0.10, 0.05]
+    valores_base = [1.000, 0.800, 0.600, 0.400, 0.200, 0.100, 0.050]
 
     if n_filas <= 7:
         solucion_inoculo = valores_base[:n_filas]
-        agua = [round(1 - x, 2) for x in solucion_inoculo]
+        agua = [round(1 - x, 3) for x in solucion_inoculo]
     else:
         solucion_inoculo = valores_base.copy()
         ultimo_valor = valores_base[-1]
@@ -32,11 +32,11 @@ def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
     df = pd.DataFrame(data)
 
     nombre_columna = f"Solución de inóculo ({concentracion_inicial} {unidad_medida})"
-    df["Factor de Dilución"] = df[nombre_columna].apply(lambda x: round(1 / x, 2))
+    df["Factor de Dilución"] = df[nombre_columna].apply(lambda x: round(1 / x, 3))
     df["Concentración Predicha Numérica"] = df["Factor de Dilución"].apply(
         lambda x: concentracion_inicial / x
     )
-    df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(0).astype(str)
+    df[f"Concentración Predicha ({unidad_medida})"] = df["Concentración Predicha Numérica"].round(3).astype(str)
 
     # Añadir columnas para las réplicas de "Concentración Real"
     for i in range(1, n_replicas + 1):
@@ -56,7 +56,7 @@ def ajustar_decimales_evento(df, decimales):
             pass
     return df
 
-def calcular_promedio_desviacion(df, n_replicas, unidad_medida):
+def calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales):
     df = df.copy()
     # Obtener las columnas de réplicas
     col_replicas = [f"Concentración Real {i} ({unidad_medida})" for i in range(1, n_replicas + 1)]
@@ -72,6 +72,10 @@ def calcular_promedio_desviacion(df, n_replicas, unidad_medida):
     else:
         df[f"Desviación Estándar ({unidad_medida})"] = 0.0
 
+    # Redondear al número de decimales especificado
+    df[f"Concentración Real Promedio ({unidad_medida})"] = df[f"Concentración Real Promedio ({unidad_medida})"].round(decimales)
+    df[f"Desviación Estándar ({unidad_medida})"] = df[f"Desviación Estándar ({unidad_medida})"].round(decimales)
+
     return df
 
 def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo_puntos,
@@ -163,7 +167,7 @@ def generar_graficos(df_valid, n_replicas, unidad_medida, palette_puntos, estilo
 
     # Añadir ecuación y R² en el gráfico
     ax1.annotate(
-        f'y = {intercept:.2f} + {slope:.2f}x\n$R^2$ = {r_value**2:.4f}',
+        f'y = {intercept:.3f} + {slope:.3f}x\n$R^2$ = {r_value**2:.4f}',
         xy=(0.05, 0.95),
         xycoords='axes fraction',
         fontsize=12,
@@ -267,12 +271,18 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def actualizar_analisis(df, n_replicas, unidad_medida):
+def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, decimales):
     if df is None or df.empty:
         return "Error en los datos", None, "No se pueden generar análisis", df
 
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas:
+        return "Se necesitan más datos", None, "No se han seleccionado filas para el análisis", df
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
+
     # Calcular promedio y desviación estándar dependiendo de las réplicas
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
@@ -283,6 +293,12 @@ def actualizar_analisis(df, n_replicas, unidad_medida):
 
     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)
+
+    # Filtrar filas según las seleccionadas
+    df_valid = df_valid.loc[indices_seleccionados]
+
     if len(df_valid) < 2:
         return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
 
@@ -297,7 +313,9 @@ def actualizar_analisis(df, n_replicas, unidad_medida):
         palette_linea_ajuste='muted', estilo_linea_ajuste='-',
         palette_linea_ideal='bright', estilo_linea_ideal='--',
         palette_barras_error='pastel',
-        mostrar_linea_ajuste=True, mostrar_linea_ideal=True, mostrar_puntos=True
+        mostrar_linea_ajuste=True,
+        mostrar_linea_ideal=False,  # Línea Ideal desmarcada por defecto
+        mostrar_puntos=True
     )
     informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
 
@@ -308,12 +326,13 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
                         palette_linea_ajuste, estilo_linea_ajuste,
                         palette_linea_ideal, estilo_linea_ideal,
                         palette_barras_error,
-                        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
+                        mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+                        filas_seleccionadas, decimales):
     if df is None or df.empty:
         return None
 
     # Asegurarse de que los cálculos estén actualizados
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida)
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
     col_predicha_num = "Concentración Predicha Numérica"
     col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
@@ -324,6 +343,18 @@ def actualizar_graficos(df, n_replicas, unidad_medida,
 
     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
 
@@ -430,7 +461,7 @@ def exportar_informe_latex(df_valid, informe_md):
         f.write(informe_tex)
     return filename
 
-def exportar_word(df, informe_md, unidad_medida):
+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})"
@@ -441,6 +472,18 @@ def exportar_word(df, informe_md, unidad_medida):
 
     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
 
@@ -448,7 +491,7 @@ def exportar_word(df, informe_md, unidad_medida):
 
     return filename  # Retornamos el nombre del archivo
 
-def exportar_latex(df, informe_md):
+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]
@@ -459,6 +502,18 @@ def exportar_latex(df, informe_md):
 
     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
 
@@ -466,7 +521,6 @@ def exportar_latex(df, informe_md):
 
     return filename  # Retornamos el nombre del archivo
 
-# Funciones de ejemplo
 def cargar_ejemplo_ufc(n_replicas):
     df = generar_tabla(7, 2000000, "UFC", n_replicas)
     # Valores reales de ejemplo
@@ -478,14 +532,14 @@ def cargar_ejemplo_ufc(n_replicas):
     return 2000000, "UFC", 7, df
 
 def cargar_ejemplo_od(n_replicas):
-    df = generar_tabla(7, 1.0, "OD", n_replicas)
+    df = generar_tabla(7, 1.000, "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]
+        valores_reales = [1.000 - (i - 1) * 0.050, 0.800 - (i - 1) * 0.040, 0.600 - (i - 1) * 0.030,
+                          0.400 - (i - 1) * 0.020, 0.200 - (i - 1) * 0.010, 0.100 - (i - 1) * 0.005,
+                          0.050 - (i - 1) * 0.002]
         df[f"Concentración Real {i} (OD)"] = valores_reales
-    return 1.0, "OD", 7, df
+    return 1.000, "OD", 7, df
 
 def limpiar_datos(n_replicas):
     df = generar_tabla(7, 2000000, "UFC", n_replicas)
@@ -511,12 +565,12 @@ def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
         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)
+        datos_sinteticos = np.round(datos_sinteticos, 3)
         df[col_real] = datos_sinteticos
 
     return df
 
-def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
+def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas, decimales):
     # Actualizar tabla sin borrar "Concentración Real"
     df_new = generar_tabla(n_filas, concentracion, unidad, n_replicas)
 
@@ -531,13 +585,16 @@ def actualizar_tabla_evento(df, n_filas, concentracion, unidad, n_replicas):
             if idx in df.index:
                 df_new.at[idx, col_new] = df.at[idx, col_old]
 
+    # Ajustar decimales
+    df_new = ajustar_decimales_evento(df_new, decimales)
+
     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
+    # 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
 
@@ -558,6 +615,164 @@ def cargar_excel(file):
 
     return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
 
+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,
+                                       legend_location, decimales,
+                                       titulo_grafico_original, titulo_grafico_personalizado,
+                                       eje_x_original, eje_y_original,
+                                       eje_x_personalizado, eje_y_personalizado):
+    if df is None or df.empty:
+        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')
+
+    df_valid = df.dropna(subset=[col_concentracion, col_absorbancia])
+
+    # Resetear el índice para asegurar que sea secuencial
+    df_valid.reset_index(drop=True, inplace=True)
+
+    # Asegurar que el gráfico original tenga todos los puntos
+    df_original = df_valid.copy()
+
+    # Convertir filas_seleccionadas a índices
+    if not filas_seleccionadas_regresion:
+        return "Se necesitan más datos", None, None, None
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas_regresion]
+
+    # Filtrar filas según las seleccionadas para el gráfico personalizado
+    df_valid = df_valid.loc[indices_seleccionados]
+
+    if len(df_valid) < 2:
+        return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
+
+    # 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])
+
+    # 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'
+    )
+
+    # 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])
+
+    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]
+
+    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'
+        )
+
+    # 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')
+
+    # 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'
+    )
+
+    # 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", fig_original, fig_personalizado, df_resumen
+
+# 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:
+        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("""
@@ -587,7 +802,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             decimales_slider = gr.Slider(
                 minimum=0,
                 maximum=5,
-                value=0,
+                value=3,
                 step=1,
                 label="Número de Decimales"
             )
@@ -621,6 +836,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         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",
+            choices=[],
+            value=[],
+        )
+
         # Opciones y botones debajo del gráfico
         with gr.Row():
             # Paletas de colores disponibles en Seaborn
@@ -664,7 +886,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 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_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")
 
@@ -680,15 +902,104 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         # Informe al final
         informe_output = gr.Markdown(elem_id="informe_output")
 
-    # Eventos
-    input_components = [tabla_output]
-    output_components = [estado_output, graficos_output, informe_output, tabla_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=[],
+        )
+
+        # Opciones de personalización
+        with gr.Row():
+            paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
+            palette_puntos_regresion = gr.Dropdown(
+                choices=paletas_colores,
+                value="deep",
+                label="Paleta para Puntos"
+            )
+            estilo_puntos_regresion = gr.Dropdown(
+                choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"],
+                value="o",
+                label="Estilo de Puntos"
+            )
+            palette_linea_ajuste_regresion = gr.Dropdown(
+                choices=paletas_colores,
+                value="muted",
+                label="Paleta Línea de Ajuste"
+            )
+            estilo_linea_ajuste_regresion = gr.Dropdown(
+                choices=["-", "--", "-.", ":"],
+                value="-",
+                label="Estilo Línea de Ajuste"
+            )
+            mostrar_linea_ajuste_regresion = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste")
+            mostrar_puntos_regresion = gr.Checkbox(value=True, label="Mostrar Puntos")
+
+        with gr.Row():
+            legend_location_dropdown = gr.Dropdown(
+                choices=[
+                    'best', 'upper right', 'upper left', 'lower left', 'lower right',
+                    'right', 'center left', 'center right', 'lower center',
+                    'upper center', 'center'
+                ],
+                value='lower right',  # Por defecto 'lower right'
+                label='Ubicación de la Leyenda'
+            )
+
+        # 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 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 (Gráfico Personalizado)",
+                placeholder="Concentración Predicha Numérica"
+            )
+            eje_y_personalizado = gr.Textbox(
+                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)
+        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 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],
-        outputs=output_components
+        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
@@ -700,11 +1011,35 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             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
+            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,
@@ -747,34 +1082,38 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     )
 
     # 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)
+    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],
+        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],
+        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],
+        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],
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
         outputs=tabla_output
     )
 
-    # No agregamos un evento para decimales_slider.change, para evitar borrar la columna "Concentración Real"
+    decimales_slider.change(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
+    )
 
     # Evento de copiar informe utilizando JavaScript
     copiar_btn.click(
@@ -798,13 +1137,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     # Eventos de exportar informes
     exportar_word_btn.click(
         fn=exportar_word,
-        inputs=[tabla_output, informe_output, unidad_input],
+        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],
+        inputs=[tabla_output, informe_output, filas_seleccionadas],
         outputs=exportar_latex_file
     )
 
@@ -814,7 +1153,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         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]
-        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC")
+        # 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",
@@ -822,12 +1164,30 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             df,
             estado,
             fig,
-            informe
+            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]
+        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, 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, decimales_slider,
+            titulo_grafico_original, titulo_grafico_personalizado,
+            eje_x_original, eje_y_original,
+            eje_x_personalizado, eje_y_personalizado
+        ],
+        outputs=[estado_regresion_output, grafico_original_output, grafico_personalizado_output, tabla_resumen_output]
     )
 
 # Lanzar la interfaz