Update app.py

app.py

@@ -1,4 +1,4 @@
-import numpy as np
+import numpy as np 
 import pandas as pd
 import statsmodels.formula.api as smf
 import statsmodels.api as sm
@@ -10,16 +10,29 @@ from scipy.stats import t, f
 import gradio as gr
 import io
 import zipfile
-from base64 import b64encode
+from datetime import datetime
 
 class RSM_BoxBehnken:
     def __init__(self, data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels):
+        """
+        Inicializa la clase con los datos del diseño Box-Behnken.
+
+        Args:
+            data (pd.DataFrame): DataFrame con los datos del experimento.
+            x1_name (str): Nombre de la primera variable independiente.
+            x2_name (str): Nombre de la segunda variable independiente.
+            x3_name (str): Nombre de la tercera variable independiente.
+            y_name (str): Nombre de la variable dependiente.
+            x1_levels (list): Niveles de la primera variable independiente.
+            x2_levels (list): Niveles de la segunda variable independiente.
+            x3_levels (list): Niveles de la tercera variable independiente.
+        """
         self.data = data.copy()
         self.model = None
         self.model_simplified = None
         self.optimized_results = None
         self.optimal_levels = None
-
+        self.all_figures = []  # Lista para almacenar las 9 figuras
         self.x1_name = x1_name
         self.x2_name = x2_name
         self.x3_name = x3_name
@@ -29,14 +42,6 @@ class RSM_BoxBehnken:
         self.x1_levels = x1_levels
         self.x2_levels = x2_levels
         self.x3_levels = x3_levels
-        
-        # Formatear datos numéricos a 3 decimales
-        self.format_data()
-
-    def format_data(self):
-        """Formatea los datos numéricos a 3 decimales."""
-        numeric_cols = self.data.select_dtypes(include=np.number).columns
-        self.data[numeric_cols] = self.data[numeric_cols].round(3)
 
     def get_levels(self, variable_name):
         """
@@ -99,21 +104,21 @@ class RSM_BoxBehnken:
 
         self.optimized_results = minimize(objective_function, x0, method=method, bounds=bounds)
         self.optimal_levels = self.optimized_results.x
-        
+
         # Convertir niveles óptimos de codificados a naturales
         optimal_levels_natural = [
-            round(self.coded_to_natural(self.optimal_levels[0], self.x1_name),3),
-            round(self.coded_to_natural(self.optimal_levels[1], self.x2_name),3),
-            round(self.coded_to_natural(self.optimal_levels[2], self.x3_name),3)
+            self.coded_to_natural(self.optimal_levels[0], self.x1_name),
+            self.coded_to_natural(self.optimal_levels[1], self.x2_name),
+            self.coded_to_natural(self.optimal_levels[2], self.x3_name)
         ]
         # Crear la tabla de optimización
         optimization_table = pd.DataFrame({
             'Variable': [self.x1_name, self.x2_name, self.x3_name],
             'Nivel Óptimo (Natural)': optimal_levels_natural,
-            'Nivel Óptimo (Codificado)': [round(x, 3) for x in self.optimal_levels]
+            'Nivel Óptimo (Codificado)': self.optimal_levels.round(3)  # Redondear a 3 decimales
         })
 
-        return optimization_table
+        return optimization_table.round(3)  # Redondear a 3 decimales
 
     def plot_rsm_individual(self, fixed_variable, fixed_level):
         """
@@ -205,15 +210,15 @@ class RSM_BoxBehnken:
 
         # Añadir los puntos de los experimentos en la superficie de respuesta con diferentes colores y etiquetas
         # Crear una lista de colores y etiquetas para los puntos
-        colors = ['red', 'blue', 'green', 'purple', 'orange', 'yellow', 'cyan', 'magenta']
+        colors = px.colors.qualitative.Safe
         point_labels = []
         for i, row in experiments_data.iterrows():
-            point_labels.append(f"{row[self.y_name]:.3f}")
+            point_labels.append(f"{row[self.y_name]:.3f}")  # Redondear a 3 decimales
 
         fig.add_trace(go.Scatter3d(
             x=experiments_x_natural,
             y=experiments_y_natural,
-            z=experiments_data[self.y_name],
+            z=experiments_data[self.y_name].round(3),
             mode='markers+text',
             marker=dict(size=4, color=colors[:len(experiments_x_natural)]),  # Usar colores de la lista
             text=point_labels,  # Usar las etiquetas creadas
@@ -224,13 +229,9 @@ class RSM_BoxBehnken:
         # Añadir etiquetas y título con variables naturales
         fig.update_layout(
             scene=dict(
-                xaxis_title=varying_variables[0] + " (g/L)",
-                yaxis_title=varying_variables[1] + " (g/L)",
+                xaxis_title=f"{varying_variables[0]} (g/L)",
+                yaxis_title=f"{varying_variables[1]} (g/L)",
                 zaxis_title=self.y_name,
-                # Puedes mantener la configuración de grid en los planos si lo deseas
-                # xaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray'),
-                # yaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray'),
-                # zaxis=dict(showgrid=True, gridwidth=1, gridcolor='lightgray')
             ),
             title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} (g/L) (Modelo Simplificado)</sup>",
             height=800,
@@ -242,10 +243,13 @@ class RSM_BoxBehnken:
     def generate_all_plots(self):
         """
         Genera todas las gráficas de RSM, variando la variable fija y sus niveles usando el modelo simplificado.
+        Almacena las figuras en self.all_figures.
         """
         if self.model_simplified is None:
             print("Error: Ajusta el modelo simplificado primero.")
-            return []
+            return
+
+        self.all_figures = []  # Resetear la lista de figuras
 
         # Niveles naturales para graficar
         levels_to_plot_natural = {
@@ -254,14 +258,12 @@ class RSM_BoxBehnken:
             self.x3_name: self.x3_levels
         }
 
-        # Generar gráficos individuales
-        figures = []
+        # Generar y almacenar gráficos individuales
         for fixed_variable in [self.x1_name, self.x2_name, self.x3_name]:
             for level in levels_to_plot_natural[fixed_variable]:
                 fig = self.plot_rsm_individual(fixed_variable, level)
                 if fig is not None:
-                    figures.append(fig)
-        return figures
+                    self.all_figures.append(fig)
 
     def coded_to_natural(self, coded_value, variable_name):
         """Convierte un valor codificado a su valor natural."""
@@ -296,7 +298,7 @@ class RSM_BoxBehnken:
 
         # Crear el diagrama de Pareto
         fig = px.bar(
-            x=sorted_tvalues,
+            x=sorted_tvalues.round(3),
             y=sorted_names,
             orientation='h',
             labels={'x': 'Efecto Estandarizado', 'y': 'Término'},
@@ -324,76 +326,76 @@ class RSM_BoxBehnken:
 
         for term, coef in coefficients.items():
             if term != 'Intercept':
-              if term == f'{self.x1_name}':
-                equation += f" + {coef:.3f}*{self.x1_name}"
-              elif term == f'{self.x2_name}':
-                equation += f" + {coef:.3f}*{self.x2_name}"
-              elif term == f'{self.x3_name}':
-                equation += f" + {coef:.3f}*{self.x3_name}"
-              elif term == f'I({self.x1_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x1_name}^2"
-              elif term == f'I({self.x2_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x2_name}^2"
-              elif term == f'I({self.x3_name} ** 2)':
-                equation += f" + {coef:.3f}*{self.x3_name}^2"
+                if term == f'{self.x1_name}':
+                    equation += f" + {coef:.3f}*{self.x1_name}"
+                elif term == f'{self.x2_name}':
+                    equation += f" + {coef:.3f}*{self.x2_name}"
+                elif term == f'{self.x3_name}':
+                    equation += f" + {coef:.3f}*{self.x3_name}"
+                elif term == f'I({self.x1_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x1_name}^2"
+                elif term == f'I({self.x2_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x2_name}^2"
+                elif term == f'I({self.x3_name} ** 2)':
+                    equation += f" + {coef:.3f}*{self.x3_name}^2"
 
         return equation
 
     def generate_prediction_table(self):
-      """
-      Genera una tabla con los valores actuales, predichos y residuales.
-      """
-      if self.model_simplified is None:
-          print("Error: Ajusta el modelo simplificado primero.")
-          return None
+        """
+        Genera una tabla con los valores actuales, predichos y residuales.
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
 
-      self.data['Predicho'] = self.model_simplified.predict(self.data).round(3)
-      self.data['Residual'] = (self.data[self.y_name] - self.data['Predicho']).round(3)
+        self.data['Predicho'] = self.model_simplified.predict(self.data)
+        self.data['Residual'] = self.data[self.y_name] - self.data['Predicho']
 
-      return self.data[[self.y_name, 'Predicho', 'Residual']]
+        return self.data[[self.y_name, 'Predicho', 'Residual']].round(3)
 
     def calculate_contribution_percentage(self):
-      """
-      Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
-      """
-      if self.model_simplified is None:
-          print("Error: Ajusta el modelo simplificado primero.")
-          return None
-
-      # ANOVA del modelo simplificado
-      anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
-
-      # Suma de cuadrados total
-      ss_total = anova_table['sum_sq'].sum()
-
-      # Crear tabla de contribución
-      contribution_table = pd.DataFrame({
-          'Factor': [],
-          'Suma de Cuadrados': [],
-          '% Contribución': []
-      })
-      
-      # Calcular porcentaje de contribución para cada factor
-      for index, row in anova_table.iterrows():
-          if index != 'Residual':
-            factor_name = index
-            if factor_name == f'I({self.x1_name} ** 2)':
-              factor_name = f'{self.x1_name}^2'
-            elif factor_name == f'I({self.x2_name} ** 2)':
-              factor_name = f'{self.x2_name}^2'
-            elif factor_name == f'I({self.x3_name} ** 2)':
-              factor_name = f'{self.x3_name}^2'
-            
-            ss_factor = row['sum_sq']
-            contribution_percentage = round((ss_factor / ss_total) * 100, 3)
-
-            contribution_table = pd.concat([contribution_table, pd.DataFrame({
-                'Factor': [factor_name],
-                'Suma de Cuadrados': [round(ss_factor,3)],
-                '% Contribución': [contribution_percentage]
-            })], ignore_index=True)
-
-      return contribution_table
+        """
+        Calcula el porcentaje de contribución de cada factor a la variabilidad de la respuesta (AIA).
+        """
+        if self.model_simplified is None:
+            print("Error: Ajusta el modelo simplificado primero.")
+            return None
+
+        # ANOVA del modelo simplificado
+        anova_table = sm.stats.anova_lm(self.model_simplified, typ=2)
+
+        # Suma de cuadrados total
+        ss_total = anova_table['sum_sq'].sum()
+
+        # Crear tabla de contribución
+        contribution_table = pd.DataFrame({
+            'Factor': [],
+            'Suma de Cuadrados': [],
+            '% Contribución': []
+        })
+        
+        # Calcular porcentaje de contribución para cada factor
+        for index, row in anova_table.iterrows():
+            if index != 'Residual':
+                factor_name = index
+                if factor_name == f'I({self.x1_name} ** 2)':
+                    factor_name = f'{self.x1_name}^2'
+                elif factor_name == f'I({self.x2_name} ** 2)':
+                    factor_name = f'{self.x2_name}^2'
+                elif factor_name == f'I({self.x3_name} ** 2)':
+                    factor_name = f'{self.x3_name}^2'
+                
+                ss_factor = row['sum_sq']
+                contribution_percentage = (ss_factor / ss_total) * 100
+
+                contribution_table = pd.concat([contribution_table, pd.DataFrame({
+                    'Factor': [factor_name],
+                    'Suma de Cuadrados': [ss_factor],
+                    '% Contribución': [contribution_percentage]
+                })], ignore_index=True)
+
+        return contribution_table.round(3)
 
     def calculate_detailed_anova(self):
         """
@@ -419,7 +421,7 @@ class RSM_BoxBehnken:
         df_total = len(self.data) - 1
 
         # 5. Suma de cuadrados de la regresión
-        ss_regression = anova_reduced['sum_sq'][:-1].sum() # Sumar todo excepto 'Residual'
+        ss_regression = anova_reduced['sum_sq'][:-1].sum()  # Sumar todo excepto 'Residual'
 
         # 6. Grados de libertad de la regresión
         df_regression = len(anova_reduced) - 1
@@ -430,31 +432,35 @@ class RSM_BoxBehnken:
 
         # 8. Suma de cuadrados del error puro (se calcula a partir de las réplicas)
         replicas = self.data[self.data.duplicated(subset=[self.x1_name, self.x2_name, self.x3_name], keep=False)]
-        ss_pure_error = replicas.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].var().sum()
-        df_pure_error = len(replicas) - len(replicas.groupby([self.x1_name, self.x2_name, self.x3_name]))
+        if not replicas.empty:
+            ss_pure_error = replicas.groupby([self.x1_name, self.x2_name, self.x3_name])[self.y_name].var().sum() * replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
+            df_pure_error = len(replicas) - replicas.groupby([self.x1_name, self.x2_name, self.x3_name]).ngroups
+        else:
+            ss_pure_error = np.nan
+            df_pure_error = np.nan
 
         # 9. Suma de cuadrados de la falta de ajuste
-        ss_lack_of_fit = ss_residual - ss_pure_error
-        df_lack_of_fit = df_residual - df_pure_error
+        ss_lack_of_fit = ss_residual - ss_pure_error if not np.isnan(ss_pure_error) else np.nan
+        df_lack_of_fit = df_residual - df_pure_error if not np.isnan(df_pure_error) else np.nan
 
         # 10. Cuadrados medios
         ms_regression = ss_regression / df_regression
         ms_residual = ss_residual / df_residual
-        ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit
-        ms_pure_error = ss_pure_error / df_pure_error
+        ms_lack_of_fit = ss_lack_of_fit / df_lack_of_fit if not np.isnan(ss_lack_of_fit) else np.nan
+        ms_pure_error = ss_pure_error / df_pure_error if not np.isnan(ss_pure_error) else np.nan
 
         # 11. Estadístico F y valor p para la falta de ajuste
-        f_lack_of_fit = ms_lack_of_fit / ms_pure_error
-        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) # Usar f.cdf de scipy.stats
+        f_lack_of_fit = ms_lack_of_fit / ms_pure_error if not np.isnan(ms_lack_of_fit) else np.nan
+        p_lack_of_fit = 1 - f.cdf(f_lack_of_fit, df_lack_of_fit, df_pure_error) if not np.isnan(f_lack_of_fit) else np.nan
 
         # 12. Crear la tabla ANOVA detallada
         detailed_anova_table = pd.DataFrame({
             'Fuente de Variación': ['Regresión', 'Residual', 'Falta de Ajuste', 'Error Puro', 'Total'],
-            'Suma de Cuadrados': [round(ss_regression,3), round(ss_residual,3), round(ss_lack_of_fit,3), round(ss_pure_error,3), round(ss_total,3)],
+            'Suma de Cuadrados': [ss_regression, ss_residual, ss_lack_of_fit, ss_pure_error, ss_total],
             'Grados de Libertad': [df_regression, df_residual, df_lack_of_fit, df_pure_error, df_total],
-            'Cuadrado Medio': [round(ms_regression,3), round(ms_residual,3), round(ms_lack_of_fit,3), round(ms_pure_error,3), np.nan],
-            'F': [np.nan, np.nan, round(f_lack_of_fit,3), np.nan, np.nan],
-            'Valor p': [np.nan, np.nan, round(p_lack_of_fit,3), np.nan, np.nan]
+            'Cuadrado Medio': [ms_regression, ms_residual, ms_lack_of_fit, ms_pure_error, np.nan],
+            'F': [np.nan, np.nan, f_lack_of_fit, np.nan, np.nan],
+            'Valor p': [np.nan, np.nan, p_lack_of_fit, np.nan, np.nan]
         })
         
         # Calcular la suma de cuadrados y grados de libertad para la curvatura
@@ -462,7 +468,7 @@ class RSM_BoxBehnken:
         df_curvature = 3
 
         # Añadir la fila de curvatura a la tabla ANOVA
-        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', round(ss_curvature,3), df_curvature, round(ss_curvature / df_curvature,3), np.nan, np.nan]
+        detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
 
         # Reorganizar las filas para que la curvatura aparezca después de la regresión
         detailed_anova_table = detailed_anova_table.reindex([0, 5, 1, 2, 3, 4])
@@ -470,7 +476,51 @@ class RSM_BoxBehnken:
         # Resetear el índice para que sea consecutivo
         detailed_anova_table = detailed_anova_table.reset_index(drop=True)
 
-        return detailed_anova_table
+        return detailed_anova_table.round(3)
+
+    def get_all_tables(self):
+        """
+        Obtiene todas las tablas generadas para ser exportadas a Excel.
+        """
+        prediction_table = self.generate_prediction_table()
+        contribution_table = self.calculate_contribution_percentage()
+        detailed_anova_table = self.calculate_detailed_anova()
+
+        return {
+            'Predicciones': prediction_table,
+            '% Contribución': contribution_table,
+            'ANOVA Detallada': detailed_anova_table
+        }
+
+    def save_figures_to_zip(self):
+        """
+        Guarda todas las figuras almacenadas en self.all_figures a un archivo ZIP en memoria.
+
+        Returns:
+            bytes: Bytes del archivo ZIP.
+        """
+        if not self.all_figures:
+            return None
+
+        zip_buffer = io.BytesIO()
+        with zipfile.ZipFile(zip_buffer, 'w') as zip_file:
+            for idx, fig in enumerate(self.all_figures, start=1):
+                img_bytes = fig.to_image(format="png")
+                zip_file.writestr(f'Grafico_{idx}.png', img_bytes)
+        zip_buffer.seek(0)
+        return zip_buffer
+
+    def save_fig_to_bytes(self, fig):
+        """
+        Convierte una figura Plotly a bytes en formato PNG.
+
+        Args:
+            fig (go.Figure): Figura de Plotly.
+
+        Returns:
+            bytes: Bytes de la imagen PNG.
+        """
+        return fig.to_image(format="png")
 
 # --- Funciones para la interfaz de Gradio ---
 
@@ -489,7 +539,7 @@ def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x
         data_str (str): Datos del experimento en formato CSV, separados por comas.
 
     Returns:
-        tuple: (pd.DataFrame, str, str, str, str, list, list, list, gr.update, list)
+        tuple: (pd.DataFrame, str, str, str, str, list, list, list, gr.update)
     """
     try:
         # Convertir los niveles a listas de números
@@ -511,15 +561,16 @@ def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x
         global rsm
         rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
 
-        return data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, gr.update(visible=True)
-
+        return data.round(3), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, gr.update(visible=True)
+    
     except Exception as e:
         return None, "", "", "", "", [], [], [], gr.update(visible=False), f"Error: {e}"
 
-def fit_and_optimize_model(rsm_plots_state=None):
+def fit_and_optimize_model():
     if 'rsm' not in globals():
-        return (None, None, None, None, None, None, None, None, None, None, [], "Error: Carga los datos primero.")
+        return None, None, None, None, None, None, "Error: Carga los datos primero.", None, None
     
+    # Ajustar modelos y optimizar
     model_completo, pareto_completo = rsm.fit_model()
     model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
     optimization_table = rsm.optimize()
@@ -527,18 +578,17 @@ def fit_and_optimize_model(rsm_plots_state=None):
     prediction_table = rsm.generate_prediction_table()
     contribution_table = rsm.calculate_contribution_percentage()
     anova_table = rsm.calculate_detailed_anova()
-
-    # Generar todos los gráficos de superficie de respuesta
-    rsm_plots = rsm.generate_all_plots()
-
+    
+    # Generar todas las figuras y almacenarlas
+    rsm.generate_all_plots()
+    
     # Formatear la ecuación para que se vea mejor en Markdown
     equation_formatted = equation.replace(" + ", "<br>+ ").replace(" ** ", "^").replace("*", " × ")
     equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
     
     return (
-        model_completo.summary().tables[0].as_html(),
+        model_completo.summary().as_html(),
         pareto_completo,
-        model_completo.summary().tables[1].as_html(),
         model_simplificado.summary().as_html(),
         pareto_simplificado,
         equation_formatted,
@@ -546,73 +596,106 @@ def fit_and_optimize_model(rsm_plots_state=None):
         prediction_table,
         contribution_table,
         anova_table,
-        rsm_plots,  # Esto se asignará al estado
-        gr.update(visible=True, maximum=len(rsm_plots) -1) if rsm_plots else gr.update()
+        rsm.all_figures,  # Devuelve todas las figuras generadas
+        gr.update()  # Placeholder para actualizar otros componentes si es necesario
     )
 
-def generate_rsm_plot(plot_index, rsm_plots_state):
-    if not rsm_plots_state:
-        return None, gr.update(visible=False), "Error: Genera los gráficos primero."
+def generate_rsm_plot(fixed_variable, fixed_level, all_figures, current_index):
+    if 'rsm' not in globals():
+        return None, "Error: Carga los datos primero.", current_index
     
-    plot_index = int(plot_index)
-    if 0 <= plot_index < len(rsm_plots_state):
-        selected_plot = rsm_plots_state[plot_index]
-        return selected_plot, gr.update(visible=True, value=plot_index), ""
-    else:
-        return None, gr.update(visible=False), "Error: Índice de gráfico fuera de rango."
+    # Encontrar el índice correspondiente al gráfico seleccionado
+    # Asumimos que los gráficos están ordenados por variable fija y nivel
+    # Se puede mejorar la lógica si es necesario
+    selected_fig = None
+    for idx, fig in enumerate(all_figures):
+        title = fig.layout.title.text
+        if fixed_variable in title and f"fijo en {fixed_level:.3f}" in title:
+            selected_fig = fig
+            current_index = idx
+            break
+    
+    if selected_fig is None and all_figures:
+        selected_fig = all_figures[0]
+        current_index = 0
 
-def download_excel():
-    if 'rsm' not in globals():
-        return "Error: Carga los datos y ajusta el modelo primero."
-
-    output = io.BytesIO()
-    with pd.ExcelWriter(output, engine='xlsxwriter') as writer:
-        rsm.data.to_excel(writer, sheet_name='Datos', index=False)
-        rsm.generate_prediction_table().to_excel(writer, sheet_name='Predicciones', index=False)
-        rsm.calculate_contribution_percentage().to_excel(writer, sheet_name='Contribucion', index=False)
-        rsm.calculate_detailed_anova().to_excel(writer, sheet_name='ANOVA', index=False)
-        rsm.optimize().to_excel(writer, sheet_name='Optimizacion', index=False)
-        # Aquí puedes agregar más tablas a diferentes hojas si es necesario
-
-    excel_data = output.getvalue()
-    b64 = b64encode(excel_data).decode('utf-8')
-    href = f'<a download="resultados_rsm.xlsx" href="data:application/vnd.openxmlformats-officedocument.spreadsheetml.sheet;base64,{b64}">Descargar Excel</a>'
-    return href
-
-def download_selected_image(plot_index, rsm_plots_state):
-    if not rsm_plots_state:
-        return "Error: Genera los gráficos primero."
-
-    plot_index = int(plot_index)
-    if 0 <= plot_index < len(rsm_plots_state):
-        selected_plot = rsm_plots_state[plot_index]
-        img_bytes = selected_plot.to_image(format="png")
-        b64 = b64encode(img_bytes).decode('utf-8')
-        href = f'<a download="grafico_rsm_{plot_index}.png" href="data:image/png;base64,{b64}">Descargar Gráfico {plot_index}</a>'
-        return href
+    return selected_fig, None, current_index
+
+def navigate_plot(direction, current_index, total_plots):
+    """
+    Navega entre los gráficos.
+
+    Args:
+        direction (str): 'left' o 'right'.
+        current_index (int): Índice actual.
+        total_plots (int): Total de gráficos.
+
+    Returns:
+        int: Nuevo índice.
+    """
+    if direction == 'left':
+        new_index = (current_index - 1) % total_plots
+    elif direction == 'right':
+        new_index = (current_index + 1) % total_plots
     else:
-        return "Error: Índice de gráfico fuera de rango."
+        new_index = current_index
+    return new_index
+
+def download_current_plot(all_figures, current_index):
+    """
+    Descarga la figura actual como PNG.
+
+    Args:
+        all_figures (list): Lista de figuras.
+        current_index (int): Índice de la figura actual.
+
+    Returns:
+        bytes: Bytes de la imagen PNG.
+    """
+    if not all_figures:
+        return None
+    fig = all_figures[current_index]
+    img_bytes = rsm.save_fig_to_bytes(fig)
+    return img_bytes
+
+def download_all_plots_zip(all_figures):
+    """
+    Descarga todas las figuras en un archivo ZIP.
+
+    Args:
+        all_figures (list): Lista de figuras.
+
+    Returns:
+        bytes: Bytes del archivo ZIP.
+    """
+    zip_bytes = rsm.save_figures_to_zip()
+    if zip_bytes:
+        return zip_bytes
+    return None
 
-def download_all_images(rsm_plots_state):
-    if not rsm_plots_state:
-        return "Error: Genera los gráficos primero."
+def download_all_tables_excel():
+    """
+    Descarga todas las tablas en un archivo Excel con múltiples hojas.
 
-    zip_output = io.BytesIO()
-    with zipfile.ZipFile(zip_output, 'w') as zipf:
-        for i, fig in enumerate(rsm_plots_state):
-            img_bytes = fig.to_image(format="png")
-            zipf.writestr(f"grafico_rsm_{i}.png", img_bytes)
+    Returns:
+        bytes: Bytes del archivo Excel.
+    """
+    if 'rsm' not in globals():
+        return None
 
-    zip_data = zip_output.getvalue()
-    b64 = b64encode(zip_data).decode('utf-8')
-    href = f'<a download="graficos_rsm.zip" href="data:application/zip;base64,{b64}">Descargar Todos los Gráficos</a>'
-    return href
+    tables = rsm.get_all_tables()
+    excel_buffer = io.BytesIO()
+    with pd.ExcelWriter(excel_buffer, engine='xlsxwriter') as writer:
+        for sheet_name, table in tables.items():
+            table.to_excel(writer, sheet_name=sheet_name, index=False)
+    excel_buffer.seek(0)
+    return excel_buffer
 
 # --- Crear la interfaz de Gradio ---
 
 with gr.Blocks() as demo:
     gr.Markdown("# Optimización de la producción de AIA usando RSM Box-Behnken")
-
+    
     with gr.Row():
         with gr.Column():
             gr.Markdown("## Configuración del Diseño")
@@ -623,7 +706,7 @@ with gr.Blocks() as demo:
             x1_levels_input = gr.Textbox(label="Niveles de X1 (separados por comas)", value="1, 3.5, 5.5")
             x2_levels_input = gr.Textbox(label="Niveles de X2 (separados por comas)", value="0.03, 0.2, 0.3")
             x3_levels_input = gr.Textbox(label="Niveles de X3 (separados por comas)", value="0.4, 0.65, 0.9")
-            data_input = gr.Textbox(label="Datos del Experimento (formato CSV)", lines=5, value="""1,-1,-1,0,166.594
+            data_input = gr.Textbox(label="Datos del Experimento (formato CSV)", lines=10, value="""1,-1,-1,0,166.594
 2,1,-1,0,177.557
 3,-1,1,0,127.261
 4,1,1,0,147.573
@@ -639,112 +722,150 @@ with gr.Blocks() as demo:
 14,0,0,0,297.238
 15,0,0,0,280.896""")
             load_button = gr.Button("Cargar Datos")
-            
-
+        
         with gr.Column():
             gr.Markdown("## Datos Cargados")
-            data_output = gr.Dataframe(label="Tabla de Datos")
-
-    # Definir el estado para rsm_plots
-    rsm_plots_state = gr.State([])
-
-    # Hacer que la sección de análisis y gráficos sea visible solo después de cargar los datos
+            data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
+    
+    # Hacer que la sección de análisis sea visible solo después de cargar los datos
     with gr.Row(visible=False) as analysis_row:
         with gr.Column():
             fit_button = gr.Button("Ajustar Modelo y Optimizar")
             gr.Markdown("**Modelo Completo**")
-            with gr.Row():
-              model_completo_output1 = gr.HTML(label="Tabla de Coeficientes")
-              pareto_completo_output = gr.Plot(label="Pareto Modelo Completo")
-            model_completo_output2 = gr.HTML(label="Tabla de ANOVA")
+            model_completo_output = gr.HTML()
+            pareto_completo_output = gr.Plot()
             gr.Markdown("**Modelo Simplificado**")
-            with gr.Row():
-              model_simplificado_output = gr.HTML(label="Tabla de Coeficientes")
-              pareto_simplificado_output = gr.Plot(label="Pareto Modelo Simplificado")
-            equation_output = gr.HTML(label="Ecuación del Modelo Simplificado")
-            optimization_table_output = gr.Dataframe(label="Tabla de Optimización")
-            prediction_table_output = gr.Dataframe(label="Tabla de Predicciones")
-            contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución")
-            anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada")
-
-            # Botones de descarga
-            download_excel_button = gr.HTML("Descargar Excel")
-            download_all_images_button = gr.HTML("Descargar Todos los Gráficos")
-
+            model_simplificado_output = gr.HTML()
+            pareto_simplificado_output = gr.Plot()
+            gr.Markdown("**Ecuación del Modelo Simplificado**")
+            equation_output = gr.HTML()
+            optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
+            prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
+            contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
+            anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
+            gr.Markdown("## Descargar Todas las Tablas")
+            download_excel_button = gr.DownloadButton("Descargar Tablas en Excel", file_name=f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx")
+        
         with gr.Column():
-            gr.Markdown("## Gráficos de Superficie de Respuesta")
+            gr.Markdown("## Generar Gráficos de Superficie de Respuesta")
+            fixed_variable_input = gr.Dropdown(label="Variable Fija", choices=["Glucosa", "Extracto_de_Levadura", "Triptofano"], value="Glucosa")
+            fixed_level_input = gr.Slider(label="Nivel de Variable Fija", minimum=0, maximum=1, step=0.01, value=0.5)
+            plot_button = gr.Button("Generar Gráficos")
             with gr.Row():
-                plot_index_slider = gr.Number(label="Índice del Gráfico", value=0, step=1, minimum=0, maximum=8)
-                previous_plot_button = gr.Button("Anterior")
-                next_plot_button = gr.Button("Siguiente")
-            rsm_plot_output = gr.Plot(label="Superficie de Respuesta")
-            download_image_button = gr.HTML("Descargar Gráfico")
-
-    # Funcionalidad de los botones
+                left_button = gr.Button("<")
+                right_button = gr.Button(">")
+            rsm_plot_output = gr.Plot()
+            plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de 9", interactive=False)
+            with gr.Row():
+                download_plot_button = gr.DownloadButton("Descargar Gráfico Actual (PNG)", file_name="Grafico_RSM.png")
+                download_all_plots_button = gr.DownloadButton("Descargar Todos los Gráficos (ZIP)", file_name="Graficos_RSM.zip")
+    
     load_button.click(
         load_data,
         inputs=[x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, data_input],
         outputs=[data_output, x1_name_input, x2_name_input, x3_name_input, y_name_input, x1_levels_input, x2_levels_input, x3_levels_input, analysis_row]
     )
-
+    
     fit_button.click(
-        fit_and_optimize_model, 
-        inputs=None,
+        fit_and_optimize_model,
+        inputs=[],
         outputs=[
-            model_completo_output1, 
-            pareto_completo, 
-            model_completo_output2, 
-            model_simplificado_output, 
-            pareto_simplificado_output, 
-            equation_output, 
-            optimization_table_output, 
-            prediction_table_output, 
-            contribution_table_output, 
-            anova_table_output, 
-            rsm_plots_state, 
-            plot_index_slider
+            model_completo_output,
+            pareto_completo_output,
+            model_simplificado_output,
+            pareto_simplificado_output,
+            equation_output,
+            optimization_table_output,
+            prediction_table_output,
+            contribution_table_output,
+            anova_table_output,
+            gr.State(),  # all_figures
+            gr.update()
         ]
     )
-
-    previous_plot_button.click(
-        lambda x: x - 1 if x > 0 else x,
-        inputs=plot_index_slider,
-        outputs=plot_index_slider
-    ).then(
-        generate_rsm_plot,
-        inputs=[plot_index_slider, rsm_plots_state],
-        outputs=[rsm_plot_output, plot_index_slider, gr.Textbox()]
+    
+    plot_button.click(
+        lambda: (None, 0),  # Reset plot index
+        inputs=[],
+        outputs=[rsm_plot_output, gr.State()]
     )
+    
+    # Navegación de gráficos
+    with gr.Row():
+        left_button.click(
+            navigate_plot,
+            inputs=["left", gr.State(), gr.State()],
+            outputs=gr.State()
+        )
+        right_button.click(
+            navigate_plot,
+            inputs=["right", gr.State(), gr.State()],
+            outputs=gr.State()
+        )
+    
+    # Funciones para manejar la navegación y actualización de gráficos
+    def update_plot(direction, current_index, total_plots, all_figures):
+        if not all_figures:
+            return None, "No hay gráficos disponibles.", current_index
+        
+        if direction == "left":
+            new_index = (current_index - 1) % total_plots
+        elif direction == "right":
+            new_index = (current_index + 1) % total_plots
+        else:
+            new_index = current_index
+        
+        selected_fig = all_figures[new_index]
+        plot_info_text = f"Gráfico {new_index + 1} de {total_plots}"
+        
+        return selected_fig, plot_info_text, new_index
 
-    next_plot_button.click(
-        lambda x: x + 1 if x < 8 else x,
-        inputs=plot_index_slider,
-        outputs=plot_index_slider
-    ).then(
-        generate_rsm_plot,
-        inputs=[plot_index_slider, rsm_plots_state],
-        outputs=[rsm_plot_output, plot_index_slider, gr.Textbox()]
+    # Actualizar gráficos al navegar
+    left_button.click(
+        update_plot,
+        inputs=["left", "current_index", "total_plots", "all_figures"],
+        outputs=[rsm_plot_output, plot_info, gr.State()]
     )
-
-    plot_index_slider.change(
-        generate_rsm_plot,
-        inputs=[plot_index_slider, rsm_plots_state],
-        outputs=[rsm_plot_output, plot_index_slider, gr.Textbox()]
+    
+    right_button.click(
+        update_plot,
+        inputs=["right", "current_index", "total_plots", "all_figures"],
+        outputs=[rsm_plot_output, plot_info, gr.State()]
+    )
+    
+    # Descargar gráfico actual
+    download_plot_button.click(
+        download_current_plot,
+        inputs=["all_figures", "current_index"],
+        outputs=download_plot_button
+    )
+    
+    # Descargar todos los gráficos en ZIP
+    download_all_plots_button.click(
+        download_all_plots_zip,
+        inputs=["all_figures"],
+        outputs=download_all_plots_button
+    )
+    
+    # Descargar todas las tablas en Excel
+    download_excel_button.click(
+        download_all_tables_excel,
+        inputs=[],
+        outputs=download_excel_button
     )
     
-    download_excel_button.click(download_excel, outputs=download_excel_button)
-    download_image_button.click(download_selected_image, inputs=[plot_index_slider, rsm_plots_state], outputs=download_image_button)
-    download_all_images_button.click(download_all_images, inputs=[rsm_plots_state], outputs=download_all_images_button)
-
     # Ejemplo de uso
     gr.Markdown("## Ejemplo de uso")
-    gr.Markdown("1. Introduce los nombres de las variables y sus niveles en las cajas de texto correspondientes.")
-    gr.Markdown("2. Copia y pega los datos del experimento en la caja de texto 'Datos del Experimento'.")
-    gr.Markdown("3. Haz clic en 'Cargar Datos' para cargar los datos en la tabla.")
-    gr.Markdown("4. Haz clic en 'Ajustar Modelo y Optimizar' para ajustar el modelo y encontrar los niveles óptimos de los factores.")
-    gr.Markdown("5. Navega por los gráficos de superficie de respuesta usando los botones 'Anterior' y 'Siguiente' o el control deslizante.")
-    gr.Markdown("6. Haz clic en 'Descargar Excel' para descargar un archivo Excel con todas las tablas.")
-    gr.Markdown("7. Haz clic en 'Descargar Gráfico' para descargar la imagen del gráfico actual.")
-    gr.Markdown("8. Haz clic en 'Descargar Todos los Gráficos' para descargar un archivo zip con todas las imágenes de los gráficos.")
-
+    gr.Markdown("""
+    1. Introduce los nombres de las variables y sus niveles en las cajas de texto correspondientes.
+    2. Copia y pega los datos del experimento en la caja de texto 'Datos del Experimento'.
+    3. Haz clic en 'Cargar Datos' para cargar los datos en la tabla.
+    4. Haz clic en 'Ajustar Modelo y Optimizar' para ajustar el modelo y encontrar los niveles óptimos de los factores.
+    5. Selecciona una variable fija y su nivel en los controles deslizantes.
+    6. Haz clic en 'Generar Gráficos' para generar los gráficos de superficie de respuesta.
+    7. Navega entre los gráficos usando los botones '<' y '>'.
+    8. Descarga el gráfico actual en PNG o descarga todos los gráficos en un ZIP.
+    9. Descarga todas las tablas en un archivo Excel con el botón correspondiente.
+    """)
+    
 demo.launch()