Update app.py

app.py

@@ -266,6 +266,7 @@ def actualizar_analisis(df, n_replicas, unidad_predicha, unidad_replicas, filas_
     return estado, fig, informe, df
 
 def exportar_informe_word(df_valid, informe_md, unidad_predicha, unidad_replicas):
+    import docx
     doc = docx.Document()
 
     style = doc.styles['Normal']
@@ -397,25 +398,25 @@ def exportar_latex(df, informe_md, filas_seleccionadas):
 
 def limpiar_datos(n_replicas):
     unidad_predicha = "mg/L"
+    # Unidad de replicas por defecto Abs
     unidad_replicas = "Abs"
-
     df = pd.DataFrame({
         "Solución": [1/(2**i) for i in range(7)],
         "H2O": [1-(1/(2**i)) for i in range(7)],
-        "Factor de Dilución": [(1/(1/(2**i))) for i in range(7)],
-        f"Concentración Predicha ({unidad_predicha})": [2000000/(1/(1/(2**i))) for i in range(7)]
+        "Dimensión de Dilución": [(1/(1/(2**i))) for i in range(7)],
+        f"Concentración Predicha ({unidad_predicha})": [150/(1/(1/(2**i))) for i in range(7)]
     })
     for i in range(1, n_replicas+1):
         df[f"Absorbancia Real {i} ({unidad_replicas})"] = np.nan
 
     return (
-        2000000,
+        150,
         unidad_predicha,
         7,
         df,
-        "",
-        None,
-        ""
+        "",  # estado
+        None, # graficos
+        ""    # informe
     )
 
 def generar_datos_sinteticos_evento(df, n_replicas, unidad_predicha, unidad_replicas):
@@ -423,16 +424,17 @@ def generar_datos_sinteticos_evento(df, n_replicas, unidad_predicha, unidad_repl
     col_predicha = f"Concentración Predicha ({unidad_predicha})"
     if col_predicha in df.columns:
         df[col_predicha] = pd.to_numeric(df[col_predicha], errors='coerce')
-        for i in range(1, n_replicas + 1):
-            col_real = f"Absorbancia Real {i} ({unidad_replicas})"
-            desviacion_std = 0.05 * df[col_predicha].mean()
-            valores_predichos = df[col_predicha].dropna().values
-            if len(valores_predichos) == 0:
-                continue
-            datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
-            datos_sinteticos = np.maximum(0, datos_sinteticos)
-            datos_sinteticos = np.round(datos_sinteticos, 3)
-            df.loc[df[col_predicha].notna(), col_real] = datos_sinteticos
+        if not df[col_predicha].empty:
+            for i in range(1, n_replicas + 1):
+                col_real = f"Absorbancia Real {i} ({unidad_replicas})"
+                desviacion_std = 0.05 * df[col_predicha].mean()
+                valores_predichos = df[col_predicha].dropna().values
+                if len(valores_predichos) == 0:
+                    continue
+                datos_sinteticos = valores_predichos + np.random.normal(0, desviacion_std, size=len(valores_predichos))
+                datos_sinteticos = np.maximum(0, datos_sinteticos)
+                datos_sinteticos = np.round(datos_sinteticos, 3)
+                df.loc[df[col_predicha].notna(), col_real] = datos_sinteticos
     return df
 
 def actualizar_tabla_evento(df, n_filas, conc, unidad_predicha, unidad_replicas, n_replicas, decimales):
@@ -449,7 +451,7 @@ def cargar_excel(file):
     all_sheets = pd.read_excel(file.name, sheet_name=None)
 
     if len(all_sheets) < 3:
-        return "El archivo debe tener al menos tres pestañas (Hoja1, Hoja2, Hoja3).", None, None, None, None, None, None, ""
+        return "El archivo debe tener al menos tres pestañas (Hoja1, Hoja2, Hoja3).", None, None, None, None, None, None, "", [], []
 
     sheet_names = list(all_sheets.keys())
     sheet1_name = sheet_names[0]
@@ -470,10 +472,9 @@ def cargar_excel(file):
     except:
         unidad_predicha = "mg/L"
 
+    # Unidad por defecto Abs
     unidad_replicas = "Abs"
-
-    concentracion_inicial = 2000000.0
-
+    concentracion_inicial = 150.0
     n_filas = len(df_base)
     n_replicas = 2
 
@@ -485,160 +486,34 @@ def cargar_excel(file):
     df_sistema[f"Absorbancia Real 1 ({unidad_replicas})"] = col_replica_1
     df_sistema[f"Absorbancia Real 2 ({unidad_replicas})"] = col_replica_2
 
-    return concentracion_inicial, unidad_predicha, n_filas, n_replicas, df_sistema, "", None, ""
+    return concentracion_inicial, unidad_predicha, n_filas, n_replicas, df_sistema, "", None, "", [], []
 
 def actualizar_opciones_filas(df):
     if df is None or df.empty:
         update = gr.update(choices=[], value=[])
+        update_regresion = gr.update(choices=[], value=[])
     else:
         opciones = [f"Fila {i+1}" for i in df.index]
+        # Marcamos todas las filas por defecto
         update = gr.update(choices=opciones, value=opciones)
-    return update, update
-
-def calcular_regresion_tabla_principal(df, unidad_predicha, unidad_replicas, filas_seleccionadas_regresion,
-                                       color_puntos, estilo_puntos,
-                                       color_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
-
-    color_puntos = safe_color(color_puntos)
-    color_linea_ajuste = safe_color(color_linea_ajuste)
-
-    col_predicha = f"Concentración Predicha ({unidad_predicha})"
-    col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
-    col_desviacion = f"Desviación Estándar ({unidad_replicas})"
-
-    n_replicas = len([c for c in df.columns if 'Absorbancia Real ' in c and 'Promedio' not in c and 'Desviación' not in c])
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales)
-
-    if col_predicha not in df.columns or col_real_promedio not in df.columns:
-        return "Faltan columnas necesarias", None, None, None
-
-    df[col_predicha] = pd.to_numeric(df[col_predicha], errors='coerce')
-    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
-    df[col_desviacion] = pd.to_numeric(df[col_desviacion], errors='coerce').fillna(0)
-
-    df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
-    df_valid.reset_index(drop=True, inplace=True)
-
-    df_original = df_valid.copy()
-
-    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]
-    if len(indices_seleccionados) < 2:
-        return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
-
-    df_valid = df_valid.loc[indices_seleccionados]
-
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha], df_valid[col_real_promedio])
-
-    sns.set(style="whitegrid")
-    fig_original, ax_original = plt.subplots(figsize=(8, 6))
-
-    # Gráfico Original
-    ax_original.errorbar(
-        df_original[col_predicha],
-        df_original[col_real_promedio],
-        yerr=df_original[col_desviacion],
-        fmt=estilo_puntos,
-        color=color_puntos,
-        ecolor='gray',
-        elinewidth=1,
-        capsize=3,
-        label='Datos'
-    )
-
-    slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_predicha], df_original[col_real_promedio])
-
-    ax_original.plot(
-        df_original[col_predicha],
-        intercept_all + slope_all * df_original[col_predicha],
-        color=color_linea_ajuste,
-        linestyle='-',
-        label='Ajuste Lineal'
-    )
-
-    ax_original.set_xlabel(eje_x_original if eje_x_original else f'Concentración Predicha ({unidad_predicha})')
-    ax_original.set_ylabel(eje_y_original if eje_y_original else f'Absorbancia Real Promedio ({unidad_replicas})')
-    ax_original.set_title(titulo_grafico_original if titulo_grafico_original else 'Regresión Lineal: Absorbancia Real vs Concentración Predicha (Original)')
-    ax_original.legend(loc=legend_location)
-
-    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'
-    )
-
-    # Gráfico Personalizado
-    sns.set(style="whitegrid")
-    fig_personalizado, ax_personalizado = plt.subplots(figsize=(8, 6))
-
-    if mostrar_puntos:
-        ax_personalizado.errorbar(
-            df_valid[col_predicha],
-            df_valid[col_real_promedio],
-            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_predicha],
-            intercept + slope * df_valid[col_predicha],
-            color=color_linea_ajuste,
-            linestyle=estilo_linea_ajuste,
-            label='Ajuste Lineal'
-        )
-
-    ax_personalizado.set_xlabel(eje_x_personalizado if eje_x_personalizado else f'Concentración Predicha ({unidad_predicha})')
-    ax_personalizado.set_ylabel(eje_y_personalizado if eje_y_personalizado else f'Absorbancia Real Promedio ({unidad_replicas})')
-    ax_personalizado.set_title(titulo_grafico_personalizado if titulo_grafico_personalizado else 'Regresión Lineal Personalizada')
-    ax_personalizado.legend(loc=legend_location)
-
-    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'
-    )
-
-    df_resumen = df_valid[[col_predicha, col_real_promedio, col_desviacion]].copy()
-    df_resumen.columns = [f'Concentración Predicha ({unidad_predicha})', 'Absorbancia Promedio', 'Desviación Estándar']
-
-    return "Regresión calculada exitosamente", fig_original, fig_personalizado, df_resumen
+        update_regresion = gr.update(choices=opciones, value=opciones)
+    return update, update_regresion
 
 def iniciar_con_ejemplo():
     unidad_predicha = "mg/L"
-    unidad_replicas = "Abs"
+    unidad_replicas = "Abs"  # Por defecto Abs
     df = pd.DataFrame({
         "Solución": [1.00,0.80,0.67,0.60,0.53,0.47,0.40],
         "H2O": [0.00,0.20,0.33,0.40,0.47,0.53,0.60],
-        "Factor de Dilución": [1.00,1.25,1.50,1.67,1.87,2.14,2.50],
+        "Dimensión de Dilución": [1.00,1.25,1.50,1.67,1.87,2.14,2.50],
         f"Concentración Predicha ({unidad_predicha})": [150,120,100,90,80,70,60],
         f"Absorbancia Real 1 ({unidad_replicas})": [1.715,1.089,0.941,0.552,0.703,0.801,0.516]
     })
     n_replicas = 1
     estado, fig, informe, df = actualizar_analisis(df, n_replicas, unidad_predicha, unidad_replicas, [f"Fila {i+1}" for i in df.index], 3)
+    filas = [f"Fila {i+1}" for i in df.index]
     return (
-        2000000,
+        150,
         unidad_predicha,
         unidad_replicas,
         7,
@@ -646,85 +521,99 @@ def iniciar_con_ejemplo():
         estado,
         fig,
         informe,
-        [f"Fila {i+1}" for i in df.index],
+        filas,
         3
     )
 
-import gradio as gr
+def recalcular_y_graficar(df, n_replicas, unidad_predicha, unidad_replicas, filas_seleccionadas, decimales,
+                          color_puntos, estilo_puntos, color_linea_ajuste, estilo_linea_ajuste,
+                          color_barras_error, mostrar_linea_ajuste, mostrar_puntos):
+    estado, fig_base, informe, df = actualizar_analisis(df, n_replicas, unidad_predicha, unidad_replicas, filas_seleccionadas, decimales)
+    fig_custom = actualizar_graficos_custom(df, n_replicas, unidad_predicha, unidad_replicas,
+                                            color_puntos, estilo_puntos,
+                                            color_linea_ajuste, estilo_linea_ajuste,
+                                            color_barras_error,
+                                            mostrar_linea_ajuste, mostrar_puntos,
+                                            filas_seleccionadas, decimales)
+    return estado, fig_custom, informe
+
+def actualizar_graficos_custom(df, n_replicas, unidad_predicha, unidad_replicas,
+                               color_puntos, estilo_puntos,
+                               color_linea_ajuste, estilo_linea_ajuste,
+                               color_barras_error,
+                               mostrar_linea_ajuste, mostrar_puntos,
+                               filas_seleccionadas, decimales):
+    if df is None or df.empty:
+        return None
+
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales)
+    col_predicha = f"Concentración Predicha ({unidad_predicha})"
+    col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
+
+    df[col_predicha] = pd.to_numeric(df[col_predicha], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
+
+    df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
+    df_valid.reset_index(drop=True, inplace=True)
+
+    if not filas_seleccionadas:
+        return None
+
+    indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas if s.startswith('Fila')]
+    df_valid = df_valid.loc[indices_seleccionados]
+
+    if len(df_valid) < 2:
+        return None
+
+    fig = generar_graficos(
+        df_valid, n_replicas, unidad_predicha, unidad_replicas,
+        color_puntos, estilo_puntos,
+        color_linea_ajuste, estilo_linea_ajuste,
+        color_barras_error,
+        mostrar_linea_ajuste, mostrar_puntos
+    )
+    return fig
+
+def resetear_ajustes():
+    return (
+        gr.update(value=True),  # mostrar_linea_ajuste
+        gr.update(value=True),  # mostrar_puntos
+        gr.update(value="#0000FF"), # color_puntos
+        gr.update(value="o"),       # estilo_puntos
+        gr.update(value="#00FF00"), # color_linea_ajuste
+        gr.update(value="-"),       # estilo_linea_ajuste
+        gr.update(value="#FFA500")  # color_barras_error
+    )
 
 with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     gr.Markdown("""
     # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
 
-    En esta interfaz puede:
-    - Ingresar y/o cargar datos de calibración.
-    - Ajustar unidades, número de decimales, réplicas, etc.
-    - Calcular la regresión, visualizar gráficos y generar informes.
-
-    **Sugerencia:** Cargue sus datos o use un ejemplo, luego presione "Calcular" para obtener el análisis.
+    Ahora la unidad de medida por defecto es "Abs", tanto al limpiar datos como al cargar ejemplo OD.
     """)
 
     with gr.Tab("📝 Datos de Calibración"):
-        gr.Markdown("""
-        ### Ingrese Parámetros Iniciales
-        Ajuste las unidades y la concentración inicial, así como el número de filas y réplicas para la tabla.
-        """)
         with gr.Row():
             with gr.Column():
-                concentracion_input = gr.Number(
-                    value=2000000,
-                    label="Concentración Inicial",
-                    precision=0
-                )
-                unidad_predicha_input = gr.Textbox(
-                    value="mg/L",
-                    label="Unidad de Medida (Predicha)",
-                    placeholder="Ejemplo: mg/L"
-                )
-                unidad_replicas_input = gr.Textbox(
-                    value="UFC",
-                    label="Unidad de Medida (Absorbancias)",
-                    placeholder="Ejemplo: Abs, OD, UFC, etc."
-                )
-                
+                concentracion_input = gr.Number(value=150,label="Concentración Inicial",precision=0)
+                unidad_predicha_input = gr.Textbox(value="mg/L",label="Unidad de Medida (Predicha)")
+                # Por defecto Abs
+                unidad_replicas_input = gr.Textbox(value="Abs",label="Unidad de Medida (Absorbancias)")
             with gr.Column():
-                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"
-                )
+                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():
             with gr.Column():
-                gr.Markdown("### Acciones sobre la Tabla")
                 calcular_btn = gr.Button("🔄 Calcular", variant="primary")
                 ajustar_decimales_btn = gr.Button("🛠 Ajustar Decimales", variant="secondary")
                 limpiar_btn = gr.Button("🗑 Limpiar Datos", variant="secondary")
-            
             with gr.Column():
-                gr.Markdown("### Ejemplos y Carga de Datos")
-                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")
 
-        gr.Markdown("### Tabla de Datos")
         tabla_output = gr.DataFrame(
             wrap=True,
             label="Tabla de Datos",
@@ -733,33 +622,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         )
 
     with gr.Tab("📊 Análisis y Reporte"):
-        gr.Markdown("""
-        ### Análisis y Resultados
-        Seleccione las filas a utilizar en el análisis y presione Calcular. Ajuste colores y estilo según su preferencia.
-        """)
-        with gr.Row():
-            filas_seleccionadas = gr.CheckboxGroup(
-                label="Seleccione filas para el análisis",
-                choices=[],
-                value=[],
-            )
-
+        filas_seleccionadas = gr.CheckboxGroup(label="Seleccione filas para el análisis",choices=[],value=[])
         with gr.Row():
             with gr.Column():
                 color_puntos_picker = gr.ColorPicker(label="Color de Puntos", value="#0000FF")
-                estilo_puntos_dropdown = gr.Dropdown(
-                    choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"],
-                    value="o",
-                    label="Estilo de Punto"
-                )
+                estilo_puntos_dropdown = gr.Dropdown(choices=["o","s","^","D","v","<",">","h","H","p","*","X","d"],value="o",label="Estilo de Punto")
             
             with gr.Column():
                 color_linea_ajuste_picker = gr.ColorPicker(label="Color de la Línea de Ajuste", value="#00FF00")
-                estilo_linea_ajuste_dropdown = gr.Dropdown(
-                    choices=["-", "--", "-.", ":"],
-                    value="-",
-                    label="Estilo Línea de Ajuste"
-                )
+                estilo_linea_ajuste_dropdown = gr.Dropdown(choices=["-","--","-.",":"],value="-",label="Estilo Línea de Ajuste")
             
             with gr.Column():
                 color_barras_error_picker = gr.ColorPicker(label="Color Barras de Error", value="#FFA500")
@@ -768,13 +639,12 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
         with gr.Row():
             graficar_btn = gr.Button("📊 Graficar", variant="primary")
-            recalcular_btn = gr.Button("🔄 Recalcular", variant="secondary")
+            resetear_btn = gr.Button("🔄 Resetear Ajustes", variant="secondary")
 
         estado_output = gr.Textbox(label="Estado del Análisis", interactive=False)
         graficos_output = gr.Plot(label="Gráficos de Análisis")
-        informe_output = gr.Markdown(elem_id="informe_output")
+        informe_output = gr.Markdown()
 
-        gr.Markdown("### Exportar Informe")
         with gr.Row():
             copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary")
             exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary")
@@ -785,72 +655,24 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             exportar_latex_file = gr.File(label="Informe en LaTeX")
 
     with gr.Tab("📈 Regresión Absorbancia vs Concentración"):
-        gr.Markdown("""
-        ### Análisis de Regresión Adicional
-        Seleccione nuevamente las filas para la regresión y personalice los gráficos.
-        """)
-
-        filas_seleccionadas_regresion = gr.CheckboxGroup(
-            label="Seleccione filas para la regresión",
-            choices=[],
-            value=[],
-        )
-
-        with gr.Row():
-            color_puntos_regresion_picker = gr.ColorPicker(label="Color Puntos (Regresión)", value="#0000FF")
-            estilo_puntos_regresion = gr.Dropdown(
-                choices=["o", "s", "^", "D", "v", "<", ">", "h", "H", "p", "*", "X", "d"],
-                value="o",
-                label="Estilo de Puntos (Regresión)"
-            )
-            color_linea_ajuste_regresion_picker = gr.ColorPicker(label="Color Línea Ajuste (Regresión)", value="#00FF00")
-            estilo_linea_ajuste_regresion = gr.Dropdown(
-                choices=["-", "--", "-.", ":"],
-                value="-",
-                label="Estilo Línea de Ajuste (Regresión)"
-            )
-            mostrar_linea_ajuste_regresion = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste (Regresión)")
-            mostrar_puntos_regresion = gr.Checkbox(value=True, label="Mostrar Puntos (Regresión)")
+        filas_seleccionadas_regresion = gr.CheckboxGroup(label="Seleccione filas para la regresión",choices=[],value=[])
 
         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'
+                'best','upper right','upper left','lower left','lower right',
+                'right','center left','center right','lower center',
+                'upper center','center'
             ],
             value='lower right',
             label='Ubicación de la Leyenda'
         )
 
-        with gr.Row():
-            titulo_grafico_original = gr.Textbox(
-                label="Título del Gráfico Original",
-                placeholder="Ej: Regresión Lineal: Abs vs Conc (Original)"
-            )
-            titulo_grafico_personalizado = gr.Textbox(
-                label="Título del Gráfico Personalizado",
-                placeholder="Ej: Regresión Lineal Personalizada"
-            )
-
-        with gr.Row():
-            eje_x_original = gr.Textbox(
-                label="Etiqueta Eje X (Original)",
-                placeholder="Concentración Predicha (mg/L)"
-            )
-            eje_y_original = gr.Textbox(
-                label="Etiqueta Eje Y (Original)",
-                placeholder="Absorbancia Real Promedio (UFC)"
-            )
-
-        with gr.Row():
-            eje_x_personalizado = gr.Textbox(
-                label="Etiqueta Eje X (Personalizado)",
-                placeholder="Concentración Predicha (mg/L)"
-            )
-            eje_y_personalizado = gr.Textbox(
-                label="Etiqueta Eje Y (Personalizado)",
-                placeholder="Absorbancia Real Promedio (UFC)"
-            )
+        titulo_grafico_original = gr.Textbox(label="Título del Gráfico Original")
+        titulo_grafico_personalizado = gr.Textbox(label="Título del Gráfico Personalizado")
+        eje_x_original = gr.Textbox(label="Etiqueta Eje X (Original)")
+        eje_y_original = gr.Textbox(label="Etiqueta Eje Y (Original)")
+        eje_x_personalizado = gr.Textbox(label="Etiqueta Eje X (Personalizado)")
+        eje_y_personalizado = gr.Textbox(label="Etiqueta Eje Y (Personalizado)")
 
         calcular_regresion_btn = gr.Button("Calcular Regresión")
 
@@ -859,123 +681,50 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         grafico_personalizado_output = gr.Plot(label="Gráfico Personalizado")
         tabla_resumen_output = gr.DataFrame(label="Tabla Resumida")
 
-    tabla_output.change(
-        fn=actualizar_opciones_filas,
-        inputs=[tabla_output],
-        outputs=[filas_seleccionadas, filas_seleccionadas_regresion]
-    )
+    tabla_output.change(fn=actualizar_opciones_filas, inputs=[tabla_output], outputs=[filas_seleccionadas, filas_seleccionadas_regresion])
+
+    def calcular_y_marcar(df, replicas, up, ur, sel, dec):
+        estado, fig, informe, df = actualizar_analisis(df, replicas, up, ur, sel, dec)
+        return estado, fig, informe, df
 
     calcular_btn.click(
-        fn=actualizar_analisis,
+        fn=calcular_y_marcar,
         inputs=[tabla_output, replicas_slider, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas, decimales_slider],
         outputs=[estado_output, graficos_output, informe_output, tabla_output]
     )
 
-    def actualizar_graficos_custom(df, n_replicas, unidad_predicha, unidad_replicas,
-                                   color_puntos, estilo_puntos,
-                                   color_linea_ajuste, estilo_linea_ajuste,
-                                   color_barras_error,
-                                   mostrar_linea_ajuste, mostrar_puntos,
-                                   filas_seleccionadas, decimales):
-        if df is None or df.empty:
-            return None
-
-        df = calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales)
-
-        col_predicha = f"Concentración Predicha ({unidad_predicha})"
-        col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
-
-        df[col_predicha] = pd.to_numeric(df[col_predicha], errors='coerce')
-        df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
-
-        df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
-        df_valid.reset_index(drop=True, inplace=True)
-
-        if not filas_seleccionadas:
-            return None
-
-        indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
-        df_valid = df_valid.loc[indices_seleccionados]
-
-        if len(df_valid) < 2:
-            return None
-
-        fig = generar_graficos(
-            df_valid, n_replicas, unidad_predicha, unidad_replicas,
-            color_puntos, estilo_puntos,
-            color_linea_ajuste, estilo_linea_ajuste,
-            color_barras_error,
-            mostrar_linea_ajuste, mostrar_puntos
-        )
-        return fig
-
-    graficar_btn.click(
-        fn=actualizar_graficos_custom,
-        inputs=[
-            tabla_output, replicas_slider, unidad_predicha_input, unidad_replicas_input,
-            color_puntos_picker, estilo_puntos_dropdown,
-            color_linea_ajuste_picker, estilo_linea_ajuste_dropdown,
-            color_barras_error_picker,
-            mostrar_linea_ajuste, mostrar_puntos,
-            filas_seleccionadas, decimales_slider
-        ],
-        outputs=graficos_output
-    )
-
-    recalcular_btn.click(
-        fn=actualizar_analisis,
-        inputs=[tabla_output, replicas_slider, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas, decimales_slider],
-        outputs=[estado_output, graficos_output, informe_output, tabla_output]
+    ajustar_decimales_btn.click(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
     )
 
-    def resetear_valores():
-        return gr.update(value=True), gr.update(value=True)
-
-    calcular_btn.click(fn=resetear_valores, outputs=[mostrar_linea_ajuste, mostrar_puntos])
-    limpiar_btn.click(fn=resetear_valores, outputs=[mostrar_linea_ajuste, mostrar_puntos])
-    ajustar_decimales_btn.click(fn=resetear_valores, outputs=[mostrar_linea_ajuste, mostrar_puntos])
-    sinteticos_btn.click(fn=resetear_valores, outputs=[mostrar_linea_ajuste, mostrar_puntos])
+    def limpiar_todo(n_replicas):
+        c,u_pred,f_slider,df,est,g,inf = limpiar_datos(n_replicas)
+        return c,u_pred,"Abs",f_slider,df,"",None,"",[],[],3
 
     limpiar_btn.click(
-        fn=limpiar_datos,
+        fn=limpiar_todo,
         inputs=[replicas_slider],
-        outputs=[concentracion_input, unidad_predicha_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, filas_seleccionadas_regresion, decimales_slider]
     )
 
-    def cargar_ejemplo_ufc(n_replicas):
-        unidad_predicha = "mg/L"
-        unidad_replicas = "Abs"
-        df = pd.DataFrame({
-            "Solución": [1.00,0.80,0.67,0.60,0.53,0.47,0.40],
-            "H2O": [0.00,0.20,0.33,0.40,0.47,0.53,0.60],
-            "Factor de Dilución": [1.00,1.25,1.50,1.67,1.87,2.14,2.50],
-            f"Concentración Predicha ({unidad_predicha})": [150,120,100,90,80,70,60]
-        })
-        for i in range(1, n_replicas + 1):
-            df[f"Absorbancia Real {i} ({unidad_replicas})"] = np.nan
-        return 2000000, unidad_predicha, unidad_replicas, 7, df
-
-    def cargar_ejemplo_od(n_replicas):
+    # Cargar ejemplo OD, pero ahora con unidad_replicas = "Abs"
+    def cargar_ejemplo_od_func(n_replicas):
         unidad_predicha = "mg/L"
-        unidad_replicas = "OD"
+        unidad_replicas = "Abs" # Cambiado a Abs
         df = pd.DataFrame({
             "Solución": [1.00,0.80,0.60,0.40,0.20,0.10,0.05],
             "H2O": [0.00,0.20,0.40,0.60,0.80,0.90,0.95],
-            "Factor de Dilución": [1.00,1.25,1.67,2.50,5.00,10.00,20.00],
+            "Dimensión de Dilución": [1.00,1.25,1.67,2.50,5.00,10.00,20.00],
             f"Concentración Predicha ({unidad_predicha})": [1.0,0.8,0.6,0.4,0.2,0.1,0.05]
         })
         for i in range(1, n_replicas + 1):
             df[f"Absorbancia Real {i} ({unidad_replicas})"] = np.nan
-        return 1.000, unidad_predicha, unidad_replicas, 7, df
-
-    ejemplo_ufc_btn.click(
-        fn=cargar_ejemplo_ufc,
-        inputs=[replicas_slider],
-        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output]
-    )
+        return 150, unidad_predicha, unidad_replicas, 7, df
 
     ejemplo_od_btn.click(
-        fn=cargar_ejemplo_od,
+        fn=cargar_ejemplo_od_func,
         inputs=[replicas_slider],
         outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output]
     )
@@ -989,53 +738,18 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     cargar_excel_btn.upload(
         fn=cargar_excel,
         inputs=[cargar_excel_btn],
-        outputs=[concentracion_input, unidad_predicha_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
-    )
-
-    ajustar_decimales_btn.click(
-        fn=ajustar_decimales_evento,
-        inputs=[tabla_output, decimales_slider],
-        outputs=tabla_output
+        outputs=[concentracion_input, unidad_predicha_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, filas_seleccionadas_regresion]
     )
 
-    def actualizar_tabla_wrapper(df, filas, conc, unidad_predicha, unidad_replicas, replicas, decimales):
-        return actualizar_tabla_evento(df, filas, conc, unidad_predicha, unidad_replicas, replicas, decimales)
-
-    concentracion_input.change(
-        fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
-        outputs=tabla_output
-    )
+    def actualizar_tabla_wrapper(df, filas, conc, up, ur, rep, dec):
+        return actualizar_tabla_evento(df, filas, conc, up, ur, rep, dec)
 
-    unidad_predicha_input.change(
-        fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
-        outputs=tabla_output
-    )
-
-    unidad_replicas_input.change(
-        fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
-        outputs=tabla_output
-    )
-
-    filas_slider.change(
-        fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
-        outputs=tabla_output
-    )
-
-    replicas_slider.change(
-        fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
-        outputs=tabla_output
-    )
-
-    decimales_slider.change(
-        fn=ajustar_decimales_evento,
-        inputs=[tabla_output, decimales_slider],
-        outputs=tabla_output
-    )
+    concentracion_input.change(actualizar_tabla_wrapper,[tabla_output,filas_slider,concentracion_input,unidad_predicha_input,unidad_replicas_input,replicas_slider,decimales_slider],tabla_output)
+    unidad_predicha_input.change(actualizar_tabla_wrapper,[tabla_output,filas_slider,concentracion_input,unidad_predicha_input,unidad_replicas_input,replicas_slider,decimales_slider],tabla_output)
+    unidad_replicas_input.change(actualizar_tabla_wrapper,[tabla_output,filas_slider,concentracion_input,unidad_predicha_input,unidad_replicas_input,replicas_slider,decimales_slider],tabla_output)
+    filas_slider.change(actualizar_tabla_wrapper,[tabla_output,filas_slider,concentracion_input,unidad_predicha_input,unidad_replicas_input,replicas_slider,decimales_slider],tabla_output)
+    replicas_slider.change(actualizar_tabla_wrapper,[tabla_output,filas_slider,concentracion_input,unidad_predicha_input,unidad_replicas_input,replicas_slider,decimales_slider],tabla_output)
+    decimales_slider.change(ajustar_decimales_evento,[tabla_output,decimales_slider],tabla_output)
 
     copiar_btn.click(
         None,
@@ -1067,25 +781,152 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=exportar_latex_file
     )
 
-    interfaz.load(
-        fn=iniciar_con_ejemplo,
-        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider]
+    graficar_btn.click(
+        fn=recalcular_y_graficar,
+        inputs=[tabla_output, replicas_slider, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas, decimales_slider,
+                color_puntos_picker, estilo_puntos_dropdown, color_linea_ajuste_picker, estilo_linea_ajuste_dropdown,
+                color_barras_error_picker, mostrar_linea_ajuste, mostrar_puntos],
+        outputs=[estado_output, graficos_output, informe_output]
     )
 
+    resetear_btn.click(fn=resetear_ajustes, outputs=[mostrar_linea_ajuste, mostrar_puntos, color_puntos_picker, estilo_puntos_dropdown, color_linea_ajuste_picker, estilo_linea_ajuste_dropdown, color_barras_error_picker])
+
+    def calcular_regresion_tabla_principal(df, up, ur, fsr,
+                                           cp, ep, cla, ela,
+                                           mla, mp,
+                                           ll, dec,
+                                           tgo, tgp,
+                                           exo, eyo,
+                                           exp, eyp):
+
+        if df is None or df.empty:
+            return "Datos insuficientes", None, None, None
+
+        col_predicha = f"Concentración Predicha ({up})"
+        col_real_promedio = f"Absorbancia Real Promedio ({ur})"
+        col_desviacion = f"Desviación Estándar ({ur})"
+
+        n_replicas = len([c for c in df.columns if 'Absorbancia Real ' in c and 'Promedio' not in c and 'Desviación' not in c])
+        df = calcular_promedio_desviacion(df, n_replicas, up, ur, dec)
+
+        if col_predicha not in df.columns or col_real_promedio not in df.columns:
+            return "Faltan columnas necesarias", None, None, None
+
+        df[col_predicha] = pd.to_numeric(df[col_predicha], errors='coerce')
+        df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
+        df[col_desviacion] = pd.to_numeric(df[col_desviacion], errors='coerce').fillna(0)
+
+        df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
+        df_valid.reset_index(drop=True, inplace=True)
+
+        df_original = df_valid.copy()
+
+        if not fsr or len(fsr) < 2:
+            return "Se necesitan más datos", None, None, None
+
+        indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in fsr]
+        if len(indices_seleccionados) < 2:
+            return "Se requieren al menos dos puntos para calcular la regresión", None, None, None
+
+        df_valid = df_valid.loc[indices_seleccionados]
+
+        slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha], df_valid[col_real_promedio])
+
+        sns.set(style="whitegrid")
+        fig_original, ax_original = plt.subplots(figsize=(8, 6))
+        ax_original.errorbar(
+            df_original[col_predicha],
+            df_original[col_real_promedio],
+            yerr=df_original[col_desviacion],
+            fmt=ep,
+            color=safe_color(cp),
+            ecolor='gray',
+            elinewidth=1,
+            capsize=3,
+            label='Datos'
+        )
+        slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_predicha], df_original[col_real_promedio])
+        ax_original.plot(
+            df_original[col_predicha],
+            intercept_all + slope_all * df_original[col_predicha],
+            color=safe_color(cla),
+            linestyle='-',
+            label='Ajuste Lineal'
+        )
+
+        ax_original.set_xlabel(exo if exo else f'Concentración Predicha ({up})')
+        ax_original.set_ylabel(eyo if eyo else f'Absorbancia Real Promedio ({ur})')
+        ax_original.set_title(tgo if tgo else 'Regresión Lineal: Absorbancia Real vs Concentración Predicha (Original)')
+        ax_original.legend(loc=ll)
+        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'
+        )
+
+        sns.set(style="whitegrid")
+        fig_personalizado, ax_personalizado = plt.subplots(figsize=(8, 6))
+
+        if mp:
+            ax_personalizado.errorbar(
+                df_valid[col_predicha],
+                df_valid[col_real_promedio],
+                yerr=df_valid[col_desviacion],
+                fmt=ep,
+                color=safe_color(cp),
+                ecolor='gray',
+                elinewidth=1,
+                capsize=3,
+                label='Datos'
+            )
+
+        if mla:
+            ax_personalizado.plot(
+                df_valid[col_predicha],
+                intercept + slope * df_valid[col_predicha],
+                color=safe_color(cla),
+                linestyle=ela,
+                label='Ajuste Lineal'
+            )
+
+        ax_personalizado.set_xlabel(exp if exp else f'Concentración Predicha ({up})')
+        ax_personalizado.set_ylabel(eyp if eyp else f'Absorbancia Real Promedio ({ur})')
+        ax_personalizado.set_title(tgp if tgp else 'Regresión Lineal Personalizada')
+        ax_personalizado.legend(loc=ll)
+        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'
+        )
+
+        df_resumen = df_valid[[col_predicha, col_real_promedio, col_desviacion]].copy()
+        df_resumen.columns = [f'Concentración Predicha ({up})', 'Absorbancia Promedio', 'Desviación Estándar']
+
+        return "Regresión calculada exitosamente", fig_original, fig_personalizado, df_resumen
+
     calcular_regresion_btn.click(
         fn=calcular_regresion_tabla_principal,
-        inputs=[
-            tabla_output, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas_regresion,
-            color_puntos_regresion_picker, estilo_puntos_regresion,
-            color_linea_ajuste_regresion_picker, 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
-        ],
+        inputs=[tabla_output, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas_regresion,
+                color_puntos_picker, estilo_puntos_dropdown,
+                color_linea_ajuste_picker, estilo_linea_ajuste_dropdown,
+                mostrar_linea_ajuste, mostrar_puntos,
+                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]
     )
 
+    interfaz.load(
+        fn=iniciar_con_ejemplo,
+        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider]
+    )
+
 if __name__ == "__main__":
     interfaz.launch()