Update app.py

app.py

@@ -14,51 +14,87 @@ from datetime import datetime
 import docx
 from docx.shared import Inches, Pt
 from docx.enum.text import WD_PARAGRAPH_ALIGNMENT
-from matplotlib.colors import to_hex
 import os
+import itertools
 
 # --- Clase RSM_BoxBehnken ---
 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.
-        """
-        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 figuras
-        self.x1_name = x1_name
-        self.x2_name = x2_name
-        self.x3_name = x3_name
-        self.y_name = y_name
-
-        # Niveles originales de las variables
-        self.x1_levels = x1_levels
-        self.x2_levels = x2_levels
-        self.x3_levels = x3_levels
-
-    def get_levels(self, variable_name):
-        """
-        Obtiene los niveles para una variable específica.
-        """
-        if variable_name == self.x1_name:
-            return self.x1_levels
-        elif variable_name == self.x2_name:
-            return self.x2_levels
-        elif variable_name == self.x3_name:
-            return self.x3_levels
-        else:
-            raise ValueError(f"Variable desconocida: {variable_name}")
+    def __init__(self, factor_names, factor_levels, y_name):
+        """
+        Inicializa la clase con los nombres de factores, sus niveles y la variable dependiente.
+        """
+        self.factor_names = factor_names  # Lista de nombres de factores
+        self.factor_levels = factor_levels  # Lista de diccionarios con min y max para cada factor
+        self.y_name = y_name  # Nombre de la variable dependiente
+        self.n_factors = len(factor_names)  # Número de factores
+        self.data = None  # DataFrame con los datos del experimento
+        self.design = None  # DataFrame con el diseño Box-Behnken
+        self.model = None  # Modelo completo
+        self.model_simplified = None  # Modelo simplificado
+        self.optimized_results = None  # Resultados de optimización
+        self.optimal_levels = None  # Niveles óptimos de factores
+        self.all_figures = []  # Lista para almacenar las figuras generadas
+
+    def generate_box_behnken_design(self, center_runs=3):
+        """
+        Genera el diseño Box-Behnken para el número de factores especificado.
+        """
+        design = []
+
+        # Generar todas las combinaciones de dos factores
+        factor_indices = list(range(self.n_factors))
+        for pair in itertools.combinations(factor_indices, 2):
+            for levels in [(-1, -1), (-1, 1), (1, -1), (1, 1)]:
+                run = [0] * self.n_factors
+                run[pair[0]] = levels[0]
+                run[pair[1]] = levels[1]
+                design.append(run)
+
+        # Añadir corridas centrales
+        for _ in range(center_runs):
+            design.append([0] * self.n_factors)
+
+        design_df = pd.DataFrame(design, columns=self.factor_names)
+        self.design = design_df
+
+        # Mapear niveles codificados a naturales
+        for i, factor in enumerate(self.factor_names):
+            design_df[factor] = design_df[factor].apply(lambda x: self.coded_to_natural(x, i))
+        
+        # Asignar al atributo data
+        self.data = design_df.copy()
+
+        return self.design
+
+    def coded_to_natural(self, coded_value, factor_index):
+        """
+        Convierte un valor codificado (-1, 0, 1) a su valor natural basado en los niveles del factor.
+        """
+        min_val = self.factor_levels[factor_index]['min']
+        max_val = self.factor_levels[factor_index]['max']
+        return min_val + (coded_value + 1) * (max_val - min_val) / 2
+
+    def natural_to_coded(self, natural_value, factor_index):
+        """
+        Convierte un valor natural a su valor codificado (-1, 0, 1) basado en los niveles del factor.
+        """
+        min_val = self.factor_levels[factor_index]['min']
+        max_val = self.factor_levels[factor_index]['max']
+        return -1 + 2 * (natural_value - min_val) / (max_val - min_val)
+
+    def set_response(self, response_values):
+        """
+        Establece los valores de respuesta (variable dependiente) en el diseño.
+        """
+        if len(response_values) != len(self.design):
+            raise ValueError("El número de valores de respuesta no coincide con el número de corridas en el diseño.")
+        self.data[self.y_name] = response_values
 
     def fit_model(self):
         """
         Ajusta el modelo de segundo orden completo a los datos.
         """
-        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
-                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2) + ' \
-                  f'{self.x1_name}:{self.x2_name} + {self.x1_name}:{self.x3_name} + {self.x2_name}:{self.x3_name}'
+        formula = self._generate_formula()
         self.model = smf.ols(formula, data=self.data).fit()
         print("Modelo Completo:")
         print(self.model.summary())
@@ -66,15 +102,29 @@ class RSM_BoxBehnken:
 
     def fit_simplified_model(self):
         """
-        Ajusta el modelo de segundo orden a los datos, eliminando términos no significativos.
+        Ajusta el modelo de segundo orden simplificado a los datos, eliminando términos no significativos.
         """
-        formula = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + ' \
-                  f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
+        formula = self._generate_formula(simplified=True)
         self.model_simplified = smf.ols(formula, data=self.data).fit()
         print("\nModelo Simplificado:")
         print(self.model_simplified.summary())
         return self.model_simplified, self.pareto_chart(self.model_simplified, "Pareto - Modelo Simplificado")
 
+    def _generate_formula(self, simplified=False):
+        """
+        Genera la fórmula del modelo según el número de factores y si es simplificado.
+        """
+        terms = self.factor_names.copy()
+        if simplified:
+            # Añadir términos cuadráticos
+            terms += [f"I({var}**2)" for var in self.factor_names]
+        else:
+            # Añadir términos cuadráticos e interacciones
+            terms += [f"I({var}**2)" for var in self.factor_names]
+            terms += [f"{var1}:{var2}" for var1, var2 in itertools.combinations(self.factor_names, 2)]
+        formula = f"{self.y_name} ~ " + " + ".join(terms)
+        return formula
+
     def optimize(self, method='Nelder-Mead'):
         """
         Encuentra los niveles óptimos de los factores para maximizar la respuesta usando el modelo simplificado.
@@ -84,138 +134,128 @@ class RSM_BoxBehnken:
             return
 
         def objective_function(x):
-            return -self.model_simplified.predict(pd.DataFrame({
-                self.x1_name: [x[0]],
-                self.x2_name: [x[1]],
-                self.x3_name: [x[2]]
-            })).values[0]
-
-        bounds = [(-1, 1), (-1, 1), (-1, 1)]
-        x0 = [0, 0, 0]
+            # Convertir los niveles codificados a naturales
+            natural_values = [self.coded_to_natural(xi, i) for i, xi in enumerate(x)]
+            # Crear un DataFrame para la predicción
+            prediction_df = pd.DataFrame([natural_values], columns=self.factor_names)
+            # Convertir naturales a codificados
+            for i in range(self.n_factors):
+                prediction_df[self.factor_names[i]] = prediction_df[self.factor_names[i]].apply(lambda val: self.natural_to_coded(val, i))
+            # Predecir la respuesta
+            return -self.model_simplified.predict(prediction_df)[0]
+
+        # Definir límites en los niveles codificados (-1, 1)
+        bounds = [(-1, 1)] * self.n_factors
+        x0 = [0] * self.n_factors  # Punto inicial en el centro
 
         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 = [
-            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)
+            self.coded_to_natural(xi, i) for i, xi in enumerate(self.optimal_levels)
         ]
+
         # Crear la tabla de optimización
         optimization_table = pd.DataFrame({
-            'Variable': [self.x1_name, self.x2_name, self.x3_name],
+            'Variable': self.factor_names,
             'Nivel Óptimo (Natural)': optimal_levels_natural,
             'Nivel Óptimo (Codificado)': self.optimal_levels
         })
 
-        return optimization_table.round(3)  # Redondear a 3 decimales
+        return optimization_table.round(3)
 
-    def plot_rsm_individual(self, fixed_variable, fixed_level):
+    def generate_all_plots(self):
         """
-        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
+        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
+
+        self.all_figures = []  # Resetear la lista de figuras
+
+        # Obtener las combinaciones de factores para gráficos
+        for fixed_index, fixed_variable in enumerate(self.factor_names):
+            for level in self.factor_levels[fixed_index]['levels']:
+                fig = self.plot_rsm_individual(fixed_variable, level)
+                if fig is not None:
+                    self.all_figures.append(fig)
+
+    def plot_rsm_individual(self, fixed_variable, fixed_level):
+        """
+        Genera un gráfico de superficie de respuesta (RSM) individual para una configuración específica.
+        """
+        # Determinar las variables que varían
+        varying_variables = [var for var in self.factor_names if var != fixed_variable]
+        if len(varying_variables) < 2:
+            print("Se requieren al menos dos variables que varían para generar el gráfico.")
             return None
 
-        # Determinar las variables que varían y sus niveles naturales
-        varying_variables = [var for var in [self.x1_name, self.x2_name, self.x3_name] if var != fixed_variable]
-        
-        # Establecer los niveles naturales para las variables que varían
-        x_natural_levels = self.get_levels(varying_variables[0])
-        y_natural_levels = self.get_levels(varying_variables[1])
+        var1, var2 = varying_variables[:2]  # Seleccionar las dos primeras variables que varían
+
+        # Niveles naturales para las variables que varían
+        var1_levels = self.factor_levels[self.factor_names.index(var1)]['levels']
+        var2_levels = self.factor_levels[self.factor_names.index(var2)]['levels']
 
         # Crear una malla de puntos para las variables que varían (en unidades naturales)
-        x_range_natural = np.linspace(x_natural_levels[0], x_natural_levels[-1], 100)
-        y_range_natural = np.linspace(y_natural_levels[0], y_natural_levels[-1], 100)
-        x_grid_natural, y_grid_natural = np.meshgrid(x_range_natural, y_range_natural)
+        x_range = np.linspace(min(var1_levels), max(var1_levels), 100)
+        y_range = np.linspace(min(var2_levels), max(var2_levels), 100)
+        x_grid, y_grid = np.meshgrid(x_range, y_range)
 
         # Convertir la malla de variables naturales a codificadas
-        x_grid_coded = self.natural_to_coded(x_grid_natural, varying_variables[0])
-        y_grid_coded = self.natural_to_coded(y_grid_natural, varying_variables[1])
+        x_coded = np.array([self.natural_to_coded(x, self.factor_names.index(var1)) for x in x_grid.flatten()]).reshape(x_grid.shape)
+        y_coded = np.array([self.natural_to_coded(y, self.factor_names.index(var2)) for y in y_grid.flatten()]).reshape(y_grid.shape)
 
         # Crear un DataFrame para la predicción con variables codificadas
         prediction_data = pd.DataFrame({
-            varying_variables[0]: x_grid_coded.flatten(),
-            varying_variables[1]: y_grid_coded.flatten(),
+            var1: x_coded.flatten(),
+            var2: y_coded.flatten(),
+            fixed_variable: self.natural_to_coded(fixed_level, self.factor_names.index(fixed_variable))
         })
-        prediction_data[fixed_variable] = self.natural_to_coded(fixed_level, fixed_variable)
 
-        # Calcular los valores predichos
-        z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid_coded.shape)
+        # Añadir las demás variables a 0 (centro)
+        for var in self.factor_names:
+            if var not in [var1, var2, fixed_variable]:
+                prediction_data[var] = 0
 
-        # Filtrar por el nivel de la variable fija (en codificado)
-        fixed_level_coded = self.natural_to_coded(fixed_level, fixed_variable)
-        subset_data = self.data[np.isclose(self.data[fixed_variable], fixed_level_coded)]
+        # Reordenar las columnas
+        prediction_data = prediction_data[self.factor_names]
 
-        # Filtrar por niveles válidos en las variables que varían
-        valid_levels = [-1, 0, 1]
-        experiments_data = subset_data[
-            subset_data[varying_variables[0]].isin(valid_levels) &
-            subset_data[varying_variables[1]].isin(valid_levels)
-        ]
+        # Calcular los valores predichos
+        z_pred = self.model_simplified.predict(prediction_data).values.reshape(x_grid.shape)
 
-        # Convertir coordenadas de experimentos a naturales
-        experiments_x_natural = experiments_data[varying_variables[0]].apply(lambda x: self.coded_to_natural(x, varying_variables[0]))
-        experiments_y_natural = experiments_data[varying_variables[1]].apply(lambda x: self.coded_to_natural(x, varying_variables[1]))
-
-        # Crear el gráfico de superficie con variables naturales en los ejes y transparencia
-        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid_natural, y=y_grid_natural, colorscale='Viridis', opacity=0.7, showscale=True)])
-
-        # --- Añadir cuadrícula a la superficie ---
-        # Líneas en la dirección x
-        for i in range(x_grid_natural.shape[0]):
-            fig.add_trace(go.Scatter3d(
-                x=x_grid_natural[i, :],
-                y=y_grid_natural[i, :],
-                z=z_pred[i, :],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                showlegend=False,
-                hoverinfo='skip'
-            ))
-        # Líneas en la dirección y
-        for j in range(x_grid_natural.shape[1]):
-            fig.add_trace(go.Scatter3d(
-                x=x_grid_natural[:, j],
-                y=y_grid_natural[:, j],
-                z=z_pred[:, j],
-                mode='lines',
-                line=dict(color='gray', width=2),
-                showlegend=False,
-                hoverinfo='skip'
-            ))
-
-        # --- Fin de la adición de la cuadrícula ---
-
-        # Añadir los puntos de los experimentos en la superficie de respuesta con diferentes colores y etiquetas
-        colors = px.colors.qualitative.Safe
-        point_labels = [f"{row[self.y_name]:.3f}" for _, row in experiments_data.iterrows()]
+        # Crear el gráfico de superficie
+        fig = go.Figure(data=[go.Surface(z=z_pred, x=x_grid, y=y_grid, colorscale='Viridis', opacity=0.7, showscale=True)])
 
+        # Añadir puntos de los experimentos
+        experiments = self.data.copy()
+        experiments = experiments[(experiments[fixed_variable] == fixed_level)]
         fig.add_trace(go.Scatter3d(
-            x=experiments_x_natural,
-            y=experiments_y_natural,
-            z=experiments_data[self.y_name].round(3),
+            x=experiments[var1],
+            y=experiments[var2],
+            z=experiments[self.y_name],
             mode='markers+text',
-            marker=dict(size=4, color=colors[:len(experiments_x_natural)]),
-            text=point_labels,
+            marker=dict(size=5, color='red'),
+            text=[f"{val:.2f}" for val in experiments[self.y_name]],
             textposition='top center',
             name='Experimentos'
         ))
 
-        # Añadir etiquetas y título con variables naturales
+        # Actualizar layout
         fig.update_layout(
             scene=dict(
-                xaxis_title=f"{varying_variables[0]} ({self.get_units(varying_variables[0])})",
-                yaxis_title=f"{varying_variables[1]} ({self.get_units(varying_variables[1])})",
+                xaxis_title=f"{var1} ({self.get_units(var1)})",
+                yaxis_title=f"{var2} ({self.get_units(var2)})",
                 zaxis_title=self.y_name,
             ),
-            title=f"{self.y_name} vs {varying_variables[0]} y {varying_variables[1]}<br><sup>{fixed_variable} fijo en {fixed_level:.3f} ({self.get_units(fixed_variable)}) (Modelo Simplificado)</sup>",
+            title=f"{self.y_name} vs {var1} y {var2}<br><sup>{fixed_variable} fijo en {fixed_level} ({self.get_units(fixed_variable)})</sup>",
             height=800,
             width=1000,
             showlegend=True
         )
+
         return fig
 
     def get_units(self, variable_name):
@@ -227,56 +267,22 @@ class RSM_BoxBehnken:
             'Glucosa': 'g/L',
             'Extracto_de_Levadura': 'g/L',
             'Triptofano': 'g/L',
-            'AIA_ppm': 'ppm'
+            'AIA_ppm': 'ppm',
+            # Agrega más unidades según tus variables
         }
         return units.get(variable_name, '')
 
-    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
-
-        self.all_figures = []  # Resetear la lista de figuras
-
-        # Niveles naturales para graficar
-        levels_to_plot_natural = {
-            self.x1_name: self.x1_levels,
-            self.x2_name: self.x2_levels,
-            self.x3_name: self.x3_levels
-        }
-
-        # 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:
-                    self.all_figures.append(fig)
-
-    def coded_to_natural(self, coded_value, variable_name):
-        """Convierte un valor codificado a su valor natural."""
-        levels = self.get_levels(variable_name)
-        return levels[0] + (coded_value + 1) * (levels[-1] - levels[0]) / 2
-
-    def natural_to_coded(self, natural_value, variable_name):
-        """Convierte un valor natural a su valor codificado."""
-        levels = self.get_levels(variable_name)
-        return -1 + 2 * (natural_value - levels[0]) / (levels[-1] - levels[0])
-
     def pareto_chart(self, model, title):
         """
         Genera un diagrama de Pareto para los efectos estandarizados de un modelo,
         incluyendo la línea de significancia.
         """
         # Calcular los efectos estandarizados
-        tvalues = model.tvalues[1:]  # Excluir la Intercept
-        abs_tvalues = np.abs(tvalues)
-        sorted_idx = np.argsort(abs_tvalues)[::-1]
+        tvalues = model.tvalues.drop('Intercept')
+        abs_tvalues = tvalues.abs()
+        sorted_idx = abs_tvalues.sort_values(ascending=False).index
         sorted_tvalues = abs_tvalues[sorted_idx]
-        sorted_names = tvalues.index[sorted_idx]
+        sorted_names = sorted_idx
 
         # Calcular el valor crítico de t para la línea de significancia
         alpha = 0.05  # Nivel de significancia
@@ -300,34 +306,6 @@ class RSM_BoxBehnken:
 
         return fig
 
-    def get_simplified_equation(self):
-        """
-        Retorna la ecuación del modelo simplificado como una cadena de texto.
-        """
-        if self.model_simplified is None:
-            print("Error: Ajusta el modelo simplificado primero.")
-            return None
-
-        coefficients = self.model_simplified.params
-        equation = f"{self.y_name} = {coefficients['Intercept']:.3f}"
-
-        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"
-
-        return equation
-
     def generate_prediction_table(self):
         """
         Genera una tabla con los valores actuales, predichos y residuales.
@@ -366,12 +344,8 @@ class RSM_BoxBehnken:
         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'
+                if 'I(' in factor_name:
+                    factor_name = factor_name.replace('I(', '').replace(')', '').replace('** 2', '^2')
                 
                 ss_factor = row['sum_sq']
                 contribution_percentage = (ss_factor / ss_total) * 100
@@ -394,8 +368,7 @@ class RSM_BoxBehnken:
 
         # --- ANOVA detallada ---
         # 1. Ajustar un modelo solo con los términos de primer orden y cuadráticos
-        formula_reduced = f'{self.y_name} ~ {self.x1_name} + {self.x2_name} + {self.x3_name} + ' \
-                          f'I({self.x1_name}**2) + I({self.x2_name}**2) + I({self.x3_name}**2)'
+        formula_reduced = self._generate_formula(simplified=True)
         model_reduced = smf.ols(formula_reduced, data=self.data).fit()
 
         # 2. ANOVA del modelo reducido (para obtener la suma de cuadrados de la regresión)
@@ -408,7 +381,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'].drop('Residual').sum()
 
         # 6. Grados de libertad de la regresión
         df_regression = len(anova_reduced) - 1
@@ -418,13 +391,9 @@ class RSM_BoxBehnken:
         df_residual = self.model_simplified.df_resid
 
         # 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)]
-        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
+        # Para simplificar, asumimos que no hay réplicas (no hay corridas duplicadas)
+        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 if not np.isnan(ss_pure_error) else np.nan
@@ -451,7 +420,9 @@ class RSM_BoxBehnken:
         })
         
         # Calcular la suma de cuadrados y grados de libertad para la curvatura
-        ss_curvature = anova_reduced['sum_sq'][f'I({self.x1_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x2_name} ** 2)'] + anova_reduced['sum_sq'][f'I({self.x3_name} ** 2)']
+        ss_curvature = anova_reduced['sum_sq'].get(f'I({self.factor_names[0]}**2)', 0) + \
+                       anova_reduced['sum_sq'].get(f'I({self.factor_names[1]}**2)', 0) + \
+                       anova_reduced['sum_sq'].get(f'I({self.factor_names[2]}**2)', 0)
         df_curvature = 3
 
         # Añadir la fila de curvatura a la tabla ANOVA
@@ -467,7 +438,7 @@ class RSM_BoxBehnken:
 
     def get_all_tables(self):
         """
-        Obtiene todas las tablas generadas para ser exportadas a Excel.
+        Obtiene todas las tablas generadas para ser exportadas a Excel y Word.
         """
         prediction_table = self.generate_prediction_table()
         contribution_table = self.calculate_contribution_percentage()
@@ -595,240 +566,285 @@ class RSM_BoxBehnken:
 
 # --- Funciones para la Interfaz de Gradio ---
 
-def load_data(x1_name, x2_name, x3_name, y_name, x1_levels_str, x2_levels_str, x3_levels_str, data_str):
+def load_data(n_factors, factor_details, y_name, example=False):
     """
-    Carga los datos del diseño Box-Behnken desde cajas de texto y crea la instancia de RSM_BoxBehnken.
+    Carga los datos del diseño Box-Behnken según el número de factores y sus detalles.
+    Si example=True, carga un ejemplo predefinido.
     """
     try:
-        # Convertir los niveles a listas de números
-        x1_levels = [float(x.strip()) for x in x1_levels_str.split(',')]
-        x2_levels = [float(x.strip()) for x in x2_levels_str.split(',')]
-        x3_levels = [float(x.strip()) for x in x3_levels_str.split(',')]
-
-        # Crear DataFrame a partir de la cadena de datos
-        data_list = [row.split(',') for row in data_str.strip().split('\n')]
-        column_names = ['Exp.', x1_name, x2_name, x3_name, y_name]
-        data = pd.DataFrame(data_list, columns=column_names)
-        data = data.apply(pd.to_numeric, errors='coerce')  # Convertir a numérico
-
-        # Validar que el DataFrame tenga las columnas correctas
-        if not all(col in data.columns for col in column_names):
-            raise ValueError("El formato de los datos no es correcto.")
-
-        # Crear la instancia de RSM_BoxBehnken
-        global rsm
-        rsm = RSM_BoxBehnken(data, x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels)
-
-        return data.round(3), x1_name, x2_name, x3_name, y_name, x1_levels, x2_levels, x3_levels, gr.update(visible=True)
-    
+        if example:
+            # Ejemplo para 3 factores
+            if n_factors == 3:
+                factor_names = ['Glucosa', 'Extracto_de_Levadura', 'Triptofano']
+                factor_levels = [
+                    {'min': 1.0, 'max': 5.5, 'levels': [1.0, 3.5, 5.5]},
+                    {'min': 0.03, 'max': 0.3, 'levels': [0.03, 0.2, 0.3]},
+                    {'min': 0.4, 'max': 0.9, 'levels': [0.4, 0.65, 0.9]}
+                ]
+                # Crear instancia
+                rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+                design = rsm.generate_box_behnken_design()
+                # Ejemplo de valores de respuesta
+                response_values = [166.594, 177.557, 127.261, 147.573, 188.883, 224.527, 190.238, 226.483, 195.550, 149.493, 187.683, 148.621, 278.951, 297.238, 280.896]
+                rsm.set_response(response_values)
+                return rsm, design
+            # Ejemplo para 4 factores
+            elif n_factors == 4:
+                factor_names = ['Glucosa', 'Extracto_de_Levadura', 'Triptofano', 'Tiempo']
+                factor_levels = [
+                    {'min': 1.0, 'max': 5.5, 'levels': [1.0, 3.5, 5.5]},
+                    {'min': 0.03, 'max': 0.3, 'levels': [0.03, 0.2, 0.3]},
+                    {'min': 0.4, 'max': 0.9, 'levels': [0.4, 0.65, 0.9]},
+                    {'min': 24, 'max': 72, 'levels': [24, 48, 72]}
+                ]
+                # Crear instancia
+                rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+                design = rsm.generate_box_behnken_design()
+                # Ejemplo de valores de respuesta (30 corridas para 4 factores)
+                response_values = [200 + np.random.normal(0, 10) for _ in range(len(design))]
+                rsm.set_response(response_values)
+                return rsm, design
+            else:
+                raise ValueError("Ejemplos solo disponibles para 3 y 4 factores.")
+        else:
+            # Cargar según la entrada del usuario
+            factor_names = [detail['name'] for detail in factor_details]
+            factor_levels = [{'min': detail['min'], 'max': detail['max'], 'levels': [detail['min'], (detail['min'] + detail['max']) / 2, detail['max']]} for detail in factor_details]
+            # Crear instancia
+            rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+            design = rsm.generate_box_behnken_design()
+            return rsm, design
     except Exception as e:
-        # Mostrar mensaje de error
-        error_message = f"Error al cargar los datos: {str(e)}"
-        print(error_message)
-        return None, "", "", "", "", [], [], [], gr.update(visible=False)
-
-def fit_and_optimize_model():
-    if 'rsm' not in globals():
-        return [None]*11  # Ajustar el número de outputs
-
-    # Ajustar modelos y optimizar
-    model_completo, pareto_completo = rsm.fit_model()
-    model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
-    optimization_table = rsm.optimize()
-    equation = rsm.get_simplified_equation()
-    prediction_table = rsm.generate_prediction_table()
-    contribution_table = rsm.calculate_contribution_percentage()
-    anova_table = rsm.calculate_detailed_anova()
-    
-    # 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}"
-    
-    # Guardar las tablas en Excel temporal
-    excel_path = rsm.save_tables_to_excel()
-
-    # Guardar todas las figuras en un ZIP temporal
-    zip_path = rsm.save_figures_to_zip()
-
-    return (
-        model_completo.summary().as_html(),
-        pareto_completo,
-        model_simplificado.summary().as_html(),
-        pareto_simplificado,
-        equation_formatted,
-        optimization_table,
-        prediction_table,
-        contribution_table,
-        anova_table,
-        zip_path,    # Ruta del ZIP de gráficos
-        excel_path   # Ruta del Excel de tablas
-    )
-
-def show_plot(current_index, all_figures):
-    if not all_figures:
-        return None, "No hay gráficos disponibles.", current_index
-    selected_fig = all_figures[current_index]
-    plot_info_text = f"Gráfico {current_index + 1} de {len(all_figures)}"
-    return selected_fig, plot_info_text, current_index
-
-def navigate_plot(direction, current_index, all_figures):
-    """
-    Navega entre los gráficos.
-    """
-    if not all_figures:
-        return None, "No hay gráficos disponibles.", current_index
-    
-    if direction == 'left':
-        new_index = (current_index - 1) % len(all_figures)
-    elif direction == 'right':
-        new_index = (current_index + 1) % len(all_figures)
-    else:
-        new_index = current_index
-    
-    selected_fig = all_figures[new_index]
-    plot_info_text = f"Gráfico {new_index + 1} de {len(all_figures)}"
-    
-    return selected_fig, plot_info_text, new_index
-
-def download_current_plot(all_figures, current_index):
+        print(f"Error al cargar los datos: {str(e)}")
+        return None, None
+
+def fit_and_optimize(rsm, response_values):
     """
-    Descarga la figura actual como PNG.
+    Ajusta los modelos, realiza la optimización y genera todas las tablas y gráficos.
     """
-    if not all_figures:
-        return None
-    fig = all_figures[current_index]
-    img_bytes = rsm.save_fig_to_bytes(fig)
-    filename = f"Grafico_RSM_{current_index + 1}.png"
-    
-    # Crear un archivo temporal
-    with tempfile.NamedTemporaryFile(delete=False, suffix=".png") as temp_file:
-        temp_file.write(img_bytes)
-        temp_path = temp_file.name
-    
-    return temp_path  # Retornar solo la ruta
-
-def download_all_plots_zip():
+    try:
+        rsm.set_response(response_values)
+        model_completo, pareto_completo = rsm.fit_model()
+        model_simplificado, pareto_simplificado = rsm.fit_simplified_model()
+        optimization_table = rsm.optimize()
+        equation = rsm.get_simplified_equation()
+        prediction_table = rsm.generate_prediction_table()
+        contribution_table = rsm.calculate_contribution_percentage()
+        anova_table = rsm.calculate_detailed_anova()
+        
+        # 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(" ** 2", "^2").replace("*", " × ")
+        equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
+        
+        # Guardar las tablas en Excel temporal
+        excel_path = rsm.save_tables_to_excel()
+
+        # Guardar todas las figuras en un ZIP temporal
+        zip_path = rsm.save_figures_to_zip()
+
+        # Preparar las tablas para exportación
+        tables_dict = rsm.get_all_tables()
+
+        return (
+            model_completo.summary().as_html(),
+            pareto_completo,
+            model_simplificado.summary().as_html(),
+            pareto_simplificado,
+            equation_formatted,
+            optimization_table,
+            prediction_table,
+            contribution_table,
+            anova_table,
+            zip_path,    # Ruta del ZIP de gráficos
+            excel_path,  # Ruta del Excel de tablas
+            tables_dict   # Diccionario de tablas para Word
+        )
+    except Exception as e:
+        print(f"Error en el análisis: {str(e)}")
+        return [None]*12
+
+def export_word(rsm_instance, tables_dict):
     """
-    Descarga todas las figuras en un archivo ZIP.
+    Exporta las tablas a un documento de Word y retorna la ruta del archivo.
     """
-    if 'rsm' not in globals():
+    try:
+        word_path = rsm_instance.export_tables_to_word(tables_dict)
+        if word_path and os.path.exists(word_path):
+            return word_path
         return None
-    zip_path = rsm.save_figures_to_zip()
-    if zip_path:
-        filename = f"Graficos_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.zip"
-        # Gradio no permite renombrar directamente, por lo que retornamos la ruta del archivo
-        return zip_path
-    return None
-
-def download_all_tables_excel():
-    """
-    Descarga todas las tablas en un archivo Excel con múltiples hojas.
-    """
-    if 'rsm' not in globals():
+    except Exception as e:
+        print(f"Error al exportar a Word: {str(e)}")
         return None
-    excel_path = rsm.save_tables_to_excel()
-    if excel_path:
-        filename = f"Tablas_RSM_{datetime.now().strftime('%Y%m%d_%H%M%S')}.xlsx"
-        # Gradio no permite renombrar directamente, por lo que retornamos la ruta del archivo
-        return excel_path
-    return None
-
-def exportar_word(rsm_instance, tables_dict):
-    """
-    Función para exportar las tablas a un documento de Word.
-    """
-    word_path = rsm_instance.export_tables_to_word(tables_dict)
-    if word_path and os.path.exists(word_path):
-        return word_path
-    return None
 
 # --- Crear la interfaz de Gradio ---
 
 def create_gradio_interface():
     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")
-                x1_name_input = gr.Textbox(label="Nombre de la Variable X1 (ej. Glucosa)", value="Glucosa")
-                x2_name_input = gr.Textbox(label="Nombre de la Variable X2 (ej. Extracto de Levadura)", value="Extracto_de_Levadura")
-                x3_name_input = gr.Textbox(label="Nombre de la Variable X3 (ej. Triptófano)", value="Triptofano")
-                y_name_input = gr.Textbox(label="Nombre de la Variable Dependiente (ej. AIA (ppm))", value="AIA_ppm")
-                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=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
-5,-1,0,-1,188.883
-6,1,0,-1,224.527
-7,-1,0,1,190.238
-8,1,0,1,226.483
-9,0,-1,-1,195.550
-10,0,1,-1,149.493
-11,0,-1,1,187.683
-12,0,1,1,148.621
-13,0,0,0,278.951
-14,0,0,0,297.238
-15,0,0,0,280.896""")
-                load_button = gr.Button("Cargar Datos")
+        gr.Markdown("# 📊 Optimización de la Producción de AIA usando Diseño Box-Behnken")
+        gr.Markdown("""
+        Esta aplicación te permite generar diseños Box-Behnken con un número variable de factores (mínimo 3, máximo 6), ajustar modelos de respuesta, realizar optimización y exportar los resultados a Excel y Word.
+        """)
+
+        with gr.Tab("🔧 Configuración"):
+            with gr.Row():
+                n_factors_input = gr.Slider(
+                    minimum=3, 
+                    maximum=6, 
+                    step=1, 
+                    value=3, 
+                    label="Número de Factores",
+                    interactive=True
+                )
+                load_example_checkbox = gr.Checkbox(
+                    label="Cargar Ejemplo",
+                    value=False
+                )
+            
+            with gr.Row():
+                with gr.Column():
+                    # Factores dinámicos (hasta 6)
+                    factor_inputs = []
+                    for i in range(6):
+                        with gr.Row():
+                            factor_name = gr.Textbox(label=f"Factor {i+1} Nombre", placeholder=f"Nombre del Factor {i+1}")
+                            factor_min = gr.Number(label=f"Factor {i+1} Min", value=0.0)
+                            factor_max = gr.Number(label=f"Factor {i+1} Max", value=1.0)
+                        factor_inputs.append({'name': factor_name, 'min': factor_min, 'max': factor_max})
+                    
+                    # Variable dependiente
+                    y_name_input = gr.Textbox(label="Variable Dependiente (Ej. AIA_ppm)", value="AIA_ppm")
             
-            with gr.Column():
-                gr.Markdown("## Datos Cargados")
-                data_output = gr.Dataframe(label="Tabla de Datos", interactive=False)
+            with gr.Row():
+                load_button = gr.Button("🔄 Generar Diseño")
         
-        # Sección de análisis 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**")
-                model_completo_output = gr.HTML()
-                pareto_completo_output = gr.Plot()
-                gr.Markdown("**Modelo Simplificado**")
-                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")
-                download_word_button = gr.DownloadButton("Descargar Tablas en Word")
+        with gr.Tab("📊 Datos del Experimento"):
+            gr.Markdown("### Diseño Box-Behnken")
+            design_output = gr.Dataframe(
+                headers=None,
+                label="Diseño Generado (Completa y Rellena la Columna de Respuestas)",
+                interactive=True
+            )
+            submit_response_button = gr.Button("✅ Enviar Respuestas")
+
+        with gr.Tab("📈 Análisis y Reporte"):
+            with gr.Row():
+                with gr.Column():
+                    gr.Markdown("**Modelo Completo**")
+                    model_completo_output = gr.HTML()
+                    pareto_completo_output = gr.Plot()
+                    
+                    gr.Markdown("**Modelo Simplificado**")
+                    model_simplificado_output = gr.HTML()
+                    pareto_simplificado_output = gr.Plot()
+                    
+                    gr.Markdown("**Ecuación del Modelo Simplificado**")
+                    equation_output = gr.HTML()
+                    
+                    gr.Markdown("**Tabla de Optimización**")
+                    optimization_table_output = gr.Dataframe(label="Tabla de Optimización", interactive=False)
+                    
+                    gr.Markdown("**Tabla de Predicciones**")
+                    prediction_table_output = gr.Dataframe(label="Tabla de Predicciones", interactive=False)
+                    
+                    gr.Markdown("**Tabla de % de Contribución**")
+                    contribution_table_output = gr.Dataframe(label="Tabla de % de Contribución", interactive=False)
+                    
+                    gr.Markdown("**Tabla ANOVA Detallada**")
+                    anova_table_output = gr.Dataframe(label="Tabla ANOVA Detallada", interactive=False)
+                    
+                    gr.Markdown("## Descargar Tablas")
+                    download_excel_button = gr.DownloadButton("💾 Descargar Tablas en Excel")
+                    download_word_button = gr.DownloadButton("📄 Descargar Tablas en Word")
+                
+                with gr.Column():
+                    gr.Markdown("**Gráficos de Superficie de Respuesta**")
+                    rsm_plot_output = gr.Plot()
+                    plot_info = gr.Textbox(label="Información del Gráfico", value="Gráfico 1 de N", interactive=False)
+                    with gr.Row():
+                        left_button = gr.Button("<")
+                        right_button = gr.Button(">")
+                    with gr.Row():
+                        download_plot_button = gr.DownloadButton("💾 Descargar Gráfico Actual (PNG)")
+                        download_all_plots_button = gr.DownloadButton("💾 Descargar Todos los Gráficos (ZIP)")
             
-            with gr.Column():
-                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=-1, maximum=1, step=0.01, value=0.0)
-                plot_button = gr.Button("Generar Gráficos")
-                with gr.Row():
-                    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)")
-                    download_all_plots_button = gr.DownloadButton("Descargar Todos los Gráficos (ZIP)")
-                current_index_state = gr.State(0)  # Estado para el índice actual
-                all_figures_state = gr.State([])  # Estado para todas las figuras
-    
-        # Cargar datos
+            with gr.Row():
+                copiar_btn = gr.Button("📋 Copiar Informe", variant="secondary")
+                exportar_word_btn = gr.Button("💾 Exportar Informe Word", variant="primary")
+                exportar_excel_btn = gr.Button("💾 Exportar Informe Excel", variant="primary")
+
+        # --- Funciones de la Interfaz ---
+
+        def handle_load_design(n_factors, factor_details, y_name, load_example):
+            """
+            Genera el diseño Box-Behnken según la configuración o carga un ejemplo.
+            """
+            if load_example:
+                # Cargar ejemplos predefinidos
+                if n_factors == 3:
+                    factor_names = ['Glucosa', 'Extracto_de_Levadura', 'Triptofano']
+                    factor_levels = [
+                        {'min': 1.0, 'max': 5.5, 'levels': [1.0, 3.5, 5.5]},
+                        {'min': 0.03, 'max': 0.3, 'levels': [0.03, 0.2, 0.3]},
+                        {'min': 0.4, 'max': 0.9, 'levels': [0.4, 0.65, 0.9]}
+                    ]
+                    y_name = 'AIA_ppm'
+                    # Crear instancia
+                    rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+                    design = rsm.generate_box_behnken_design()
+                    # Ejemplo de valores de respuesta
+                    response_values = [166.594, 177.557, 127.261, 147.573, 188.883, 224.527, 190.238, 226.483, 195.550, 149.493, 187.683, 148.621, 278.951, 297.238, 280.896]
+                    rsm.set_response(response_values)
+                    return rsm, design
+                elif n_factors == 4:
+                    factor_names = ['Glucosa', 'Extracto_de_Levadura', 'Triptofano', 'Tiempo']
+                    factor_levels = [
+                        {'min': 1.0, 'max': 5.5, 'levels': [1.0, 3.5, 5.5]},
+                        {'min': 0.03, 'max': 0.3, 'levels': [0.03, 0.2, 0.3]},
+                        {'min': 0.4, 'max': 0.9, 'levels': [0.4, 0.65, 0.9]},
+                        {'min': 24, 'max': 72, 'levels': [24, 48, 72]}
+                    ]
+                    y_name = 'AIA_ppm'
+                    # Crear instancia
+                    rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+                    design = rsm.generate_box_behnken_design()
+                    # Ejemplo de valores de respuesta (30 corridas para 4 factores)
+                    response_values = [200 + np.random.normal(0, 10) for _ in range(len(design))]
+                    rsm.set_response(response_values)
+                    return rsm, design
+                else:
+                    raise ValueError("Ejemplos solo disponibles para 3 y 4 factores.")
+            else:
+                # Cargar según la entrada del usuario
+                factor_names = [detail['name'] for detail in factor_details]
+                factor_levels = [{'min': detail['min'], 'max': detail['max'], 'levels': [detail['min'], (detail['min'] + detail['max']) / 2, detail['max']]} for detail in factor_details]
+                # Crear instancia
+                rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
+                design = rsm.generate_box_behnken_design()
+                return rsm, design
+
+        def prepare_download_files(excel_path, zip_path):
+            """
+            Prepara los archivos para descarga.
+            """
+            return excel_path, zip_path
+
+        # Cargar Diseño
         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]
+            fn=handle_load_design,
+            inputs=[gr.Slider, 
+                    [gr.Row().components for gr.Row in gr.Blocks().__class__], 
+                    y_name_input, 
+                    load_example_checkbox],
+            outputs=[gr.State(), design_output]
         )
-        
-        # Ajustar modelo y optimizar
-        fit_button.click(
-            fit_and_optimize_model,
-            inputs=[],
+
+        # Enviar Respuestas
+        submit_response_button.click(
+            fn=fit_and_optimize,
+            inputs=[gr.State(), design_output],
             outputs=[
                 model_completo_output,
                 pareto_completo_output,
@@ -839,77 +855,34 @@ def create_gradio_interface():
                 prediction_table_output,
                 contribution_table_output,
                 anova_table_output,
-                download_all_plots_button,  # Ruta del ZIP de gráficos
-                download_excel_button      # Ruta del Excel de tablas
+                download_all_plots_button,
+                download_excel_button,
+                tables_dict_output := gr.State()
             ]
         )
-        
-        # Generar y mostrar los gráficos
-        plot_button.click(
-            lambda fixed_var, fixed_lvl: (
-                rsm.plot_rsm_individual(fixed_var, fixed_lvl),
-                f"Gráfico 1 de {len(rsm.all_figures)}" if rsm.all_figures else "No hay gráficos disponibles.",
-                0,
-                rsm.all_figures  # Actualizar el estado de todas las figuras
-            ),
-            inputs=[fixed_variable_input, fixed_level_input],
-            outputs=[rsm_plot_output, plot_info, current_index_state, all_figures_state]
-        )
-        
-        # Navegación de gráficos
-        left_button.click(
-            lambda current_index, all_figures: navigate_plot('left', current_index, all_figures),
-            inputs=[current_index_state, all_figures_state],
-            outputs=[rsm_plot_output, plot_info, current_index_state]
-        )
-        right_button.click(
-            lambda current_index, all_figures: navigate_plot('right', current_index, all_figures),
-            inputs=[current_index_state, all_figures_state],
-            outputs=[rsm_plot_output, plot_info, current_index_state]
-        )
-        
-        # Descargar gráfico actual
-        download_plot_button.click(
-            download_current_plot,
-            inputs=[all_figures_state, current_index_state],
-            outputs=download_plot_button
+
+        # Descargar Tablas en Excel
+        download_excel_button.click(
+            fn=lambda excel_path: excel_path,
+            inputs=[download_excel_button],
+            outputs=[download_excel_button]
         )
-        
-        # Descargar todos los gráficos en ZIP
+
+        # Descargar Todos los Gráficos en ZIP
         download_all_plots_button.click(
-            download_all_plots_zip,
-            inputs=[],
-            outputs=download_all_plots_button
-        )
-        
-        # Descargar todas las tablas en Excel y Word
-        download_excel_button.click(
-            fn=lambda: download_all_tables_excel(),
-            inputs=[],
-            outputs=download_excel_button
+            fn=lambda zip_path: zip_path,
+            inputs=[download_all_plots_button],
+            outputs=[download_all_plots_button]
         )
-        
+
+        # Descargar Tablas en Word
         download_word_button.click(
-            fn=lambda: exportar_word(rsm, rsm.get_all_tables()),
-            inputs=[],
-            outputs=download_word_button
+            fn=lambda rsm_instance, tables_dict: export_word(rsm_instance, tables_dict),
+            inputs=[gr.State(), gr.State()],
+            outputs=[download_word_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.
-        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 o Word con los botones correspondientes.
-        """)
 
-    return demo
+        return demo
 
 # --- Función Principal ---