Update app.py

app.py

@@ -9,7 +9,6 @@ import docx
 from docx.shared import Inches, Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
-import re
 
 def generar_tabla(n_filas, concentracion_inicial, unidad_medida, n_replicas):
     valores_base = [1.000, 0.800, 0.600, 0.400, 0.200, 0.100, 0.050]
@@ -57,43 +56,87 @@ def ajustar_decimales_evento(df, decimales):
             pass
     return df
 
-def generar_graficos(df_valid, unidad_medida, col_absorbancia, palette_puntos, estilo_puntos,
+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)]
+    # Convertir a numérico
+    for col in col_replicas:
+        df[col] = pd.to_numeric(df[col], errors='coerce')
+
+    # Calcular el promedio y la desviación estándar
+    df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
+
+    if n_replicas > 1:
+        df[f"Desviación Estándar ({unidad_medida})"] = df[col_replicas].std(ddof=1, axis=1)
+    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,
                      palette_linea_ajuste, estilo_linea_ajuste,
-                     mostrar_linea_ajuste, mostrar_puntos):
+                     palette_linea_ideal, estilo_linea_ideal,
+                     palette_barras_error, mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
     col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+    col_desviacion = f"Desviación Estándar ({unidad_medida})"
 
     # Convertir a numérico
     df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_absorbancia] = df_valid[col_absorbancia].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
+    df_valid[col_desviacion] = df_valid[col_desviacion].fillna(0).astype(float)
 
     # Calcular regresión lineal
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_absorbancia])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Configurar estilos
     sns.set(style="whitegrid")
     plt.rcParams.update({'figure.autolayout': True})
 
-    fig, ax1 = plt.subplots(figsize=(7, 6))
+    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 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)
+    colors_linea_ideal = sns.color_palette(palette_linea_ideal, as_cmap=False)
+    colors_barras_error = sns.color_palette(palette_barras_error, as_cmap=False)
 
     # Seleccionar colores
     color_puntos = colors_puntos[0]
     color_linea_ajuste = colors_linea_ajuste[0]
+    color_linea_ideal = colors_linea_ideal[0]
+    color_barras_error = colors_barras_error[0]
 
     # Gráfico de dispersión con línea de regresión
     if mostrar_puntos:
-        ax1.scatter(
-            df_valid[col_predicha_num],
-            df_valid[col_absorbancia],
-            color=color_puntos,
-            s=100,
-            label='Datos',
-            marker=estilo_puntos
-        )
+        if n_replicas > 1:
+            # Incluir barras de error
+            ax1.errorbar(
+                df_valid[col_predicha_num],
+                df_valid[col_real_promedio],
+                yerr=df_valid[col_desviacion],
+                fmt=estilo_puntos,
+                color=color_puntos,
+                ecolor=color_barras_error,
+                elinewidth=2,
+                capsize=3,
+                label='Datos Reales'
+            )
+        else:
+            ax1.scatter(
+                df_valid[col_predicha_num],
+                df_valid[col_real_promedio],
+                color=color_puntos,
+                s=100,
+                label='Datos Reales',
+                marker=estilo_puntos
+            )
 
     # Línea de ajuste
     if mostrar_linea_ajuste:
@@ -106,9 +149,21 @@ def generar_graficos(df_valid, unidad_medida, col_absorbancia, palette_puntos, e
             linestyle=estilo_linea_ajuste
         )
 
-    ax1.set_title('Correlación entre Concentración Predicha y Absorbancia', fontsize=14)
+    # Línea ideal
+    if mostrar_linea_ideal:
+        min_predicha = df_valid[col_predicha_num].min()
+        max_predicha = df_valid[col_predicha_num].max()
+        ax1.plot(
+            [min_predicha, max_predicha],
+            [min_predicha, max_predicha],
+            color=color_linea_ideal,
+            linestyle=estilo_linea_ideal,
+            label='Ideal'
+        )
+
+    ax1.set_title('Correlación entre Concentración Predicha y Real', fontsize=14)
     ax1.set_xlabel('Concentración Predicha', fontsize=12)
-    ax1.set_ylabel('Absorbancia', fontsize=12)
+    ax1.set_ylabel('Concentración Real Promedio', fontsize=12)
 
     # Añadir ecuación y R² en el gráfico
     ax1.annotate(
@@ -123,6 +178,23 @@ def generar_graficos(df_valid, unidad_medida, col_absorbancia, palette_puntos, e
     # Posicionar la leyenda
     ax1.legend(loc='lower right', fontsize=10)
 
+    # Gráfico de residuos
+    residuos = df_valid[col_real_promedio] - df_valid['Ajuste Lineal']
+    ax2.scatter(
+        df_valid[col_predicha_num],
+        residuos,
+        color=color_puntos,
+        s=100,
+        marker=estilo_puntos,
+        label='Residuos'
+    )
+
+    ax2.axhline(y=0, color='black', linestyle='--', linewidth=1)
+    ax2.set_title('Gráfico de Residuos', fontsize=14)
+    ax2.set_xlabel('Concentración Predicha', fontsize=12)
+    ax2.set_ylabel('Residuo', fontsize=12)
+    ax2.legend(loc='upper right', fontsize=10)
+
     plt.tight_layout()
     plt.savefig('grafico.png')  # Guardar el gráfico para incluirlo en el informe
     return fig
@@ -155,19 +227,20 @@ def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
 
     return evaluacion
 
-def generar_informe_completo(df_valid, unidad_medida, col_absorbancia):
+def generar_informe_completo(df_valid, n_replicas, unidad_medida):
     """Generar un informe completo en formato markdown"""
     col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir a numérico
     df_valid[col_predicha_num] = df_valid[col_predicha_num].astype(float)
-    df_valid[col_absorbancia] = df_valid[col_absorbancia].astype(float)
+    df_valid[col_real_promedio] = df_valid[col_real_promedio].astype(float)
 
     # Calcular estadísticas
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_absorbancia])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     r_squared = r_value ** 2
-    rmse = np.sqrt(((df_valid[col_absorbancia] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
-    cv = (df_valid[col_absorbancia].std() / df_valid[col_absorbancia].mean()) * 100  # CV de los valores
+    rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
+    cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100  # CV de los valores reales
 
     # Evaluar calidad
     evaluacion = evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv)
@@ -198,7 +271,7 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def actualizar_analisis(df, unidad_medida, filas_seleccionadas, decimales, absorbancia_seleccionada):
+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
 
@@ -208,64 +281,67 @@ def actualizar_analisis(df, unidad_medida, filas_seleccionadas, decimales, absor
 
     indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
 
-    # Usar la columna de absorbancia seleccionada
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_absorbancia = absorbancia_seleccionada
+    # Calcular promedio y desviación estándar dependiendo de las réplicas
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
-    if col_absorbancia not in df.columns:
-        return "La columna seleccionada no existe en los datos", None, "Error en los datos", df
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
     df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df[col_absorbancia] = pd.to_numeric(df[col_absorbancia], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
-    df_valid = df.dropna(subset=[col_predicha_num, col_absorbancia])
+    df_valid = df.dropna(subset=[col_predicha_num, col_real_promedio])
 
-    # Resetear el índice
+    # 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 para el análisis", df
+        return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
 
-    # Calcular regresión lineal
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_absorbancia])
+    # Calcular la regresión y agregar 'Ajuste Lineal'
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
     df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha_num]
 
     # Generar gráfico con opciones predeterminadas
     fig = generar_graficos(
-        df_valid, unidad_medida, col_absorbancia,
+        df_valid, n_replicas, unidad_medida,
         palette_puntos='deep', estilo_puntos='o',
         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=False,  # Línea Ideal desmarcada por defecto
         mostrar_puntos=True
     )
-    informe, estado = generar_informe_completo(df_valid, unidad_medida, col_absorbancia)
+    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
 
     return estado, fig, informe, df
 
-def actualizar_graficos(df, unidad_medida,
+def actualizar_graficos(df, n_replicas, unidad_medida,
                         palette_puntos, estilo_puntos,
                         palette_linea_ajuste, estilo_linea_ajuste,
-                        mostrar_linea_ajuste, mostrar_puntos,
-                        filas_seleccionadas, decimales, absorbancia_seleccionada):
+                        palette_linea_ideal, estilo_linea_ideal,
+                        palette_barras_error,
+                        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
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_absorbancia = absorbancia_seleccionada
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
 
-    if col_absorbancia not in df.columns:
-        return None
+    col_predicha_num = "Concentración Predicha Numérica"
+    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
 
     # Convertir columnas a numérico
     df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
-    df[col_absorbancia] = pd.to_numeric(df[col_absorbancia], errors='coerce')
+    df[col_real_promedio] = pd.to_numeric(df[col_real_promedio], errors='coerce')
 
-    df_valid = df.dropna(subset=[col_predicha_num, col_absorbancia])
+    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)
@@ -284,56 +360,411 @@ def actualizar_graficos(df, unidad_medida,
 
     # Generar gráfico con opciones seleccionadas
     fig = generar_graficos(
-        df_valid, unidad_medida, col_absorbancia,
+        df_valid, n_replicas, unidad_medida,
         palette_puntos, estilo_puntos,
         palette_linea_ajuste, estilo_linea_ajuste,
-        mostrar_linea_ajuste, mostrar_puntos
+        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.000, "OD", n_replicas)
+    # Valores reales de ejemplo
+    for i in range(1, n_replicas + 1):
+        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.000, "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, 3)
+        df[col_real] = datos_sinteticos
+
+    return df
+
+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)
+
+    # 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]
+
+    # 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=0)  # Leer la primera pestaña
-
-    # Verificar que las columnas 'Absorbancia' existan
-    absorbancia_columns = [col for col in df.columns if 'Absorbancia' in col]
-    if not absorbancia_columns:
-        return "El archivo debe tener columnas 'Absorbancia'", None, None, None, None, None, None, None, None
-
-    # Obtener concentración inicial y unidad de medida desde el nombre de la primera columna
-    first_column_name = df.columns[0]
-    try:
-        # Extraer concentración y unidad
-        match = re.search(r'\(([\d\.]+)\s*(\w+)\)', first_column_name)
-        if match:
-            concentracion_inicial = float(match.group(1))
-            unidad_medida = match.group(2)
-        else:
-            concentracion_inicial = 0
-            unidad_medida = ''
-    except:
-        concentracion_inicial = 0
-        unidad_medida = ''
+    df = pd.read_excel(file.name, sheet_name=None)
 
-    n_filas = len(df)
-    n_replicas = 1  # Solo se selecciona una columna de absorbancia para el análisis
+    # 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)
 
-    # Copiar las columnas relevantes al DataFrame base
-    for col in df.columns:
-        if col in df_base.columns:
-            df_base[col] = df[col]
-        else:
-            df_base[col] = df[col]
+    # Llenar la tabla con los datos de cada pestaña
+    for i, (sheet_name, sheet_df) in enumerate(df.items(), start=1):
+        col_real = f"Concentración Real {i} ({unidad_medida})"
+        df_base[col_real] = sheet_df.iloc[:, 1].values
+
+    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, "", None, ""
+
+def calcular_regresion_tabla_principal(df, unidad_medida, 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)
 
-    # Obtener las opciones de absorbancia
-    absorbancia_options = absorbancia_columns  # Nombres tal como aparecen en el archivo Excel
+    # 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)
 
-    return concentracion_inicial, unidad_medida, n_filas, n_replicas, df_base, absorbancia_options, "", None, ""
+    # 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=[])
@@ -394,12 +825,6 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             sinteticos_btn = gr.Button("🧪 Generar Datos Sintéticos", variant="secondary")
             cargar_excel_btn = gr.UploadButton("📂 Cargar Excel", file_types=[".xlsx"], variant="secondary")
 
-        absorbancia_dropdown = gr.Dropdown(
-            label="Seleccione la Absorbancia para el análisis",
-            choices=[],
-            value=None
-        )
-
         tabla_output = gr.DataFrame(
             wrap=True,
             label="Tabla de Datos",
@@ -411,13 +836,16 @@ 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
             paletas_colores = ["deep", "muted", "pastel", "bright", "dark", "colorblind", "Set1", "Set2", "Set3"]
 
             palette_puntos_dropdown = gr.Dropdown(
@@ -442,7 +870,23 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             )
 
         with gr.Row():
+            palette_linea_ideal_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="bright",
+                label="Paleta Línea Ideal"
+            )
+            estilo_linea_ideal_dropdown = gr.Dropdown(
+                choices=["--", "-", "-.", ":"],
+                value="--",
+                label="Estilo Línea Ideal"
+            )
+            palette_barras_error_dropdown = gr.Dropdown(
+                choices=paletas_colores,
+                value="pastel",
+                label="Paleta Barras de Error"
+            )
             mostrar_linea_ajuste = gr.Checkbox(value=True, label="Mostrar Línea de Ajuste")
+            mostrar_linea_ideal = gr.Checkbox(value=False, label="Mostrar Línea Ideal")  # Desmarcado por defecto
             mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos")
             graficar_btn = gr.Button("📊 Graficar", variant="primary")
 
@@ -455,19 +899,106 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             exportar_word_file = gr.File(label="Informe en Word")
             exportar_latex_file = gr.File(label="Informe en LaTeX")
 
+        # Informe al final
         informe_output = gr.Markdown(elem_id="informe_output")
 
+    with gr.Tab("📈 Regresión Absorbancia vs Concentración"):
+        gr.Markdown("## Ajuste de Regresión utilizando datos de la Tabla Principal")
+
+        # Casillas para seleccionar filas
+        filas_seleccionadas_regresion = gr.CheckboxGroup(
+            label="Seleccione las filas a incluir en el análisis de regresión",
+            choices=[],
+            value=[],
+        )
+
+        # 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, ]
+        outputs=[filas_seleccionadas, filas_seleccionadas_regresion]
     )
 
     # Evento al presionar el botón Calcular
     calcular_btn.click(
         fn=actualizar_analisis,
-        inputs=[tabla_output, unidad_input, filas_seleccionadas, decimales_slider, absorbancia_dropdown],
+        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
         outputs=[estado_output, graficos_output, informe_output, tabla_output]
     )
 
@@ -475,26 +1006,145 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     graficar_btn.click(
         fn=actualizar_graficos,
         inputs=[
-            tabla_output, unidad_input,
+            tabla_output, replicas_slider, unidad_input,
             palette_puntos_dropdown, estilo_puntos_dropdown,
             palette_linea_ajuste_dropdown, estilo_linea_ajuste_dropdown,
-            mostrar_linea_ajuste, mostrar_puntos,
-            filas_seleccionadas, decimales_slider, absorbancia_dropdown
+            palette_linea_ideal_dropdown, estilo_linea_ideal_dropdown,
+            palette_barras_error_dropdown,
+            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+            filas_seleccionadas, decimales_slider
         ],
         outputs=graficos_output
     )
 
+    # Asegurar que la línea ideal esté desmarcada por defecto
+    def resetear_linea_ideal():
+        return gr.update(value=False)
+
+    # Desmarcar 'Mostrar Línea Ideal' en eventos de botones
+    calcular_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    limpiar_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    ajustar_decimales_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+    sinteticos_btn.click(
+        fn=resetear_linea_ideal,
+        outputs=mostrar_linea_ideal
+    )
+
+    # Eventos de los botones adicionales, como limpiar, cargar ejemplos, ajustar decimales, etc.
     # Evento para limpiar datos
     limpiar_btn.click(
-        fn=lambda: (2000000, "UFC", 7, generar_tabla(7, 2000000, "UFC", 1), "", None, "", [], 3, [], None),
-        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider, absorbancia_dropdown, absorbancia_dropdown]
+        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, absorbancia_dropdown, estado_output, graficos_output, informe_output]
+        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, decimales):
+        return actualizar_tabla_evento(df, filas, conc, unidad, replicas, decimales)
+
+    concentracion_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    unidad_input.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    filas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    replicas_slider.change(
+        fn=actualizar_tabla_wrapper,
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    decimales_slider.change(
+        fn=ajustar_decimales_evento,
+        inputs=[tabla_output, decimales_slider],
+        outputs=tabla_output
+    )
+
+    # Evento de copiar informe utilizando JavaScript
+    copiar_btn.click(
+        None,
+        [],
+        [],
+        js="""
+        function() {
+            const informeElement = document.querySelector('#informe_output');
+            const range = document.createRange();
+            range.selectNode(informeElement);
+            window.getSelection().removeAllRanges();
+            window.getSelection().addRange(range);
+            document.execCommand('copy');
+            window.getSelection().removeAllRanges();
+            alert('Informe copiado al portapapeles');
+        }
+        """
+    )
+
+    # Eventos de exportar informes
+    exportar_word_btn.click(
+        fn=exportar_word,
+        inputs=[tabla_output, informe_output, unidad_input, filas_seleccionadas],
+        outputs=exportar_word_file
+    )
+
+    exportar_latex_btn.click(
+        fn=exportar_latex,
+        inputs=[tabla_output, informe_output, filas_seleccionadas],
+        outputs=exportar_latex_file
     )
 
     # Inicializar la interfaz con el ejemplo base
@@ -502,10 +1152,11 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         n_replicas = 1
         df = generar_tabla(7, 2000000, "UFC", n_replicas)
         # Valores reales de ejemplo
-        df["Absorbancia 1"] = [0.8, 0.65, 0.5, 0.35, 0.2, 0.1, 0.05]
+        df[f"Concentración Real 1 (UFC)"] = [2000000, 1600000, 1200000, 800000, 400000, 200000, 100000]
+        # Calcular promedio y desviación estándar
+        df = calcular_promedio_desviacion(df, n_replicas, "UFC", 3)
         filas_seleccionadas_inicial = [f"Fila {i+1}" for i in df.index]
-        absorbancia_options = ["Absorbancia 1"]
-        estado, fig, informe, df = actualizar_analisis(df, "UFC", filas_seleccionadas_inicial, 3, "Absorbancia 1")
+        estado, fig, informe, df = actualizar_analisis(df, n_replicas, "UFC", filas_seleccionadas_inicial, 3)
         return (
             2000000,
             "UFC",
@@ -515,14 +1166,28 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             fig,
             informe,
             filas_seleccionadas_inicial,
-            3,  # Número de decimales
-            absorbancia_options,
-            "Absorbancia 1"
+            3  # Número de decimales
         )
 
     interfaz.load(
         fn=iniciar_con_ejemplo,
-        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider, absorbancia_dropdown, absorbancia_dropdown]
+        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