spacr 0.2.5__py3-none-any.whl → 0.2.8__py3-none-any.whl

spacr/gui_core.py

@@ -1,23 +1,25 @@
-import traceback, ctypes, csv, re, time
+import traceback, ctypes, csv, re, platform, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
-from multiprocessing import Process, Value, Queue, set_start_method, Manager
+from multiprocessing import Process, Value, Queue, set_start_method
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import numpy as np
 import psutil
 import GPUtil
-import tkinter.font as tkFont
+from collections import deque
+import tracemalloc
+from tkinter import Menu
+import io
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, get_analyze_reads_default_settings, set_default_umap_image_settings
-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
@@ -29,6 +31,10 @@ canvas_widget = None
 scrollable_frame = None
 progress_label = None
 fig_queue = None
+figures = None
+figure_index = None
+progress_bar = None
+usage_bars = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -72,42 +78,309 @@ 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
+def display_figure(fig):
+    global canvas, canvas_widget
+
+    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())
+    bg_color = style_out['bg_color']
+    fg_color = style_out['fg_color']
+
+    # Initialize the scale factor for zooming
+    scale_factor = 1.0
+
+    # Save the original x and y limits of the first axis (assuming all axes have the same limits)
+    original_xlim = [ax.get_xlim() for ax in fig.get_axes()]
+    original_ylim = [ax.get_ylim() for ax in fig.get_axes()]
+
+    # Clear previous canvas content
+    if canvas:
+        canvas.get_tk_widget().destroy()
+
+    # Create a new canvas for the figure
+    new_canvas = FigureCanvasTkAgg(fig, master=canvas_widget.master)
+    new_canvas.draw()
+    new_canvas.get_tk_widget().grid(row=0, column=0, sticky="nsew")
+
+    # Update the global canvas and canvas_widget references
+    canvas = new_canvas
+    canvas_widget = new_canvas.get_tk_widget()
+    canvas_widget.configure(bg=bg_color)
+
+    # Create the context menu
+    context_menu = tk.Menu(canvas_widget, tearoff=0, bg=bg_color, fg=fg_color)
+    context_menu.add_command(label="Save Figure as PDF", command=lambda: save_figure_as_format(fig, 'pdf'))
+    context_menu.add_command(label="Save Figure as PNG", command=lambda: save_figure_as_format(fig, 'png'))
+    context_menu.add_command(label="Modify Figure", command=lambda: modify_figure(fig))
+    context_menu.add_command(label="Reset Zoom", command=lambda: reset_zoom(fig))  # Add Reset Zoom option
+
+    def reset_zoom(fig):
+        global scale_factor
+        scale_factor = 1.0  # Reset the scale factor
+
+        for i, ax in enumerate(fig.get_axes()):
+            ax.set_xlim(original_xlim[i])
+            ax.set_ylim(original_ylim[i])
+        fig.canvas.draw_idle()
+
+    def on_right_click(event):
+        context_menu.post(event.x_root, event.y_root)
+
+    def on_hover(event):
+        widget_width = event.widget.winfo_width()
+        x_position = event.x
+
+        if x_position < widget_width / 2:
+            canvas_widget.config(cursor="hand2")
+        else:
+            canvas_widget.config(cursor="hand2")
+
+    def on_leave(event):
+        canvas_widget.config(cursor="arrow")
+
+    def flash_feedback(side):
+        flash = tk.Toplevel(canvas_widget.master)
+        flash.overrideredirect(True)
+        flash_width = int(canvas_widget.winfo_width() / 2)
+        flash_height = canvas_widget.winfo_height()
+        flash.configure(bg='white')
+        flash.attributes('-alpha', 0.9)
+
+        if side == "left":
+            flash.geometry(f"{flash_width}x{flash_height}+{canvas_widget.winfo_rootx()}+{canvas_widget.winfo_rooty()}")
+        else:
+            flash.geometry(f"{flash_width}x{flash_height}+{canvas_widget.winfo_rootx() + flash_width}+{canvas_widget.winfo_rooty()}")
+
+        flash.lift()
+
+        # Ensure the flash covers the correct area only
+        flash.update_idletasks()
+        flash.after(100, flash.destroy)
+
+    def on_click(event):
+        widget_width = event.widget.winfo_width()
+        x_position = event.x
+
+        if x_position < widget_width / 2:
+            #flash_feedback("left")
+            show_previous_figure()
+        else:
+            #flash_feedback("right")
+            show_next_figure()
+
+    def zoom_v1(event):
+        nonlocal scale_factor
+
+        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
+
+        # Adjust zoom factor based on the operating system and mouse event
+        if event.num == 4 or event.delta > 0:  # Scroll up
+            scale_factor *= (1 + zoom_speed)
+        elif event.num == 5 or event.delta < 0:  # Scroll down
+            scale_factor /= (1 + zoom_speed)
+
+        # Get mouse position relative to the figure
+        x_mouse, y_mouse = event.x, event.y
+        x_ratio = x_mouse / canvas_widget.winfo_width()
+        y_ratio = y_mouse / canvas_widget.winfo_height()
+
+        for ax in fig.get_axes():
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
 
-    def clear_canvas(canvas):
+            # Calculate the new limits
+            x_center = xlim[0] + x_ratio * (xlim[1] - xlim[0])
+            y_center = ylim[0] + (1 - y_ratio) * (ylim[1] - ylim[0])
+
+            x_range = (xlim[1] - xlim[0]) * scale_factor
+            y_range = (ylim[1] - ylim[0]) * scale_factor
+
+            ax.set_xlim([x_center - x_range * x_ratio, x_center + x_range * (1 - x_ratio)])
+            ax.set_ylim([y_center - y_range * (1 - y_ratio), y_center + y_range * y_ratio])
+
+        # 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():
-            ax.clear()
+            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)
+
+
+    # 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
+
+    lower_bound = max(0, figure_index - 20)
+    upper_bound = min(len(figures), figure_index + 20)
+    # Clear figures outside of the +/- 20 range
+    figures = deque([fig for i, fig in enumerate(figures) if lower_bound <= i <= upper_bound])
+    # Update the figure index after clearing
+    figure_index = min(max(figure_index, 0), len(figures) - 1)
+
+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])
+        clear_unused_figures()
+
+def show_next_figure():
+    global figure_index, figures, fig_queue
+    if figure_index is not None and figure_index < len(figures) - 1:
+        figure_index += 1
+        display_figure(figures[figure_index])
+        clear_unused_figures()
+    elif figure_index == len(figures) - 1 and not fig_queue.empty():
+        fig = fig_queue.get_nowait()
+        figures.append(fig)
+        figure_index += 1
+        display_figure(fig)
+
+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():
-            time.sleep(1)
-            clear_canvas(canvas)
             fig = fig_queue.get_nowait()
 
-            for ax in fig.get_axes():
-                ax.set_xticks([])  # Remove x-axis ticks
-                ax.set_yticks([])  # Remove y-axis ticks
-                ax.xaxis.set_visible(False)  # Hide the x-axis
-                ax.yaxis.set_visible(False)  # Hide the y-axis
+            if fig is None:
+                print("Warning: Retrieved a None figure from fig_queue.")
+                continue  # Skip processing if the figure is None
 
-            # Adjust layout to minimize spacing between axes
-            fig.subplots_adjust(left=0, right=1, top=1, bottom=0, wspace=0.01, hspace=0.01)
-            fig.set_facecolor('black')
+            # Standardize the figure appearance before adding it to the list
+            fig = standardize_figure(fig)
 
-            canvas.figure = fig
-            fig_width, fig_height = canvas_widget.winfo_width(), canvas_widget.winfo_height()
-            fig.set_size_inches(fig_width / fig.dpi, fig_height / fig.dpi, forward=True)
-            canvas.draw_idle()
+            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(1, process_fig_queue)
+        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
         parent_frame.after_tasks.append(after_id)
 
-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, progress_bar_var, usage_bars_var):
-    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, progress_bar, usage_bars
+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
@@ -117,13 +390,16 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     canvas_widget = canvas_widget_var
     scrollable_frame = scrollable_frame_var
     fig_queue = fig_queue_var
+    figures = figures_var
+    figure_index = figure_index_var
     progress_bar = progress_bar_var
     usage_bars = usage_bars_var
+    index_control = index_control_var
 
 def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     global vars_dict, scrollable_frame, button_scrollable_frame
-    from .settings import generate_fields
+    from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
 
     def read_settings_from_csv(csv_file_path):
         settings = {}
@@ -159,9 +435,11 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'classify':
         settings = set_default_train_test_model(settings={})
     elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
+    elif settings_type == 'recruitment':
+        settings = get_analyze_recruitment_default_settings(settings={})
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     
@@ -172,8 +450,9 @@ def import_settings(settings_type='mask'):
 
 def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
-    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, get_analyze_reads_default_settings, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
-    from .gui_utils import convert_settings_dict_for_gui, set_element_size
+    from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .gui_utils import convert_settings_dict_for_gui
+    from .gui_elements import set_element_size
 
     size_dict = set_element_size()
     settings_width = size_dict['settings_width']
@@ -197,9 +476,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'measure':
         settings = get_measure_crop_settings(settings={})
     elif settings_type == 'classify':
-        settings = set_default_train_test_model(settings={})
-    elif settings_type == 'sequencing':
-        settings = get_analyze_reads_default_settings(settings={})
+        settings = deep_spacr_defaults(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
     elif settings_type == 'train_cellpose':
@@ -211,7 +488,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'cellpose_all':
         settings = get_check_cellpose_models_default_settings(settings={})
     elif settings_type == 'map_barcodes':
-        settings = get_map_barcodes_default_settings(settings={})
+        settings = set_default_generate_barecode_mapping(settings={})
     elif settings_type == 'regression':
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
@@ -231,39 +508,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
-
-    # Create a frame for the plot section
-    plot_frame = tk.Frame(vertical_container, bg='lightgrey')
-    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([], [])  # This creates an empty 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")  # Use grid for the canvas widget
-
-    plot_frame.grid_rowconfigure(0, weight=1)
-    plot_frame.grid_columnconfigure(0, weight=1)
-
-    canvas.draw()
-    canvas.figure = figure
-    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
@@ -282,9 +526,10 @@ def setup_console(vertical_container):
 
     # Create the scrollable frame (which is a Text widget) with white text
     family = style_out['font_family']
-    size = style_out['font_size'] - 2
-    font = tkFont.Font(family=family, size=size)
-    console_output = tk.Text(console_frame, bg=style_out['bg_color'], fg=style_out['fg_color'], font=font, bd=0, highlightthickness=0)
+    font_size = style_out['font_size']
+    font_loader = style_out['font_loader']
+    console_output = tk.Text(console_frame, bg=style_out['bg_color'], fg=style_out['fg_color'], font=font_loader.get_font(size=font_size), bd=0, highlightthickness=0)
+    
     console_output.grid(row=1, column=0, sticky="nsew")  # Use grid for console_output
 
     # Configure the grid to allow expansion
@@ -302,36 +547,15 @@ def setup_console(vertical_container):
 
     return console_output, console_frame
 
-def setup_progress_frame(vertical_container):
-    global progress_output
-    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=('Helvetica', 12), 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 set_element_size, download_hug_dataset
-    from .settings import categories
+    from .gui_utils import download_hug_dataset
+    from .gui_elements import set_element_size
 
     size_dict = set_element_size()
     button_section_height = size_dict['panel_height']
     button_frame = tk.Frame(horizontal_container, height=button_section_height)
     
-    # Prevent the frame from resizing based on the child widget
-    #button_frame.pack_propagate(False)
-
     horizontal_container.add(button_frame, stretch="always", sticky="nsew")
     button_scrollable_frame = spacrFrame(button_frame, scrollbar=False)
     button_scrollable_frame.grid(row=1, column=0, sticky="nsew")
@@ -346,7 +570,7 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
         widgets.append(run_button)
         btn_col += 1
 
-    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap']:
+    if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap', 'map_barcodes']:
         abort_button = spacrButton(button_scrollable_frame.scrollable_frame, text="abort", command=lambda: initiate_abort(), show_text=False, size=size_dict['btn_size'], animation=False)
         abort_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(abort_button)
@@ -364,9 +588,9 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
         widgets.append(import_button)
         btn_row += 1
 
-    # Add the progress bar under the settings category menu
+    # Add the batch progress bar
     progress_bar = spacrProgressBar(button_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate')
-    progress_bar.grid(row=btn_row, column=0, columnspan=6, pady=5, padx=5, sticky='ew')
+    progress_bar.grid(row=btn_row, column=0, columnspan=7, pady=5, padx=5, sticky='ew')
     progress_bar.set_label_position()  # Set the label position after grid placement
     widgets.append(progress_bar)
 
@@ -378,10 +602,9 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
 
     return button_scrollable_frame, btn_col
 
-def setup_usage_panel(horizontal_container, btn_col):
+def setup_usage_panel(horizontal_container, btn_col, uppdate_frequency):
     global usage_bars
-    from .gui_utils import set_element_size
-    from .gui_elements import set_dark_style
+    from .gui_elements import set_dark_style, set_element_size
 
     usg_col = 1
 
@@ -405,7 +628,7 @@ def setup_usage_panel(horizontal_container, btn_col):
             bar['value'] = usage
 
         # Schedule the function to run again after 1000 ms (1 second)
-        parent_frame.after(1000, update_usage, ram_bar, vram_bar, gpu_bar, usage_bars, parent_frame)
+        parent_frame.after(uppdate_frequency, update_usage, ram_bar, vram_bar, gpu_bar, usage_bars, parent_frame)
 
     size_dict = set_element_size()
     usage_panel_height = size_dict['panel_height']
@@ -422,7 +645,7 @@ def setup_usage_panel(horizontal_container, btn_col):
     widgets = [usage_scrollable_frame.scrollable_frame]
     
     usage_bars = []
-    max_elements_per_column = 4
+    max_elements_per_column = 6
     row = 0
     col = 0
 
@@ -432,15 +655,15 @@ def setup_usage_panel(horizontal_container, btn_col):
     # Configure the style for the label
     style = ttk.Style()
     style_out = set_dark_style(style)
-    size = style_out['font_size'] - 2
-    usage_font = tkFont.Font(family=style_out['font_family'], size=size)
-    style.configure("usage.TLabel", font=usage_font, foreground=style_out['fg_color'])
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size'] - 2
+    style.configure("usage.TLabel", font=font_loader.get_font(size=font_size), foreground=style_out['fg_color'])
 
     # Try adding RAM bar
     try:
         ram_info = psutil.virtual_memory()
         ram_label_text = f"RAM"
-        label = ttk.Label(usage_scrollable_frame.scrollable_frame, text=ram_label_text, anchor='w', style="usage.TLabel")
+        label = tk.Label(usage_scrollable_frame.scrollable_frame,text=ram_label_text,anchor='w',font=font_loader.get_font(size=font_size),bg=style_out['bg_color'],fg=style_out['fg_color'])
         label.grid(row=row, column=2 * col, pady=5, padx=5, sticky='w')
         ram_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
         ram_bar.grid(row=row, column=2 * col + 1, pady=5, padx=5, sticky='ew')
@@ -457,7 +680,7 @@ def setup_usage_panel(horizontal_container, btn_col):
         if gpus:
             gpu = gpus[0]
             vram_label_text = f"VRAM"
-            label = ttk.Label(usage_scrollable_frame.scrollable_frame, text=vram_label_text, anchor='w', style="usage.TLabel")
+            label = tk.Label(usage_scrollable_frame.scrollable_frame,text=vram_label_text,anchor='w',font=font_loader.get_font(size=font_size),bg=style_out['bg_color'],fg=style_out['fg_color'])
             label.grid(row=row, column=2 * col, pady=5, padx=5, sticky='w')
             vram_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
             vram_bar.grid(row=row, column=2 * col + 1, pady=5, padx=5, sticky='ew')
@@ -467,7 +690,7 @@ def setup_usage_panel(horizontal_container, btn_col):
             row += 1
 
             gpu_label_text = f"GPU"
-            label = ttk.Label(usage_scrollable_frame.scrollable_frame, text=gpu_label_text, anchor='w', style="usage.TLabel")
+            label = tk.Label(usage_scrollable_frame.scrollable_frame,text=gpu_label_text,anchor='w',font=font_loader.get_font(size=font_size),bg=style_out['bg_color'],fg=style_out['fg_color'])
             label.grid(row=row, column=2 * col, pady=5, padx=5, sticky='w')
             gpu_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
             gpu_bar.grid(row=row, column=2 * col + 1, pady=5, padx=5, sticky='ew')
@@ -487,7 +710,8 @@ def setup_usage_panel(horizontal_container, btn_col):
             if row > 0 and row % max_elements_per_column == 0:
                 col += 1
                 row = 0
-            label = ttk.Label(usage_scrollable_frame.scrollable_frame, text=f"Core {core+1}", anchor='w', style="usage.TLabel")
+
+            label = tk.Label(usage_scrollable_frame.scrollable_frame,text=f"C{core+1}",anchor='w',font=font_loader.get_font(size=font_size),bg=style_out['bg_color'],fg=style_out['fg_color'])
             label.grid(row=row, column=2 * col, pady=2, padx=5, sticky='w')
             bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
             bar.grid(row=row, column=2 * col + 1, pady=2, padx=5, sticky='ew')
@@ -524,17 +748,15 @@ def initiate_abort():
 
     thread_control = {"run_thread": None, "stop_requested": False}
 
-
 def start_process(q=None, fig_queue=None, settings_type='mask'):
     global thread_control, vars_dict, parent_frame
     from .settings import check_settings, expected_types
-    from .gui_utils import run_function_gui
+    from .gui_utils import run_function_gui, set_high_priority, set_cpu_affinity, initialize_cuda
 
     if q is None:
         q = Queue()
     if fig_queue is None:
         fig_queue = Queue()
-
     try:
         settings = check_settings(vars_dict, expected_types, q)
     except ValueError as e:
@@ -547,21 +769,32 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
     stop_requested = Value('i', 0)
     thread_control["stop_requested"] = stop_requested
 
+    # Initialize CUDA in the main process
+    initialize_cuda()
+
     process_args = (settings_type, settings, q, fig_queue, stop_requested)
-    if settings_type in [
-        'mask', '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'
-    ]:
-        thread_control["run_thread"] = Process(target=run_function_gui, args=process_args)
+    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']:
+
+        # Start the process
+        process = Process(target=run_function_gui, args=process_args)
+        process.start()
+
+        # Set high priority for the process
+        #set_high_priority(process)
+
+        # Set CPU affinity if necessary
+        set_cpu_affinity(process)
+
+        # Store the process in thread_control for future reference
+        thread_control["run_thread"] = process
     else:
         q.put(f"Error: Unknown settings type '{settings_type}'")
         return
-    thread_control["run_thread"].start()
 
 def process_console_queue():
-    global q, console_output, parent_frame, progress_bar
+    global q, console_output, parent_frame, progress_bar, process_console_queue
 
     # Initialize function attribute if it doesn't exist
     if not hasattr(process_console_queue, "completed_tasks"):
@@ -574,21 +807,21 @@ def process_console_queue():
     while not q.empty():
         message = q.get_nowait()
         clean_message = ansi_escape_pattern.sub('', message)
-        console_output.insert(tk.END, clean_message + "\n")
-        console_output.see(tk.END)
+        #console_output.insert(tk.END, clean_message + "\n")
+        #console_output.see(tk.END)
         
         # Check if the message contains progress information
         if clean_message.startswith("Progress:"):
             try:
                 # Extract the progress information
-                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*)(.*)', clean_message)
+                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*),(.*)', clean_message)
 
                 if match:
                     current_progress = int(match.group(1))
                     total_progress = int(match.group(2))
                     operation_type = match.group(3).strip()
-                    time_info = match.group(4).strip()
-
+                    additional_info = match.group(4).strip()  # Capture everything after operation_type
+                    
                     # Check if the maximum value has changed
                     if process_console_queue.current_maximum != total_progress:
                         process_console_queue.current_maximum = total_progress
@@ -599,55 +832,75 @@ def process_console_queue():
                     
                     # Calculate the unique progress count
                     unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
-                    
+
                     # Update the progress bar
                     if progress_bar:
                         progress_bar['maximum'] = total_progress
                         progress_bar['value'] = unique_progress_count
 
-                    # Extract and update additional information
+                    # Store operation type and additional info
                     if operation_type:
                         progress_bar.operation_type = operation_type
-
-                    time_image_match = re.search(r'Time/image: ([\d.]+) sec', time_info)
-                    if time_image_match:
-                        progress_bar.time_image = float(time_image_match.group(1))
-
-                    time_batch_match = re.search(r'Time/batch: ([\d.]+) sec', time_info)
-                    if time_batch_match:
-                        progress_bar.time_batch = float(time_batch_match.group(1))
-
-                    time_left_match = re.search(r'Time_left: ([\d.]+) min', time_info)
-                    if time_left_match:
-                        progress_bar.time_left = float(time_left_match.group(1))
+                        progress_bar.additional_info = additional_info
 
                     # Update the progress label
                     if progress_bar.progress_label:
                         progress_bar.update_label()
-                        
+
                     # Clear completed tasks when progress is complete
                     if unique_progress_count >= total_progress:
                         process_console_queue.completed_tasks.clear()
 
             except Exception as e:
                 print(f"Error parsing progress message: {e}")
-        #else:
-        #    # Only insert messages that do not start with "Progress:"
-        #    console_output.insert(tk.END, clean_message + "\n")
-        #    console_output.see(tk.END)
+        else:
+            # Only insert messages that do not start with "Progress:"
+            console_output.insert(tk.END, clean_message + "\n")
+            console_output.see(tk.END)
         
-    after_id = console_output.after(1, process_console_queue)
+    after_id = console_output.after(uppdate_frequency, process_console_queue)
     parent_frame.after_tasks.append(after_id)
 
+def main_thread_update_function(root, q, fig_queue, canvas_widget):
+    global uppdate_frequency
+    try:
+        while not q.empty():
+            message = q.get_nowait()
+    except Exception as e:
+        print(f"Error updating GUI canvas: {e}")
+    finally:
+        root.after(uppdate_frequency, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget))
+
 def initiate_root(parent, settings_type='mask'):
-    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar
-    from .gui_utils import main_thread_update_function, setup_frame, set_element_size
-    from .gui import gui_app
+    """
+    Initializes the root window and sets up the GUI components based on the specified settings type.
+
+    Args:
+        parent (tkinter.Tk or tkinter.Toplevel): The parent window for the GUI.
+        settings_type (str, optional): The type of settings to be displayed in the GUI. Defaults to 'mask'.
+
+    Returns:
+        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, index_control, usage_bars
+    
+    from .gui_utils import setup_frame
     from .settings import descriptions
 
+    uppdate_frequency = 500
+
+    # Start tracemalloc and initialize global variables
+    tracemalloc.start()
+
     set_start_method('spawn', force=True)
+    #set_start_method('forkserver', force=True)
     print("Initializing root with settings_type:", settings_type)
 
+    # Initialize global variables
+    figures = deque()
+    figure_index = -1
+
     parent_frame = parent
 
     if not isinstance(parent_frame, (tk.Tk, tk.Toplevel)):
@@ -676,9 +929,9 @@ def initiate_root(parent, settings_type='mask'):
         canvas, canvas_widget = setup_plot_section(vertical_container)
         console_output, _ = setup_console(vertical_container)
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
-        _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col)
+        _, 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, progress_bar, usage_bars)
+        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")
@@ -687,7 +940,7 @@ def initiate_root(parent, settings_type='mask'):
         
         process_console_queue()
         process_fig_queue()
-        after_id = parent_window.after(100, lambda: main_thread_update_function(parent_window, q, fig_queue, canvas_widget))
+        after_id = parent_window.after(uppdate_frequency, lambda: main_thread_update_function(parent_window, q, fig_queue, canvas_widget))
         parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")