spacr 0.2.68__py3-none-any.whl → 0.3.0__py3-none-any.whl

spacr/__init__.py

@@ -23,9 +23,9 @@ from . import app_measure
 from . import app_classify
 from . import app_sequencing
 from . import app_umap
+from . import mediar
 from . import logger
 
-
 __all__ = [
     "core",
     "io",
@@ -48,6 +48,7 @@ __all__ = [
     "app_classify",
     "app_sequencing",
     "app_umap",
+    "mediar",
     "logger"
 ]
 

spacr/core.py

@@ -50,8 +50,6 @@ import random
 from PIL import Image
 from torchvision.transforms import ToTensor
 
-
-
 def analyze_plaques(folder):
     summary_data = []
     details_data = []
@@ -1638,7 +1636,7 @@ def preprocess_generate_masks(src, settings={}):
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
     settings['src'] = src
-    save_settings(settings)
+    save_settings(settings, name='gen_mask')
 
     if not settings['pathogen_channel'] is None:
         custom_model_ls = ['toxo_pv_lumen','toxo_cyto']
@@ -1674,7 +1672,10 @@ def preprocess_generate_masks(src, settings={}):
             time_ls=[]
             if check_mask_folder(src, 'cell_mask_stack'):
                 start = time.time()
-                generate_cellpose_masks(mask_src, settings, 'cell')
+                if settings['segmantation_model'] == 'cellpose':
+                    generate_cellpose_masks(mask_src, settings, 'cell')
+                elif settings['segmantation_model'] == 'mediar':
+                    generate_mediar_masks(mask_src, settings, 'cell')
                 stop = time.time()
                 duration = (stop - start)
                 time_ls.append(duration)
@@ -1685,7 +1686,10 @@ def preprocess_generate_masks(src, settings={}):
             time_ls=[]
             if check_mask_folder(src, 'nucleus_mask_stack'):
                 start = time.time()
-                generate_cellpose_masks(mask_src, settings, 'nucleus')
+                if settings['segmantation_model'] == 'cellpose':
+                    generate_cellpose_masks(mask_src, settings, 'nucleus')
+                elif settings['segmantation_model'] == 'mediar':
+                    generate_mediar_masks(mask_src, settings, 'nucleus')
                 stop = time.time()
                 duration = (stop - start)
                 time_ls.append(duration)
@@ -1696,7 +1700,10 @@ def preprocess_generate_masks(src, settings={}):
             time_ls=[]
             if check_mask_folder(src, 'pathogen_mask_stack'):
                 start = time.time()
-                generate_cellpose_masks(mask_src, settings, 'pathogen')
+                if settings['segmantation_model'] == 'cellpose':
+                    generate_cellpose_masks(mask_src, settings, 'pathogen')
+                elif settings['segmantation_model'] == 'mediar':
+                    generate_mediar_masks(mask_src, settings, 'pathogen')
                 stop = time.time()
                 duration = (stop - start)
                 time_ls.append(duration)
@@ -1898,7 +1905,7 @@ def all_elements_match(list1, list2):
     # Check if all elements in list1 are in list2
     return all(element in list2 for element in list1)
 
-def prepare_batch_for_cellpose(batch):
+def prepare_batch_for_segmentation(batch):
     # Ensure the batch is of dtype float32
     if batch.dtype != np.float32:
         batch = batch.astype(np.float32)
@@ -2021,7 +2028,7 @@ def generate_cellpose_masks(src, settings, object_type):
             if batch.size == 0:
                 continue
             
-            batch = prepare_batch_for_cellpose(batch)
+            batch = prepare_batch_for_segmentation(batch)
 
             if timelapse:
                 movie_path = os.path.join(os.path.dirname(src), 'movies')
@@ -2180,7 +2187,7 @@ def generate_masks_from_imgs(src, model, model_name, batch_size, diameter, cellp
         image_files = all_image_files[i:i+batch_size]
 
         if normalize:
-            images, _, image_names, _ = _load_normalized_images_and_labels(image_files, None, channels, percentiles,  circular, invert, plot, remove_background, background, Signal_to_noise)
+            images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files, None, channels, percentiles,  circular, invert, plot, remove_background, background, Signal_to_noise, target_height, target_width)
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
             orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         else:
@@ -2300,7 +2307,7 @@ def compare_cellpose_masks(src, verbose=False, processes=None, save=True):
     from .io import _read_mask
 
     dirs = [os.path.join(src, d) for d in os.listdir(src) if os.path.isdir(os.path.join(src, d)) and d != 'results']
-    dirs.sort()  # Optional: sort directories if needed
+    dirs.sort()
     conditions = [os.path.basename(d) for d in dirs]
 
     # Get common files in all directories
@@ -2316,7 +2323,7 @@ def compare_cellpose_masks(src, verbose=False, processes=None, save=True):
 
     # Filter out None results (from skipped files)
     results = [res for res in results if res is not None]
-    #print(results)
+    print(results)
     if verbose:
         for result in results:
             filename = result['filename']
@@ -3102,4 +3109,92 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
     else:
         plt.show()
 
-    return
+    return
+
+def generate_mediar_masks(src, settings, object_type):
+    """
+    Generates masks using the MEDIARPredictor.
+    
+    :param src: Source folder containing images or npz files.
+    :param settings: Dictionary of settings for generating masks.
+    :param object_type: Type of object to detect (e.g., 'cell', 'nucleus', etc.).
+    """
+    from .mediar import MEDIARPredictor
+    from .io import _create_database, _save_object_counts_to_database
+    from .plot import plot_masks
+    from .settings import set_default_settings_preprocess_generate_masks, _get_object_settings
+
+    # Clear CUDA cache and check if CUDA is available
+    gc.collect()
+    if not torch.cuda.is_available():
+        print(f'Torch CUDA is not available, using CPU')
+
+    # Preprocess settings
+    settings = set_default_settings_preprocess_generate_masks(src, settings)
+
+    if settings['verbose']:
+        settings_df = pd.DataFrame(list(settings.items()), columns=['setting_key', 'setting_value'])
+        settings_df['setting_value'] = settings_df['setting_value'].apply(str)
+        display(settings_df)
+
+    figuresize = 10
+    timelapse = settings['timelapse']
+    batch_size = settings['batch_size']
+
+    # Get object settings and initialize MEDIARPredictor
+    mediar_predictor = MEDIARPredictor(input_path=None, output_path=None, normalize=settings['normalize'], use_tta=False)
+
+    # Paths to input npz files
+    paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
+
+    # Initialize a database for saving measurements
+    count_loc = os.path.join(os.path.dirname(src), 'measurements', 'measurements.db')
+    os.makedirs(os.path.dirname(src) + '/measurements', exist_ok=True)
+    _create_database(count_loc)
+
+    for file_index, path in enumerate(paths):
+        name = os.path.basename(path)
+        name, ext = os.path.splitext(name)
+        output_folder = os.path.join(os.path.dirname(path), f'{object_type}_mask_stack')
+        os.makedirs(output_folder, exist_ok=True)
+
+        with np.load(path) as data:
+            stack = data['data']
+            filenames = data['filenames']
+
+            for i, filename in enumerate(filenames):
+                output_path = os.path.join(output_folder, filename)
+                if os.path.exists(output_path):
+                    print(f"File {filename} already exists. Skipping...")
+                    continue
+
+        # Process each batch of images in the stack
+        for i in range(0, stack.shape[0], batch_size):
+            batch = stack[i: i + batch_size]
+            batch_filenames = filenames[i: i + batch_size]
+
+            # Prepare batch for MEDIARPredictor (optional)
+            batch = prepare_batch_for_segmentation(batch)
+
+            # Predict masks using MEDIARPredictor
+            predicted_masks = mediar_predictor.predict_batch(batch)
+
+            # Save predicted masks
+            for j, mask in enumerate(predicted_masks):
+                output_filename = os.path.join(output_folder, batch_filenames[j])
+                mask = mask.astype(np.uint16)
+                np.save(output_filename, mask)
+
+            # Optional: Plot the masks
+            if settings['plot']:
+                for idx, mask in enumerate(predicted_masks):
+                    plot_masks(batch[idx], mask, cmap='inferno', figuresize=figuresize)
+
+            # Save object counts to database
+            _save_object_counts_to_database(predicted_masks, object_type, batch_filenames, count_loc)
+
+        # Clear CUDA cache after each file
+        gc.collect()
+        torch.cuda.empty_cache()
+
+    print("Mask generation completed.")

spacr/gui.py

@@ -32,7 +32,7 @@ class MainApp(tk.Tk):
         # Set the window size to the dimensions of the monitor where it is located
         self.geometry(f"{width}x{height}")
         self.title("SpaCr GUI Collection")
-        self.configure(bg='#333333')  # Set window background to dark gray
+        self.configure(bg='#333333')
 
         style = ttk.Style()
         self.color_settings = set_dark_style(style, parent_frame=self)
@@ -55,7 +55,8 @@ class MainApp(tk.Tk):
             "Cellpose All": (lambda frame: initiate_root(self, 'cellpose_all'), "Run Cellpose on all images."),
             "Map Barcodes": (lambda frame: initiate_root(self, 'map_barcodes'), "Map barcodes to data."),
             "Regression": (lambda frame: initiate_root(self, 'regression'), "Perform regression analysis."),
-            "Recruitment": (lambda frame: initiate_root(self, 'recruitment'), "Analyze recruitment data.")
+            "Recruitment": (lambda frame: initiate_root(self, 'recruitment'), "Analyze recruitment data."),
+            "Plaque": (lambda frame: initiate_root(self, 'analyze_plaques'), "Analyze plaque data.")
         }
 
         self.selected_app = tk.StringVar()

spacr/gui_core.py

@@ -1,4 +1,4 @@
-import traceback, ctypes, csv, re
+import traceback, ctypes, csv, re, platform, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
@@ -19,7 +19,7 @@ try:
 except AttributeError:
     pass
 
-from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , set_dark_style
+from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style, standardize_figure
 
 # Define global variables
 q = None
@@ -35,8 +35,6 @@ figures = None
 figure_index = None
 progress_bar = None
 usage_bars = None
-fig_memory_limit = None
-figure_current_memory_usage = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -80,35 +78,10 @@ def toggle_settings(button_scrollable_frame):
     category_dropdown.grid(row=0, column=4, sticky="ew", pady=2, padx=2)
     vars_dict = hide_all_settings(vars_dict, categories)
 
-def process_fig_queue():
-    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index
-
-    from .gui_elements import standardize_figure
-    try:
-        while not fig_queue.empty():
-            fig = fig_queue.get_nowait()
-
-            if fig is None:
-                print("Warning: Retrieved a None figure from fig_queue.")
-                continue  # Skip processing if the figure is None
-
-            # Standardize the figure appearance before adding it to the list
-            standardize_figure(fig)
-
-            figures.append(fig)
-            if figure_index == len(figures) - 2:
-                figure_index += 1
-                display_figure(fig)
-    except Exception as e:
-        traceback.print_exc()
-    finally:
-        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
-        parent_frame.after_tasks.append(after_id)
-
 def display_figure(fig):
     global canvas, canvas_widget
 
-    from .gui_elements import modify_figure_properties, save_figure_as_format, modify_figure
+    from .gui_elements import save_figure_as_format, modify_figure
 
     # Apply the dark style to the context menu
     style_out = set_dark_style(ttk.Style())
@@ -197,7 +170,7 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom(event):
+    def zoom_v1(event):
         nonlocal scale_factor
 
         zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
@@ -230,16 +203,55 @@ def display_figure(fig):
         # Redraw the figure
         fig.canvas.draw_idle()
 
+    def zoom(event):
+        nonlocal scale_factor
+
+        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
+
+        # Determine the zoom direction based on the scroll event
+        if event.num == 4 or event.delta > 0:  # Scroll up (zoom in)
+            scale_factor /= (1 + zoom_speed)  # Divide to zoom in
+        elif event.num == 5 or event.delta < 0:  # Scroll down (zoom out)
+            scale_factor *= (1 + zoom_speed)  # Multiply to zoom out
+
+        # Adjust the axes limits based on the new scale factor
+        for ax in canvas.figure.get_axes():
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+
+            x_center = (xlim[1] + xlim[0]) / 2
+            y_center = (ylim[1] + ylim[0]) / 2
+
+            x_range = (xlim[1] - xlim[0]) * scale_factor
+            y_range = (ylim[1] - ylim[0]) * scale_factor
+
+            # Set the new limits
+            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
+            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
+
+        # Redraw the figure efficiently
+        canvas.draw_idle()
+
+
     # Bind events for hover, click interactions, and zoom
     canvas_widget.bind("<Motion>", on_hover)
     canvas_widget.bind("<Leave>", on_leave)
     canvas_widget.bind("<Button-1>", on_click)
     canvas_widget.bind("<Button-3>", on_right_click)
 
-    # Bind mouse wheel for zooming (cross-platform)
-    canvas_widget.bind("<MouseWheel>", zoom)  # Windows
-    canvas_widget.bind("<Button-4>", zoom)  # Linux/macOS Scroll Up
-    canvas_widget.bind("<Button-5>", zoom)  # Linux/macOS Scroll Down
+
+    # Detect the operating system and bind the appropriate mouse wheel events
+    current_os = platform.system()
+
+    if current_os == "Windows":
+        canvas_widget.bind("<MouseWheel>", zoom)  # Windows
+    elif current_os == "Darwin":  # macOS
+        canvas_widget.bind("<MouseWheel>", zoom)
+        canvas_widget.bind("<Button-4>", zoom)  # Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Scroll down
+    elif current_os == "Linux":
+        canvas_widget.bind("<Button-4>", zoom)  # Linux Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Linux Scroll down
 
 def clear_unused_figures():
     global figures, figure_index
@@ -253,6 +265,7 @@ def clear_unused_figures():
 
 def show_previous_figure():
     global figure_index, figures, fig_queue
+    
     if figure_index is not None and figure_index > 0:
         figure_index -= 1
         display_figure(figures[figure_index])
@@ -270,8 +283,104 @@ def show_next_figure():
         figure_index += 1
         display_figure(fig)
 
-def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, progress_bar_var, usage_bars_var, fig_memory_limit_var, figure_current_memory_usage_var):
-    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage
+def process_fig_queue():
+    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index, index_control
+
+    from .gui_elements import standardize_figure
+    try:
+        while not fig_queue.empty():
+            fig = fig_queue.get_nowait()
+
+            if fig is None:
+                print("Warning: Retrieved a None figure from fig_queue.")
+                continue  # Skip processing if the figure is None
+
+            # Standardize the figure appearance before adding it to the list
+            fig = standardize_figure(fig)
+
+            figures.append(fig)
+
+            # Update the slider range and set the value to the latest figure index
+            index_control.set_to(len(figures) - 1)
+
+            if figure_index == -1:
+                figure_index += 1
+                display_figure(figures[figure_index])
+                index_control.set(figure_index)
+            
+    except Exception as e:
+        traceback.print_exc()
+    finally:
+        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
+        parent_frame.after_tasks.append(after_id)
+
+def update_figure(value):
+    global figure_index, figures
+
+    # Convert the value to an integer
+    index = int(value)
+    
+    # Check if the index is valid
+    if 0 <= index < len(figures):
+        figure_index = index
+        display_figure(figures[figure_index])
+
+    # Update the index control widget's range and value
+    index_control.set_to(len(figures) - 1)
+    index_control.set(figure_index)
+
+def setup_plot_section(vertical_container):
+    global canvas, canvas_widget, figures, figure_index, index_control
+
+    # Initialize deque for storing figures and the current index
+    figures = deque()
+
+    # Create a frame for the plot section
+    plot_frame = tk.Frame(vertical_container)
+    vertical_container.add(plot_frame, stretch="always")
+
+    # Set up the plot
+    figure = Figure(figsize=(30, 4), dpi=100)
+    plot = figure.add_subplot(111)
+    plot.plot([], [])
+    plot.axis('off')
+    
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
+    canvas_widget = canvas.get_tk_widget()
+    canvas_widget.grid(row=0, column=0, sticky="nsew")
+
+    plot_frame.grid_rowconfigure(0, weight=1)
+    plot_frame.grid_columnconfigure(0, weight=1)
+
+    canvas.draw()
+    canvas.figure = figure  # Ensure that the figure is linked to the canvas
+    style_out = set_dark_style(ttk.Style())
+    bg = style_out['bg_color']
+    fg = style_out['fg_color']
+
+    figure.patch.set_facecolor(bg)
+    plot.set_facecolor(bg)
+    containers = [plot_frame]
+
+    # Create slider
+    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)  # Fixed height based on knob_radius
+    control_frame.grid(row=1, column=0, sticky="ew", padx=10, pady=5)
+    control_frame.grid_propagate(False)  # Prevent the frame from resizing
+
+    # Pass the update_figure function as the command to spacrSlider
+    index_control = spacrSlider(control_frame, from_=0, to=0, value=0, thickness=2, knob_radius=10, position="center", show_index=True, command=update_figure)
+    index_control.grid(row=0, column=0, sticky="ew")
+    control_frame.grid_columnconfigure(0, weight=1)
+
+    widgets = [canvas_widget, index_control]
+    style = ttk.Style(vertical_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
+
+    return canvas, canvas_widget
+
+def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, index_control_var, progress_bar_var, usage_bars_var):
+    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, index_control
     thread_control = thread_control_var
     q = q_var
     console_output = console_output_var
@@ -285,8 +394,7 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     figure_index = figure_index_var
     progress_bar = progress_bar_var
     usage_bars = usage_bars_var
-    fig_memory_limit = fig_memory_limit_var
-    figure_current_memory_usage = figure_current_memory_usage_var
+    index_control = index_control_var
 
 def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
@@ -332,6 +440,8 @@ def import_settings(settings_type='mask'):
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'analyze_plaques':
+        settings = {}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     
@@ -385,6 +495,8 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
+    elif settings_type == 'analyze_plaques':
+        settings = {}
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
 
@@ -400,46 +512,6 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     print("Settings panel setup complete")
     return scrollable_frame, vars_dict
 
-def setup_plot_section(vertical_container):
-    global canvas, canvas_widget, figures, figure_index
-
-    from .gui_elements import set_element_size
-
-    # Initialize deque for storing figures and the current index
-    figures = deque()
-    figure_index = -1
-
-    # Create a frame for the plot section
-    plot_frame = tk.Frame(vertical_container)
-    vertical_container.add(plot_frame, stretch="always")
-
-    # Set up the plot
-    figure = Figure(figsize=(30, 4), dpi=100)
-    plot = figure.add_subplot(111)
-    plot.plot([], [])
-    plot.axis('off')
-    
-    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
-    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
-    canvas_widget = canvas.get_tk_widget()
-    canvas_widget.grid(row=0, column=0, sticky="nsew")
-
-    plot_frame.grid_rowconfigure(0, weight=1)
-    plot_frame.grid_columnconfigure(0, weight=1)
-
-    canvas.draw()
-    canvas.figure = figure  # Ensure that the figure is linked to the canvas
-    style_out = set_dark_style(ttk.Style())
-
-    figure.patch.set_facecolor(style_out['bg_color'])
-    plot.set_facecolor(style_out['bg_color'])
-    containers = [plot_frame]
-    widgets = [canvas_widget]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    
-    return canvas, canvas_widget
-
 def setup_console(vertical_container):
     global console_output
     from .gui_elements import set_dark_style
@@ -479,27 +551,6 @@ def setup_console(vertical_container):
 
     return console_output, console_frame
 
-def setup_progress_frame(vertical_container):
-    global progress_output
-    style_out = set_dark_style(ttk.Style())
-    font_loader = style_out['font_loader']
-    font_size = style_out['font_size']
-    progress_frame = tk.Frame(vertical_container)
-    vertical_container.add(progress_frame, stretch="always")
-    label_frame = tk.Frame(progress_frame)
-    label_frame.grid(row=0, column=0, sticky="ew", pady=(5, 0), padx=10)
-    progress_label = spacrLabel(label_frame, text="Processing: 0%", font=font_loader.get_font(size=font_size), anchor='w', justify='left', align="left")
-    progress_label.grid(row=0, column=0, sticky="w")
-    progress_output = scrolledtext.ScrolledText(progress_frame, height=10)
-    progress_output.grid(row=1, column=0, sticky="nsew")
-    progress_frame.grid_rowconfigure(1, weight=1)
-    progress_frame.grid_columnconfigure(0, weight=1)
-    containers = [progress_frame, label_frame]
-    widgets = [progress_label, progress_output]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    return progress_output
-
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
     global thread_control, parent_frame, button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
     from .gui_utils import download_hug_dataset
@@ -598,7 +649,7 @@ def setup_usage_panel(horizontal_container, btn_col, uppdate_frequency):
     widgets = [usage_scrollable_frame.scrollable_frame]
     
     usage_bars = []
-    max_elements_per_column = 6
+    max_elements_per_column = 5
     row = 0
     col = 0
 
@@ -726,9 +777,9 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
     initialize_cuda()
 
     process_args = (settings_type, settings, q, fig_queue, stop_requested)
-    if settings_type in ['mask', 'umap', 'measure', 'simulation', 'sequencing', 
-                         'classify', 'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
-                         'regression', 'recruitment', 'plaques', 'cellpose_compare', 'vision_scores', 'vision_dataset']:
+    if settings_type in ['mask', 'umap', 'measure', 'simulation', 'sequencing', 'classify', 'analyze_plaques', 
+                         'cellpose_dataset', 'train_cellpose', 'ml_analyze', 'cellpose_masks', 'cellpose_all', 'map_barcodes', 
+                         'regression', 'recruitment', 'cellpose_compare', 'vision_scores', 'vision_dataset']:
 
         # Start the process
         process = Process(target=run_function_gui, args=process_args)
@@ -836,7 +887,7 @@ def initiate_root(parent, settings_type='mask'):
         tuple: A tuple containing the parent frame and the dictionary of variables used in the GUI.
     """
     
-    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, fig_memory_limit, figure_current_memory_usage
+    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, index_control, usage_bars
     
     from .gui_utils import setup_frame
     from .settings import descriptions
@@ -853,8 +904,6 @@ def initiate_root(parent, settings_type='mask'):
     # Initialize global variables
     figures = deque()
     figure_index = -1
-    fig_memory_limit = 200 * 1024 * 1024  # 200 MB limit
-    figure_current_memory_usage = 0
 
     parent_frame = parent
 
@@ -886,7 +935,7 @@ def initiate_root(parent, settings_type='mask'):
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
         _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
 
-        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage)
+        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, index_control, progress_bar, usage_bars)
         description_text = descriptions.get(settings_type, "No description available for this module.")
         
         q.put(f"Console")
@@ -899,4 +948,6 @@ def initiate_root(parent, settings_type='mask'):
         parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")
-    return parent_frame, vars_dict
+    return parent_frame, vars_dict
+
+