spacr 0.2.56__py3-none-any.whl → 0.2.65__py3-none-any.whl

spacr/gui_core.py

@@ -1,4 +1,4 @@
-import traceback, ctypes, csv, re, time
+import traceback, ctypes, csv, re
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
@@ -9,14 +9,17 @@ from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 import numpy as np
 import psutil
 import GPUtil
+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, set_default_generate_barecode_mapping, 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 , set_dark_style
 
 # Define global variables
 q = None
@@ -28,6 +31,12 @@ canvas_widget = None
 scrollable_frame = None
 progress_label = None
 fig_queue = None
+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}
 
@@ -72,41 +81,197 @@ def toggle_settings(button_scrollable_frame):
     vars_dict = hide_all_settings(vars_dict, categories)
 
 def process_fig_queue():
-    global canvas, fig_queue, canvas_widget, parent_frame
-
-    def clear_canvas(canvas):
-        for ax in canvas.figure.get_axes():
-            ax.clear()
-        canvas.draw_idle()
+    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():
-            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
+            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)
+            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(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 display_figure(fig):
+    global canvas, canvas_widget
+
+    from .gui_elements import modify_figure_properties, 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(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()
+
+            # 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()
+
+    # 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
+
+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 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
     thread_control = thread_control_var
     q = q_var
     console_output = console_output_var
@@ -116,13 +281,17 @@ 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
+    fig_memory_limit = fig_memory_limit_var
+    figure_current_memory_usage = figure_current_memory_usage_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, 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
+    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 = {}
@@ -161,6 +330,8 @@ def import_settings(settings_type='mask'):
         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}")
     
@@ -230,27 +401,34 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     return scrollable_frame, vars_dict
 
 def setup_plot_section(vertical_container):
-    global canvas, canvas_widget
+    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, bg='lightgrey')
+    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([], [])  # This creates an empty plot.
+    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")  # Use grid for the canvas 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
+    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'])
@@ -259,7 +437,7 @@ def setup_plot_section(vertical_container):
     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):
@@ -280,7 +458,7 @@ def setup_console(vertical_container):
 
     # Create the scrollable frame (which is a Text widget) with white text
     family = style_out['font_family']
-    font_size = style_out['font_size'] - 2
+    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)
     
@@ -331,9 +509,6 @@ def setup_button_section(horizontal_container, settings_type='mask', run=True, a
     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")
@@ -366,7 +541,7 @@ 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=7, pady=5, padx=5, sticky='ew')
     progress_bar.set_label_position()  # Set the label position after grid placement
@@ -380,7 +555,7 @@ 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_elements import set_dark_style, set_element_size
 
@@ -406,7 +581,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']
@@ -423,7 +598,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
 
@@ -441,7 +616,7 @@ def setup_usage_panel(horizontal_container, btn_col):
     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')
@@ -458,7 +633,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')
@@ -468,7 +643,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')
@@ -488,7 +663,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')
@@ -525,11 +701,10 @@ 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()
@@ -547,21 +722,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', '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'
-    ]:
-        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 +760,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 +785,77 @@ 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
+    """
+    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, fig_memory_limit, figure_current_memory_usage
+    
+    from .gui_utils import setup_frame
     from .settings import descriptions
 
+    uppdate_frequency = 100
+
+    # 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
+    fig_memory_limit = 200 * 1024 * 1024  # 200 MB limit
+    figure_current_memory_usage = 0
+
     parent_frame = parent
 
     if not isinstance(parent_frame, (tk.Tk, tk.Toplevel)):
@@ -676,9 +884,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, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage)
         description_text = descriptions.get(settings_type, "No description available for this module.")
         
         q.put(f"Console")
@@ -687,7 +895,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")