Update app.py

app.py

@@ -11,26 +11,20 @@ from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
 import os
 from matplotlib.colors import to_hex
 
-
 def safe_color(c):
     if isinstance(c, str):
         c = c.strip()
         if c.lower().startswith('rgba('):
-            # Extraer valores numéricos del string rgba
             vals = c.strip('rgba()').split(',')
             vals = [v.strip() for v in vals]
             if len(vals) == 4:
                 r, g, b, a = [float(x) for x in vals]
-                # Los valores en rgba(...) parecen ser mayores a 1, interpretamos que están en escala 0-255.
-                # Convertimos a rango [0,1]:
-                r /= 255.0
-                g /= 255.0
-                b /= 255.0
-                # Convertimos a hex
+                r = r/255.0 if r > 1 else r
+                g = g/255.0 if g > 1 else g
+                b = b/255.0 if b > 1 else b
                 c = to_hex((r, g, b, a))
     return c
 
-
 def ajustar_decimales_evento(df, decimales):
     df = df.copy()
     for col in df.columns:
@@ -41,66 +35,64 @@ def ajustar_decimales_evento(df, decimales):
             pass
     return df
 
-def calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales):
+def calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales):
     df = df.copy()
-    col_replicas = [c for c in df.columns if c.startswith("Concentración Real") and unidad_medida in c and "Promedio" not in c and "Desviación" not in c]
+    # Ahora las columnas de las réplicas se llaman "Absorbancia Real X (unidad_replicas)"
+    col_replicas = [c for c in df.columns if c.startswith("Absorbancia Real") and f"({unidad_replicas})" in c and "Promedio" not in c and "Desviación" not in c]
+
     for col in col_replicas:
         df[col] = pd.to_numeric(df[col], errors='coerce')
 
     if len(col_replicas) > 0:
-        df[f"Concentración Real Promedio ({unidad_medida})"] = df[col_replicas].mean(axis=1)
+        df[f"Absorbancia Real Promedio ({unidad_replicas})"] = df[col_replicas].mean(axis=1)
     else:
-        df[f"Concentración Real Promedio ({unidad_medida})"] = np.nan
+        df[f"Absorbancia Real Promedio ({unidad_replicas})"] = np.nan
 
     if len(col_replicas) > 1:
-        df[f"Desviación Estándar ({unidad_medida})"] = df[col_replicas].std(ddof=1, axis=1)
+        df[f"Desviación Estándar ({unidad_replicas})"] = df[col_replicas].std(ddof=1, axis=1)
     else:
-        df[f"Desviación Estándar ({unidad_medida})"] = 0.0
+        df[f"Desviación Estándar ({unidad_replicas})"] = 0.0
 
-    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)
+    df[f"Absorbancia Real Promedio ({unidad_replicas})"] = df[f"Absorbancia Real Promedio ({unidad_replicas})"].round(decimales)
+    df[f"Desviación Estándar ({unidad_replicas})"] = df[f"Desviación Estándar ({unidad_replicas})"].round(decimales)
 
     return df
 
-def generar_graficos(df_valid, n_replicas, unidad_medida,
+def generar_graficos(df_valid, n_replicas, unidad_predicha, unidad_replicas,
                      color_puntos, estilo_puntos,
                      color_linea_ajuste, estilo_linea_ajuste,
-                     color_linea_ideal, estilo_linea_ideal,
                      color_barras_error,
-                     mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos):
+                     mostrar_linea_ajuste, mostrar_puntos):
 
-    # Convertir colores a formato válido para matplotlib
     color_puntos = safe_color(color_puntos)
     color_linea_ajuste = safe_color(color_linea_ajuste)
-    color_linea_ideal = safe_color(color_linea_ideal)
     color_barras_error = safe_color(color_barras_error)
 
-    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})"
+    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})"
 
-    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_predicha] = pd.to_numeric(df_valid[col_predicha], errors='coerce')
     df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
     df_valid[col_desviacion] = pd.to_numeric(df_valid[col_desviacion], errors='coerce').fillna(0)
 
-    if df_valid.empty or df_valid[col_predicha_num].isna().all() or df_valid[col_real_promedio].isna().all():
+    if df_valid.empty or df_valid[col_predicha].isna().all() or df_valid[col_real_promedio].isna().all():
         fig = plt.figure()
         plt.text(0.5,0.5,"Datos insuficientes para generar el gráfico",ha='center',va='center')
         return fig
 
-    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]
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha], df_valid[col_real_promedio])
+    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha]
 
     sns.set(style="whitegrid")
     plt.rcParams.update({'figure.autolayout': True})
 
     fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(14, 6))
 
-    # Gráfico principal
     if mostrar_puntos:
         if n_replicas > 1:
             ax1.errorbar(
-                df_valid[col_predicha_num],
+                df_valid[col_predicha],
                 df_valid[col_real_promedio],
                 yerr=df_valid[col_desviacion],
                 fmt=estilo_puntos,
@@ -112,7 +104,7 @@ def generar_graficos(df_valid, n_replicas, unidad_medida,
             )
         else:
             ax1.scatter(
-                df_valid[col_predicha_num],
+                df_valid[col_predicha],
                 df_valid[col_real_promedio],
                 color=color_puntos,
                 s=100,
@@ -122,7 +114,7 @@ def generar_graficos(df_valid, n_replicas, unidad_medida,
 
     if mostrar_linea_ajuste:
         ax1.plot(
-            df_valid[col_predicha_num],
+            df_valid[col_predicha],
             df_valid['Ajuste Lineal'],
             color=color_linea_ajuste,
             label='Ajuste Lineal',
@@ -130,20 +122,9 @@ def generar_graficos(df_valid, n_replicas, unidad_medida,
             linestyle=estilo_linea_ajuste
         )
 
-    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('Concentración Real Promedio', fontsize=12)
+    ax1.set_title('Correlación entre Concentración Predicha y Absorbancia Real', fontsize=14)
+    ax1.set_xlabel(f'Concentración Predicha ({unidad_predicha})', fontsize=12)
+    ax1.set_ylabel(f'Absorbancia Real Promedio ({unidad_replicas})', fontsize=12)
 
     ax1.annotate(
         f'y = {intercept:.3f} + {slope:.3f}x\n$R^2$ = {r_value**2:.4f}',
@@ -156,10 +137,9 @@ def generar_graficos(df_valid, n_replicas, unidad_medida,
 
     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],
+        df_valid[col_predicha],
         residuos,
         color=color_puntos,
         s=100,
@@ -169,7 +149,7 @@ def generar_graficos(df_valid, n_replicas, unidad_medida,
 
     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_xlabel(f'Concentración Predicha ({unidad_predicha})', fontsize=12)
     ax2.set_ylabel('Residuo', fontsize=12)
     ax2.legend(loc='upper right', fontsize=10)
 
@@ -207,20 +187,20 @@ def evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv_percent):
 
     return evaluacion
 
-def generar_informe_completo(df_valid, n_replicas, unidad_medida):
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+def generar_informe_completo(df_valid, n_replicas, unidad_predicha, unidad_replicas):
+    col_predicha = f"Concentración Predicha ({unidad_predicha})"
+    col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
 
-    df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    df_valid[col_predicha] = pd.to_numeric(df_valid[col_predicha], errors='coerce')
     df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
     if len(df_valid) < 2:
         informe = "# Informe de Calibración ⚠️\nNo hay suficientes datos para calcular la regresión."
         return informe, "⚠️"
 
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha_num], df_valid[col_real_promedio])
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha], df_valid[col_real_promedio])
     r_squared = r_value ** 2
-    rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha_num])) ** 2).mean())
+    rmse = np.sqrt(((df_valid[col_real_promedio] - (intercept + slope * df_valid[col_predicha])) ** 2).mean())
     cv = (df_valid[col_real_promedio].std() / df_valid[col_real_promedio].mean()) * 100 if df_valid[col_real_promedio].mean() != 0 else 0
 
     evaluacion = evaluar_calidad_calibracion(df_valid, r_squared, rmse, cv)
@@ -251,7 +231,7 @@ Fecha: {datetime.now().strftime('%d/%m/%Y %H:%M')}
 """
     return informe, evaluacion['estado']
 
-def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, decimales):
+def actualizar_analisis(df, n_replicas, unidad_predicha, unidad_replicas, filas_seleccionadas, decimales):
     if df is None or df.empty:
         return "Error en los datos", None, "No se pueden generar análisis", df
 
@@ -260,15 +240,15 @@ def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, deci
 
     indices_seleccionados = [int(s.split(' ')[1]) - 1 for s in filas_seleccionadas]
 
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
+    df = calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales)
 
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+    col_predicha = f"Concentración Predicha ({unidad_predicha})"
+    col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
 
-    df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+    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_num, col_real_promedio])
+    df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
     df_valid.reset_index(drop=True, inplace=True)
 
     df_valid = df_valid.loc[indices_seleccionados]
@@ -276,25 +256,22 @@ def actualizar_analisis(df, n_replicas, unidad_medida, filas_seleccionadas, deci
     if len(df_valid) < 2:
         return "Se necesitan más datos", None, "Se requieren al menos dos valores reales para el análisis", df
 
-    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]
+    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_predicha], df_valid[col_real_promedio])
+    df_valid['Ajuste Lineal'] = intercept + slope * df_valid[col_predicha]
 
-    # Generar gráfico con colores por defecto (podrán actualizarse con el botón Graficar)
     fig = generar_graficos(
-        df_valid, n_replicas, unidad_medida,
+        df_valid, n_replicas, unidad_predicha, unidad_replicas,
         color_puntos="#0000FF", estilo_puntos='o',
         color_linea_ajuste="#00FF00", estilo_linea_ajuste='-',
-        color_linea_ideal="#FF0000", estilo_linea_ideal='--',
         color_barras_error="#FFA500",
         mostrar_linea_ajuste=True,
-        mostrar_linea_ideal=False,
         mostrar_puntos=True
     )
-    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_medida)
+    informe, estado = generar_informe_completo(df_valid, n_replicas, unidad_predicha, unidad_replicas)
 
     return estado, fig, informe, df
 
-def exportar_informe_word(df_valid, informe_md, unidad_medida):
+def exportar_informe_word(df_valid, informe_md, unidad_predicha, unidad_replicas):
     doc = docx.Document()
 
     style = doc.styles['Normal']
@@ -368,16 +345,16 @@ def exportar_informe_latex(df_valid, informe_md):
         f.write(informe_tex)
     return filename
 
-def exportar_word(df, informe_md, unidad_medida, filas_seleccionadas):
+def exportar_word(df, informe_md, unidad_predicha, unidad_replicas, filas_seleccionadas):
     df_valid = df.copy()
-    col_predicha_num = "Concentración Predicha Numérica"
-    col_real_promedio = [c for c in df_valid.columns if 'Real Promedio' in c][0] if any('Real Promedio' in c for c in df_valid.columns) else None
+    col_predicha = f"Concentración Predicha ({unidad_predicha})"
+    col_real_promedio = [c for c in df_valid.columns if 'Absorbancia Real Promedio' in c][0] if any('Absorbancia Real Promedio' in c for c in df_valid.columns) else None
 
-    if col_predicha_num in df_valid.columns:
-        df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    if col_predicha in df_valid.columns:
+        df_valid[col_predicha] = pd.to_numeric(df_valid[col_predicha], errors='coerce')
     if col_real_promedio:
         df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
-    df_valid = df_valid.dropna(subset=[col_predicha_num] if col_predicha_num else df_valid.columns[0], how='all')
+    df_valid = df_valid.dropna(subset=[col_predicha] if col_predicha else df_valid.columns[0], how='all')
     df_valid.reset_index(drop=True, inplace=True)
 
     if not filas_seleccionadas:
@@ -392,20 +369,21 @@ def exportar_word(df, informe_md, unidad_medida, filas_seleccionadas):
     if df_valid.empty:
         return None
 
-    filename = exportar_informe_word(df_valid, informe_md, unidad_medida)
+    filename = exportar_informe_word(df_valid, informe_md, unidad_predicha, unidad_replicas)
     return filename
 
 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] if any('Real Promedio' in c for c in df_valid.columns) else None
+    col_predicha = [c for c in df_valid.columns if 'Concentración Predicha' in c]
+    col_predicha = col_predicha[0] if col_predicha else None
+    col_real_promedio = [col for col in df_valid.columns if 'Absorbancia Real Promedio' in col][0] if any('Absorbancia Real Promedio' in c for c in df_valid.columns) else None
 
-    if col_predicha_num in df_valid.columns:
-        df_valid[col_predicha_num] = pd.to_numeric(df_valid[col_predicha_num], errors='coerce')
+    if col_predicha and col_predicha in df_valid.columns:
+        df_valid[col_predicha] = pd.to_numeric(df_valid[col_predicha], errors='coerce')
     if col_real_promedio:
         df_valid[col_real_promedio] = pd.to_numeric(df_valid[col_real_promedio], errors='coerce')
 
-    df_valid = df_valid.dropna(subset=[col_predicha_num] if col_predicha_num else df_valid.columns[0], how='all')
+    df_valid = df_valid.dropna(subset=[col_predicha] if col_predicha else df_valid.columns[0], how='all')
     df_valid.reset_index(drop=True, inplace=True)
 
     if not filas_seleccionadas:
@@ -424,16 +402,24 @@ def exportar_latex(df, informe_md, filas_seleccionadas):
     return filename
 
 def limpiar_datos(n_replicas):
+    # Por defecto asignamos una unidad de predicha y replicas.
+    # Aquí el ejemplo quedará con mg/L para predicha y Absorbancia para réplicas
+    unidad_predicha = "mg/L"
+    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)],
-        "Concentración Predicha Numérica": [2000000/(1/(1/(2**i))) for i in range(7)],
-        "Concentración Predicha (mg/L)": [2000000/(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)]
     })
+    # Creamos columnas de absorbancia real vacías
+    for i in range(1, n_replicas+1):
+        df[f"Absorbancia Real {i} ({unidad_replicas})"] = np.nan
+
     return (
         2000000,
-        "UFC",
+        unidad_predicha,
         7,
         df,
         "",
@@ -441,24 +427,24 @@ def limpiar_datos(n_replicas):
         ""
     )
 
-def generar_datos_sinteticos_evento(df, n_replicas, unidad_medida):
+def generar_datos_sinteticos_evento(df, n_replicas, unidad_predicha, unidad_replicas):
     df = df.copy()
-    col_predicha_num = "Concentración Predicha Numérica"
-    if col_predicha_num in df.columns:
-        df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+    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"Concentración Real {i} ({unidad_medida})"
-            desviacion_std = 0.05 * df[col_predicha_num].mean()
-            valores_predichos = df[col_predicha_num].dropna().values
+            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_num].notna(), col_real] = datos_sinteticos
+            df.loc[df[col_predicha].notna(), col_real] = datos_sinteticos
     return df
 
-def actualizar_tabla_evento(df, n_filas, conc, unidad, n_replicas, decimales):
+def actualizar_tabla_evento(df, n_filas, conc, unidad_predicha, unidad_replicas, n_replicas, decimales):
     df = df.copy()
     if len(df) > n_filas:
         df = df.iloc[:n_filas].reset_index(drop=True)
@@ -483,17 +469,30 @@ def cargar_excel(file):
     df_sheet2 = all_sheets[sheet2_name]
     df_sheet3 = all_sheets[sheet3_name]
 
-    df_base = df_sheet1.iloc[:, :5].copy()
+    df_base = df_sheet1.iloc[:, :4].copy()
+
+    # Intentar extraer la unidad de predicha del nombre de la columna de Concentración Predicha
+    # Suponemos que la cuarta columna es "Concentración Predicha (...)"
+    pred_col = df_base.columns[-1]
+    unidad_predicha = "mg/L"
+    try:
+        # intentar extraer unidad de predicha
+        if "(" in pred_col and ")" in pred_col:
+            unidad_predicha = pred_col.split("(")[1].split(")")[0].strip()
+    except:
+        unidad_predicha = "mg/L"
+
+    # Por defecto, la unidad de las réplicas (absorbancias)
+    unidad_replicas = "Abs"
 
-    primera_col = df_base.columns[0]
+    # Intentar extraer la concentración inicial y unidad
+    # Si no se logra, usamos por defecto
     try:
-        parte_interna = primera_col.split('(')[1].split(')')[0]
-        partes = parte_interna.split()
-        unidad_medida = partes[-1]
-        concentracion_inicial = float("".join(partes[:-1]))
+        primera_col = df_base.columns[0]
+        # Antes se intentaba extraer la unidad de aquí, ahora sólo la concentración inicial
+        concentracion_inicial = 2000000.0
     except:
         concentracion_inicial = 2000000.0
-        unidad_medida = "UFC"
 
     n_filas = len(df_base)
     n_replicas = 2
@@ -503,10 +502,10 @@ def cargar_excel(file):
     col_replica_1 = df_sheet2.iloc[:n_filas, 1].values if df_sheet2.shape[1] > 1 else df_sheet2.iloc[:n_filas,0].values
     col_replica_2 = df_sheet3.iloc[:n_filas, 1].values if df_sheet3.shape[1] > 1 else df_sheet3.iloc[:n_filas,0].values
 
-    df_sistema[f"Concentración Real 1 ({unidad_medida})"] = col_replica_1
-    df_sistema[f"Concentración Real 2 ({unidad_medida})"] = col_replica_2
+    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_medida, 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:
@@ -516,7 +515,7 @@ def actualizar_opciones_filas(df):
         update = gr.update(choices=opciones, value=opciones)
     return update, update
 
-def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_regresion,
+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,
@@ -528,25 +527,24 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
     if df is None or df.empty:
         return "Datos insuficientes", None, None, None
 
-    # Convertir colores a formato seguro
     color_puntos = safe_color(color_puntos)
     color_linea_ajuste = safe_color(color_linea_ajuste)
 
-    col_concentracion = "Concentración Predicha Numérica"
-    col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
-    col_desviacion = f"Desviación Estándar ({unidad_medida})"
+    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 'Concentración Real' in c and 'Promedio' not in c and 'Desviación' not in c])
-    df = calcular_promedio_desviacion(df, n_replicas, unidad_medida, decimales)
+    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_concentracion not in df.columns or col_real_promedio not in df.columns:
+    if col_predicha not in df.columns or col_real_promedio not in df.columns:
         return "Faltan columnas necesarias", None, None, None
 
-    df[col_concentracion] = pd.to_numeric(df[col_concentracion], errors='coerce')
+    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_concentracion, col_real_promedio])
+    df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
     df_valid.reset_index(drop=True, inplace=True)
 
     df_original = df_valid.copy()
@@ -560,14 +558,14 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
 
     df_valid = df_valid.loc[indices_seleccionados]
 
-    slope, intercept, r_value, p_value, std_err = stats.linregress(df_valid[col_concentracion], df_valid[col_real_promedio])
+    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_concentracion],
+        df_original[col_predicha],
         df_original[col_real_promedio],
         yerr=df_original[col_desviacion],
         fmt=estilo_puntos,
@@ -578,19 +576,19 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         label='Datos'
     )
 
-    slope_all, intercept_all, r_value_all, p_value_all, std_err_all = stats.linregress(df_original[col_concentracion], df_original[col_real_promedio])
+    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_concentracion],
-        intercept_all + slope_all * df_original[col_concentracion],
+        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 '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)')
+    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(
@@ -608,7 +606,7 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
 
     if mostrar_puntos:
         ax_personalizado.errorbar(
-            df_valid[col_concentracion],
+            df_valid[col_predicha],
             df_valid[col_real_promedio],
             yerr=df_valid[col_desviacion],
             fmt=estilo_puntos,
@@ -621,15 +619,15 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
 
     if mostrar_linea_ajuste:
         ax_personalizado.plot(
-            df_valid[col_concentracion],
-            intercept + slope * df_valid[col_concentracion],
+            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 '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_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)
 
@@ -642,25 +640,27 @@ def calcular_regresion_tabla_principal(df, unidad_medida, filas_seleccionadas_re
         verticalalignment='top'
     )
 
-    df_resumen = df_valid[[col_concentracion, col_real_promedio, col_desviacion]].copy()
-    df_resumen.columns = ['Concentración Predicha', 'Absorbancia Promedio', 'Desviación Estándar']
+    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
 
 def iniciar_con_ejemplo():
+    unidad_predicha = "mg/L"
+    unidad_replicas = "UFC"
     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],
-        "Concentración Predicha Numérica": [150,120,100,90,80,70,60],
-        "Concentración Predicha (mg/L)": [150,120,100,90,80,70,60],
-        "Concentración Real 1 (UFC)": [1.715,1.089,0.941,0.552,0.703,0.801,0.516]
+        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, "UFC", [f"Fila {i+1}" for i in df.index], 3)
+    estado, fig, informe, df = actualizar_analisis(df, n_replicas, unidad_predicha, unidad_replicas, [f"Fila {i+1}" for i in df.index], 3)
     return (
         2000000,
-        "UFC",
+        unidad_predicha,
+        unidad_replicas,
         7,
         df,
         estado,
@@ -670,11 +670,13 @@ def iniciar_con_ejemplo():
         3
     )
 
-
 with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
     gr.Markdown("""
     # 📊 Sistema Avanzado de Calibración con Análisis Estadístico
     Configure los parámetros, edite los valores en la tabla y luego presione "Calcular" para obtener el análisis.
+
+    **Nota:** La unidad en la pestaña uno "Unidad de Medida (Predicha)" será la unidad de la concentración predicha.
+    Debajo se encuentra otra "Unidad de Medida (Absorbancias)" para las réplicas (valores reales).
     """)
 
     with gr.Tab("📝 Datos de Calibración"):
@@ -684,10 +686,15 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 label="Concentraci��n Inicial",
                 precision=0
             )
-            unidad_input = gr.Textbox(
+            unidad_predicha_input = gr.Textbox(
+                value="mg/L",
+                label="Unidad de Medida (Predicha)",
+                placeholder="mg/L, etc."
+            )
+            unidad_replicas_input = gr.Textbox(
                 value="UFC",
-                label="Unidad de Medida",
-                placeholder="UFC, OD, etc..."
+                label="Unidad de Medida (Absorbancias)",
+                placeholder="Abs, OD, UFC, etc."
             )
             filas_slider = gr.Slider(
                 minimum=1,
@@ -753,16 +760,10 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
                 label="Estilo Línea de Ajuste"
             )
 
-        with gr.Row():
-            color_linea_ideal_picker = gr.ColorPicker(label="Color Línea Ideal", value="#FF0000")
-            estilo_linea_ideal_dropdown = gr.Dropdown(
-                choices=["--", "-", "-.", ":"],
-                value="--",
-                label="Estilo Línea Ideal"
-            )
             color_barras_error_picker = gr.ColorPicker(label="Color Barras de Error", value="#FFA500")
+
+        with gr.Row():
             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")
             mostrar_puntos = gr.Checkbox(value=True, label="Mostrar Puntos")
             graficar_btn = gr.Button("📊 Graficar", variant="primary")
 
@@ -818,7 +819,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         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)"
+                placeholder="Regresión Lineal: Absorbancia Real vs Concentración Predicha (Original)"
             )
             titulo_grafico_personalizado = gr.Textbox(
                 label="Título del Gráfico Personalizado",
@@ -828,21 +829,21 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         with gr.Row():
             eje_x_original = gr.Textbox(
                 label="Etiqueta del Eje X (Gráfico Original)",
-                placeholder="Concentración Predicha Numérica"
+                placeholder="Concentración Predicha (mg/L)"
             )
             eje_y_original = gr.Textbox(
                 label="Etiqueta del Eje Y (Gráfico Original)",
-                placeholder="Concentración Real Promedio (UFC)"
+                placeholder="Absorbancia Real Promedio (UFC)"
             )
 
         with gr.Row():
             eje_x_personalizado = gr.Textbox(
                 label="Etiqueta del Eje X (Gráfico Personalizado)",
-                placeholder="Concentración Predicha Numérica"
+                placeholder="Concentración Predicha (mg/L)"
             )
             eje_y_personalizado = gr.Textbox(
                 label="Etiqueta del Eje Y (Gráfico Personalizado)",
-                placeholder="Concentración Real Promedio (UFC)"
+                placeholder="Absorbancia Real Promedio (UFC)"
             )
 
         calcular_regresion_btn = gr.Button("Calcular Regresión")
@@ -860,29 +861,28 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
     calcular_btn.click(
         fn=actualizar_analisis,
-        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
+        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_medida,
+    def actualizar_graficos_custom(df, n_replicas, unidad_predicha, unidad_replicas,
                                    color_puntos, estilo_puntos,
                                    color_linea_ajuste, estilo_linea_ajuste,
-                                   color_linea_ideal, estilo_linea_ideal,
                                    color_barras_error,
-                                   mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+                                   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_medida, decimales)
+        df = calcular_promedio_desviacion(df, n_replicas, unidad_predicha, unidad_replicas, decimales)
 
-        col_predicha_num = "Concentración Predicha Numérica"
-        col_real_promedio = f"Concentración Real Promedio ({unidad_medida})"
+        col_predicha = f"Concentración Predicha ({unidad_predicha})"
+        col_real_promedio = f"Absorbancia Real Promedio ({unidad_replicas})"
 
-        df[col_predicha_num] = pd.to_numeric(df[col_predicha_num], errors='coerce')
+        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_num, col_real_promedio])
+        df_valid = df.dropna(subset=[col_predicha, col_real_promedio])
         df_valid.reset_index(drop=True, inplace=True)
 
         if not filas_seleccionadas:
@@ -895,24 +895,22 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
             return None
 
         fig = generar_graficos(
-            df_valid, n_replicas, unidad_medida,
+            df_valid, n_replicas, unidad_predicha, unidad_replicas,
             color_puntos, estilo_puntos,
             color_linea_ajuste, estilo_linea_ajuste,
-            color_linea_ideal, estilo_linea_ideal,
             color_barras_error,
-            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos
+            mostrar_linea_ajuste, mostrar_puntos
         )
         return fig
 
     graficar_btn.click(
         fn=actualizar_graficos_custom,
         inputs=[
-            tabla_output, replicas_slider, unidad_input,
+            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_linea_ideal_picker, estilo_linea_ideal_dropdown,
             color_barras_error_picker,
-            mostrar_linea_ajuste, mostrar_linea_ideal, mostrar_puntos,
+            mostrar_linea_ajuste, mostrar_puntos,
             filas_seleccionadas, decimales_slider
         ],
         outputs=graficos_output
@@ -920,70 +918,72 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
     recalcular_btn.click(
         fn=actualizar_analisis,
-        inputs=[tabla_output, replicas_slider, unidad_input, filas_seleccionadas, decimales_slider],
+        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 resetear_linea_ideal():
-        return gr.update(value=False)
+    def resetear_valores():
+        return gr.update(value=True), gr.update(value=True)
 
-    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)
+    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])
 
     limpiar_btn.click(
         fn=limpiar_datos,
         inputs=[replicas_slider],
-        outputs=[concentracion_input, unidad_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
+        outputs=[concentracion_input, unidad_predicha_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
     def cargar_ejemplo_ufc(n_replicas):
+        unidad_predicha = "mg/L"
+        unidad_replicas = "UFC"
         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],
-            "Concentración Predicha Numérica": [150,120,100,90,80,70,60],
-            "Concentración Predicha (mg/L)": [150,120,100,90,80,70,60]
+            f"Concentración Predicha ({unidad_predicha})": [150,120,100,90,80,70,60]
         })
         for i in range(1, n_replicas + 1):
-            df[f"Concentración Real {i} (UFC)"] = np.nan
-        return 2000000, "UFC", 7, df
+            df[f"Absorbancia Real {i} ({unidad_replicas})"] = np.nan
+        return 2000000, unidad_predicha, unidad_replicas, 7, df
 
     def cargar_ejemplo_od(n_replicas):
+        unidad_predicha = "mg/L"
+        unidad_replicas = "OD"
         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],
-            "Concentración Predicha Numérica": [1.0,0.8,0.6,0.4,0.2,0.1,0.05],
-            "Concentración Predicha (mg/L)": [1.0,0.8,0.6,0.4,0.2,0.1,0.05]
+            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"Concentración Real {i} (OD)"] = np.nan
-        return 1.000, "OD", 7, df
+            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_input, filas_slider, tabla_output]
+        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_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]
+        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output]
     )
 
     sinteticos_btn.click(
         fn=generar_datos_sinteticos_evento,
-        inputs=[tabla_output, replicas_slider, unidad_input],
+        inputs=[tabla_output, replicas_slider, unidad_predicha_input, unidad_replicas_input],
         outputs=tabla_output
     )
 
     cargar_excel_btn.upload(
         fn=cargar_excel,
         inputs=[cargar_excel_btn],
-        outputs=[concentracion_input, unidad_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
+        outputs=[concentracion_input, unidad_predicha_input, filas_slider, replicas_slider, tabla_output, estado_output, graficos_output, informe_output]
     )
 
     ajustar_decimales_btn.click(
@@ -992,30 +992,36 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
         outputs=tabla_output
     )
 
-    def actualizar_tabla_wrapper(df, filas, conc, unidad, replicas, decimales):
-        return actualizar_tabla_evento(df, filas, conc, unidad, replicas, decimales)
+    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_input, replicas_slider, decimales_slider],
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
+        outputs=tabla_output
+    )
+
+    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_input.change(
+    unidad_replicas_input.change(
         fn=actualizar_tabla_wrapper,
-        inputs=[tabla_output, filas_slider, concentracion_input, unidad_input, replicas_slider, decimales_slider],
+        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_input, replicas_slider, decimales_slider],
+        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_input, replicas_slider, decimales_slider],
+        inputs=[tabla_output, filas_slider, concentracion_input, unidad_predicha_input, unidad_replicas_input, replicas_slider, decimales_slider],
         outputs=tabla_output
     )
 
@@ -1045,7 +1051,7 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
     exportar_word_btn.click(
         fn=exportar_word,
-        inputs=[tabla_output, informe_output, unidad_input, filas_seleccionadas],
+        inputs=[tabla_output, informe_output, unidad_predicha_input, unidad_replicas_input, filas_seleccionadas],
         outputs=exportar_word_file
     )
 
@@ -1057,13 +1063,13 @@ with gr.Blocks(theme=gr.themes.Soft()) as interfaz:
 
     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]
+        outputs=[concentracion_input, unidad_predicha_input, unidad_replicas_input, filas_slider, tabla_output, estado_output, graficos_output, informe_output, filas_seleccionadas, decimales_slider]
     )
 
     calcular_regresion_btn.click(
         fn=calcular_regresion_tabla_principal,
         inputs=[
-            tabla_output, unidad_input, filas_seleccionadas_regresion,
+            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,