Update app.py

app.py

@@ -41,20 +41,24 @@ class RSM_BoxBehnken:
         """
         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)
+        # Generar todas las combinaciones de tres niveles para cada par de factores
+        for combination in itertools.combinations(self.factor_names, 2):
+            var1, var2 = combination
+            for level1 in [-1, 0, 1]:
+                for level2 in [-1, 0, 1]:
+                    # Solo agregar puntos que formen el diseño Box-Behnken
+                    if abs(level1) == 1 and abs(level2) == 1:
+                        run = {var: 0 for var in self.factor_names}
+                        run[var1] = level1
+                        run[var2] = level2
+                        design.append(run)
 
         # Añadir corridas centrales
         for _ in range(center_runs):
-            design.append([0] * self.n_factors)
+            run = {var: 0 for var in self.factor_names}
+            design.append(run)
 
-        design_df = pd.DataFrame(design, columns=self.factor_names)
+        design_df = pd.DataFrame(design)
         self.design = design_df
 
         # Mapear niveles codificados a naturales
@@ -178,7 +182,9 @@ class RSM_BoxBehnken:
 
         # 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']:
+            # Usar los niveles originales para fijar la variable
+            fixed_levels = self.factor_levels[fixed_index]['levels']
+            for level in fixed_levels:
                 fig = self.plot_rsm_individual(fixed_variable, level)
                 if fig is not None:
                     self.all_figures.append(fig)
@@ -231,7 +237,10 @@ class RSM_BoxBehnken:
 
         # Añadir puntos de los experimentos
         experiments = self.data.copy()
-        experiments = experiments[(experiments[fixed_variable] == fixed_level)]
+        # Convertir el nivel fijo a codificado para filtrar
+        fixed_level_coded = self.natural_to_coded(fixed_level, self.factor_names.index(fixed_variable))
+        # Filtrar experimentos donde la variable fija está cerca del nivel seleccionado (tolerancia pequeña)
+        experiments = experiments[np.isclose(experiments[fixed_variable], fixed_level, atol=1e-3)]
         fig.add_trace(go.Scatter3d(
             x=experiments[var1],
             y=experiments[var2],
@@ -267,6 +276,7 @@ class RSM_BoxBehnken:
             'Glucosa': 'g/L',
             'Extracto_de_Levadura': 'g/L',
             'Triptofano': 'g/L',
+            'Tiempo': 'Horas',
             'AIA_ppm': 'ppm',
             # Agrega más unidades según tus variables
         }
@@ -306,6 +316,28 @@ 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 in self.factor_names:
+                    equation += f" + {coef:.3f}*{term}"
+                elif term.startswith("I("):
+                    equation += f" + {coef:.3f}*{term[2:-1]}"
+                else:
+                    equation += f" + {coef:.3f}*{term.replace(':', '×')}"
+
+        return equation
+
     def generate_prediction_table(self):
         """
         Genera una tabla con los valores actuales, predichos y residuales.
@@ -420,10 +452,12 @@ class RSM_BoxBehnken:
         })
         
         # Calcular la suma de cuadrados y grados de libertad para la curvatura
-        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
+        ss_curvature = 0
+        for var in self.factor_names:
+            curvature_term = f"I({var}**2)"
+            if curvature_term in anova_reduced.index:
+                ss_curvature += anova_reduced.loc[curvature_term, 'sum_sq']
+        df_curvature = self.n_factors
 
         # Añadir la fila de curvatura a la tabla ANOVA
         detailed_anova_table.loc[len(detailed_anova_table)] = ['Curvatura', ss_curvature, df_curvature, ss_curvature / df_curvature, np.nan, np.nan]
@@ -566,14 +600,13 @@ class RSM_BoxBehnken:
 
 # --- Funciones para la Interfaz de Gradio ---
 
-def load_data(n_factors, factor_details, y_name, example=False):
+def handle_load_design(n_factors, factor_inputs, y_name, load_example):
     """
-    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.
+    Genera el diseño Box-Behnken según la configuración o carga un ejemplo.
     """
     try:
-        if example:
-            # Ejemplo para 3 factores
+        if load_example:
+            # Cargar ejemplos predefinidos
             if n_factors == 3:
                 factor_names = ['Glucosa', 'Extracto_de_Levadura', 'Triptofano']
                 factor_levels = [
@@ -581,6 +614,7 @@ def load_data(n_factors, factor_details, y_name, example=False):
                     {'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()
@@ -588,7 +622,6 @@ def load_data(n_factors, factor_details, y_name, example=False):
                 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 = [
@@ -597,6 +630,7 @@ def load_data(n_factors, factor_details, y_name, example=False):
                     {'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()
@@ -608,14 +642,20 @@ def load_data(n_factors, factor_details, y_name, example=False):
                 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]
+            factor_names = []
+            factor_levels = []
+            for i in range(n_factors):
+                name = factor_inputs[i]['name']
+                min_val = factor_inputs[i]['min']
+                max_val = factor_inputs[i]['max']
+                factor_names.append(name)
+                factor_levels.append({'min': min_val, 'max': max_val, 'levels': [min_val, (min_val + max_val) / 2, max_val]})
             # Crear instancia
             rsm = RSM_BoxBehnken(factor_names, factor_levels, y_name)
             design = rsm.generate_box_behnken_design()
             return rsm, design
     except Exception as e:
-        print(f"Error al cargar los datos: {str(e)}")
+        print(f"Error al cargar el diseño: {str(e)}")
         return None, None
 
 def fit_and_optimize(rsm, response_values):
@@ -636,7 +676,7 @@ def fit_and_optimize(rsm, response_values):
         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 = equation.replace(" + ", "<br>+ ").replace("** 2", "^2").replace("*", " × ")
         equation_formatted = f"### Ecuación del Modelo Simplificado:<br>{equation_formatted}"
         
         # Guardar las tablas en Excel temporal
@@ -709,7 +749,7 @@ def create_gradio_interface():
                     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_name = gr.Textbox(label=f"Factor {i+1} Nombre", placeholder=f"Nombre del Factor {i+1}", value=f"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})
@@ -724,7 +764,7 @@ def create_gradio_interface():
             gr.Markdown("### Diseño Box-Behnken")
             design_output = gr.Dataframe(
                 headers=None,
-                label="Diseño Generado (Completa y Rellena la Columna de Respuestas)",
+                label="Diseño Generado (Completa la Columna de Respuestas)",
                 interactive=True
             )
             submit_response_button = gr.Button("✅ Enviar Respuestas")
@@ -769,81 +809,45 @@ def create_gradio_interface():
                     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.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):
+        def handle_load_design_wrapper(n_factors, factor_inputs, y_name, load_example):
             """
-            Genera el diseño Box-Behnken según la configuración o carga un ejemplo.
+            Wrapper para manejar la carga del diseño Box-Behnken.
             """
-            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):
+            # Extraer los valores de los inputs
+            factor_details = []
+            for i in range(6):
+                name = factor_inputs[i]['name'].value
+                min_val = factor_inputs[i]['min'].value
+                max_val = factor_inputs[i]['max'].value
+                factor_details.append({'name': name, 'min': min_val, 'max': max_val})
+            # Generar el diseño
+            return handle_load_design(n_factors, factor_details, y_name, load_example)
+
+        def handle_submit_response(rsm, design_df):
             """
-            Prepara los archivos para descarga.
+            Obtiene las respuestas ingresadas por el usuario y realiza el análisis.
             """
-            return excel_path, zip_path
+            try:
+                # Obtener las respuestas de la última columna (AIA_ppm)
+                response_values = design_df[rsm.y_name].tolist()
+                return fit_and_optimize(rsm, response_values)
+            except Exception as e:
+                print(f"Error al procesar las respuestas: {str(e)}")
+                return [None]*12
 
         # Cargar Diseño
         load_button.click(
-            fn=handle_load_design,
-            inputs=[gr.Slider, 
-                    [gr.Row().components for gr.Row in gr.Blocks().__class__], 
-                    y_name_input, 
-                    load_example_checkbox],
+            fn=handle_load_design_wrapper,
+            inputs=[n_factors_input, factor_inputs, y_name_input, load_example_checkbox],
             outputs=[gr.State(), design_output]
         )
-
-        # Enviar Respuestas
+        
+        # Enviar Respuestas y Realizar Análisis
         submit_response_button.click(
-            fn=fit_and_optimize,
+            fn=handle_submit_response,
             inputs=[gr.State(), design_output],
             outputs=[
                 model_completo_output,
@@ -857,31 +861,73 @@ def create_gradio_interface():
                 anova_table_output,
                 download_all_plots_button,
                 download_excel_button,
-                tables_dict_output := gr.State()
+                gr.State()  # Para tables_dict
             ]
         )
 
-        # Descargar Tablas en Excel
-        download_excel_button.click(
-            fn=lambda excel_path: excel_path,
-            inputs=[download_excel_button],
-            outputs=[download_excel_button]
+        # Navegación de Gráficos (Simplificada)
+        current_plot_state = gr.State(0)
+
+        def get_current_plot(rsm, current_index):
+            if not rsm.all_figures:
+                return None, "No hay gráficos disponibles.", current_index
+            selected_fig = rsm.all_figures[current_index]
+            plot_info_text = f"Gráfico {current_index + 1} de {len(rsm.all_figures)}"
+            return selected_fig, plot_info_text, current_index
+
+        def navigate_plot(direction, current_index, rsm):
+            if not rsm.all_figures:
+                return None, "No hay gráficos disponibles.", current_index
+            if direction == 'left':
+                new_index = (current_index - 1) % len(rsm.all_figures)
+            elif direction == 'right':
+                new_index = (current_index + 1) % len(rsm.all_figures)
+            else:
+                new_index = current_index
+            selected_fig = rsm.all_figures[new_index]
+            plot_info_text = f"Gráfico {new_index + 1} de {len(rsm.all_figures)}"
+            return selected_fig, plot_info_text, new_index
+
+        # Navegación de Gráficos
+        left_button.click(
+            fn=navigate_plot,
+            inputs=[gr.ButtonValue(left_button), current_plot_state, gr.State()],
+            outputs=[rsm_plot_output, plot_info, current_plot_state]
+        )
+        right_button.click(
+            fn=navigate_plot,
+            inputs=[gr.ButtonValue(right_button), current_plot_state, gr.State()],
+            outputs=[rsm_plot_output, plot_info, current_plot_state]
+        )
+
+        # Descargar Gráfico Actual
+        download_plot_button.click(
+            fn=lambda rsm, current_index: rsm.save_fig_to_bytes(rsm.all_figures[current_index]) if rsm and rsm.all_figures else None,
+            inputs=[gr.State(), current_plot_state],
+            outputs=download_plot_button
         )
 
         # Descargar Todos los Gráficos en ZIP
         download_all_plots_button.click(
-            fn=lambda zip_path: zip_path,
-            inputs=[download_all_plots_button],
-            outputs=[download_all_plots_button]
+            fn=lambda rsm: rsm.save_figures_to_zip() if rsm else None,
+            inputs=[gr.State()],
+            outputs=download_all_plots_button
+        )
+
+        # Descargar Tablas en Excel
+        download_excel_button.click(
+            fn=lambda excel_path: (excel_path, None) if excel_path else (None, None),
+            inputs=[gr.State()],
+            outputs=[download_excel_button, None]
         )
 
         # Descargar Tablas en Word
         download_word_button.click(
-            fn=lambda rsm_instance, tables_dict: export_word(rsm_instance, tables_dict),
+            fn=lambda rsm_instance, tables_dict: export_word(rsm_instance, tables_dict) if rsm_instance and tables_dict else None,
             inputs=[gr.State(), gr.State()],
             outputs=[download_word_button]
         )
-
+    
         return demo
 
 # --- Función Principal ---