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

spacr/gui_core.py

@@ -1,23 +1,23 @@
-import os, traceback, ctypes, matplotlib, requests, csv, matplotlib, time, requests, re
-import matplotlib.pyplot as plt
-matplotlib.use('Agg')
+import traceback, ctypes, csv, re, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
-from multiprocessing import Process, Value, Queue, set_start_method
-from multiprocessing.sharedctypes import Synchronized
+from multiprocessing import Process, Value, Queue, set_start_method, Manager
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-from huggingface_hub import list_repo_files
 import numpy as np
+import psutil
+import GPUtil
+import tkinter.font as tkFont
+
 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, set_default_font
+from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style
 
 # Define global variables
 q = None
@@ -32,143 +32,96 @@ fig_queue = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
-def initiate_abort():
-    global thread_control
-    if isinstance(thread_control.get("stop_requested"), Synchronized):
-        thread_control["stop_requested"].value = 1
-    if thread_control.get("run_thread") is not None:
-        thread_control["run_thread"].terminate()
-        thread_control["run_thread"].join()
-        thread_control["run_thread"] = None
-
-def spacrFigShow(fig_queue=None):
-    """
-    Replacement for plt.show() that queues figures instead of displaying them.
-    """
-    fig = plt.gcf()
-    if fig_queue:
-        fig_queue.put(fig)
-    else:
-        fig.show()
-    plt.close(fig)
+def toggle_settings(button_scrollable_frame):
+    global vars_dict
+    from .settings import categories
+    from .gui_utils import hide_all_settings
+    if vars_dict is None:
+        raise ValueError("vars_dict is not initialized.")
 
-def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imports=1):
+    active_categories = set()
 
-    """
-    Wraps the run_multiple_simulations function to integrate with GUI processes.
-    
-    Parameters:
-    - settings: dict, The settings for the run_multiple_simulations function.
-    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
-    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
-    """
+    def toggle_category(settings):
+        for setting in settings:
+            if setting in vars_dict:
+                label, widget, _, frame = vars_dict[setting]
+                if widget.grid_info():
+                    label.grid_remove()
+                    widget.grid_remove()
+                    frame.grid_remove()
+                else:
+                    label.grid()
+                    widget.grid()
+                    frame.grid()
 
-    # Temporarily override plt.show
-    original_show = plt.show
-    plt.show = lambda: spacrFigShow(fig_queue)
+    def on_category_select(selected_category):
+        if selected_category == "Select Category":
+            return
+        if selected_category in categories:
+            toggle_category(categories[selected_category])
+            if selected_category in active_categories:
+                active_categories.remove(selected_category)
+            else:
+                active_categories.add(selected_category)
+        category_dropdown.update_styles(active_categories)
+        category_var.set("Select Category")
 
-    try:
-        if imports == 1:
-            function(settings=settings)
-        elif imports == 2:
-            function(src=settings['src'], settings=settings)
-    except Exception as e:
-        # Send the error message to the GUI via the queue
-        errorMessage = f"Error during processing: {e}"
-        q.put(errorMessage) 
-        traceback.print_exc()
-    finally:
-        # Restore the original plt.show function
-        plt.show = original_show
-
-def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
-    from .gui_utils import process_stdout_stderr
-    from .core import preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
-    from .io import generate_cellpose_train_test
-    from .measure import measure_crop
-    from .sim import run_multiple_simulations
-    from .deep_spacr import train_test_model
-    from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
-    process_stdout_stderr(q)
-
-    print(f'run_function_gui settings_type: {settings_type}') 
-    
-    if settings_type == 'mask':
-        function = preprocess_generate_masks
-        imports = 2
-    elif settings_type == 'measure':
-        function = measure_crop
-        imports = 1
-    elif settings_type == 'simulation':
-        function = run_multiple_simulations
-        imports = 1
-    elif settings_type == 'sequencing':
-        function = analyze_reads
-        imports = 1
-    elif settings_type == 'classify':
-        function = train_test_model
-        imports = 2
-    elif settings_type == 'train_cellpose':
-        function = train_cellpose
-        imports = 1
-    elif settings_type == 'ml_analyze':
-        function = generate_ml_scores
-        imports = 2
-    elif settings_type == 'cellpose_masks':
-        function = identify_masks_finetune
-        imports = 1
-    elif settings_type == 'cellpose_all':
-        function = check_cellpose_models
-        imports = 1
-    elif settings_type == 'map_barcodes':
-        function = map_barcodes_folder
-        imports = 2
-    elif settings_type == 'regression':
-        function = perform_regression
-        imports = 2
-    elif settings_type == 'recruitment':
-        function = analyze_recruitment
-        imports = 2
-    else:
-        raise ValueError(f"Invalid settings type: {settings_type}")
-    try:
-        function_gui_wrapper(function, settings, q, fig_queue, imports)
-    except Exception as e:
-        q.put(f"Error during processing: {e}")
-        traceback.print_exc()
-    finally:
-        stop_requested.value = 1
+    category_var = tk.StringVar()
+    non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
+    category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
+    category_dropdown.grid(row=0, column=4, sticky="ew", pady=2, padx=2)
+    vars_dict = hide_all_settings(vars_dict, categories)
 
-def start_process(q=None, fig_queue=None, settings_type='mask'):
-    global thread_control, vars_dict
-    from .settings import check_settings, expected_types
+def process_fig_queue():
+    global canvas, fig_queue, canvas_widget, parent_frame
 
-    if q is None:
-        q = Queue()
-    if fig_queue is None:
-        fig_queue = Queue()
+    def clear_canvas(canvas):
+        for ax in canvas.figure.get_axes():
+            ax.clear()
+        canvas.draw_idle()
 
     try:
-        settings = check_settings(vars_dict, expected_types, q)
-    except ValueError as e:
-        q.put(f"Error: {e}")
-        return
+        while not fig_queue.empty():
+            time.sleep(1)
+            clear_canvas(canvas)
+            fig = fig_queue.get_nowait()
 
-    if thread_control.get("run_thread") is not None:
-        initiate_abort()
-    
-    stop_requested = Value('i', 0)
-    thread_control["stop_requested"] = stop_requested
+            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
 
-    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)
-    else:
-        q.put(f"Error: Unknown settings type '{settings_type}'")
-        return
-    thread_control["run_thread"].start()
+            # 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')
+
+            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()
+    except Exception as e:
+        traceback.print_exc()
+    finally:
+        after_id = canvas_widget.after(1, 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
+    thread_control = thread_control_var
+    q = q_var
+    console_output = console_output_var
+    parent_frame = parent_frame_var
+    vars_dict = vars_dict_var
+    canvas = canvas_var
+    canvas_widget = canvas_widget_var
+    scrollable_frame = scrollable_frame_var
+    fig_queue = fig_queue_var
+    progress_bar = progress_bar_var
+    usage_bars = usage_bars_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
 
@@ -217,74 +170,23 @@ def import_settings(settings_type='mask'):
     vars_dict = generate_fields(new_settings, scrollable_frame)
     vars_dict = hide_all_settings(vars_dict, categories=None)
 
-def convert_settings_dict_for_gui(settings):
-    from torchvision import models as torch_models
-    torchvision_models = [name for name, obj in torch_models.__dict__.items() if callable(obj)]
-    chans = ['0', '1', '2', '3', '4', '5', '6', '7', '8', None]
-    chans_v2 = [0, 1, 2, 3, None]
-    variables = {}
-    special_cases = {
-        'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
-        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
-        'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
-        'cell_mask_dim': ('combo', chans, None),
-        'cell_chann_dim': ('combo', chans, None),
-        'nucleus_mask_dim': ('combo', chans, None),
-        'nucleus_chann_dim': ('combo', chans, None),
-        'pathogen_mask_dim': ('combo', chans, None),
-        'pathogen_chann_dim': ('combo', chans, None),
-        'crop_mode': ('combo', ['cell', 'nucleus', 'pathogen', '[cell, nucleus, pathogen]', '[cell,nucleus, pathogen]'], ['cell']),
-        'magnification': ('combo', [20, 40, 60], 20),
-        'nucleus_channel': ('combo', chans_v2, None),
-        'cell_channel': ('combo', chans_v2, None),
-        'channel_of_interest': ('combo', chans_v2, None),
-        'pathogen_channel': ('combo', chans_v2, None),
-        'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
-        'train_mode': ('combo', ['erm', 'irm'], 'erm'),
-        'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),
-        'reduction_method': ('combo', ['umap', 'tsne'], 'umap'),
-        'model_name': ('combo', ['cyto', 'cyto_2', 'cyto_3', 'nuclei'], 'cyto'),
-        'regression_type': ('combo', ['ols','gls','wls','rlm','glm','mixed','quantile','logit','probit','poisson','lasso','ridge'], 'ols'),
-        'timelapse_objects': ('combo', ['cell', 'nucleus', 'pathogen', 'cytoplasm', None], None),
-        'model_type': ('combo', torchvision_models, 'resnet50'),
-        'optimizer_type': ('combo', ['adamw', 'adam'], 'adamw'),
-        'schedule': ('combo', ['reduce_lr_on_plateau', 'step_lr'], 'reduce_lr_on_plateau'),
-        'loss_type': ('combo', ['focal_loss', 'binary_cross_entropy_with_logits'], 'focal_loss'),
-        'normalize_by': ('combo', ['fov', 'png'], 'png'),
-        'agg_type': ('combo', ['mean', 'median'], 'mean'),
-        'grouping': ('combo', ['mean', 'median'], 'mean'),
-        'min_max': ('combo', ['allq', 'all'], 'allq'),
-        'transform': ('combo', ['log', 'sqrt', 'square', None], None)
-    }
-
-    for key, value in settings.items():
-        if key in special_cases:
-            variables[key] = special_cases[key]
-        elif isinstance(value, bool):
-            variables[key] = ('check', None, value)
-        elif isinstance(value, int) or isinstance(value, float):
-            variables[key] = ('entry', None, value)
-        elif isinstance(value, str):
-            variables[key] = ('entry', None, value)
-        elif value is None:
-            variables[key] = ('entry', None, value)
-        elif isinstance(value, list):
-            variables[key] = ('entry', None, str(value))
-        else:
-            variables[key] = ('entry', None, str(value))
-    return variables
-
-def setup_settings_panel(vertical_container, settings_type='mask', window_dimensions=[500, 1000]):
+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
+
+    size_dict = set_element_size()
+    settings_width = size_dict['settings_width']
+
+    # Create a PanedWindow for the settings panel
+    settings_paned_window = tk.PanedWindow(vertical_container, orient=tk.HORIZONTAL, width=size_dict['settings_width'])
+    vertical_container.add(settings_paned_window, stretch="always")
 
-    width = (window_dimensions[0]) // 6
-    height = window_dimensions[1]
+    settings_frame = tk.Frame(settings_paned_window, width=settings_width)
+    settings_frame.pack_propagate(False)  # Prevent the frame from resizing based on its children
+
+    settings_paned_window.add(settings_frame)
 
-    settings_frame = tk.Frame(vertical_container)
-    vertical_container.add(settings_frame, stretch="always")
-    settings_label = spacrLabel(settings_frame, text="Settings", anchor='center', justify='center', align="center")
-    settings_label.grid(row=0, column=0, pady=10, padx=10)
     scrollable_frame = spacrFrame(settings_frame)
     scrollable_frame.grid(row=1, column=0, sticky="nsew")
     settings_frame.grid_rowconfigure(1, weight=1)
@@ -321,7 +223,7 @@ def setup_settings_panel(vertical_container, settings_type='mask', window_dimens
     vars_dict = generate_fields(variables, scrollable_frame)
     
     containers = [settings_frame]
-    widgets = [settings_label, scrollable_frame]
+    widgets = [scrollable_frame]
 
     style = ttk.Style(vertical_container)
     _ = set_dark_style(style, containers=containers, widgets=widgets)
@@ -331,8 +233,12 @@ def setup_settings_panel(vertical_container, settings_type='mask', window_dimens
 
 def setup_plot_section(vertical_container):
     global canvas, canvas_widget
-    plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL)
+
+    # 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.
@@ -340,7 +246,11 @@ def setup_plot_section(vertical_container):
     canvas = FigureCanvasTkAgg(figure, master=plot_frame)
     canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
-    plot_frame.add(canvas_widget, stretch="always")
+    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())
@@ -351,23 +261,46 @@ 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):
     global console_output
-    console_frame = tk.Frame(vertical_container)
+    from .gui_elements import set_dark_style
+
+    # Apply dark style and get style output
+    style = ttk.Style()
+    style_out = set_dark_style(style)
+
+    # Create a frame for the console section
+    console_frame = tk.Frame(vertical_container, bg=style_out['bg_color'])
     vertical_container.add(console_frame, stretch="always")
-    console_label = spacrLabel(console_frame, text="Console", anchor='center', justify='center', align="center")
-    console_label.grid(row=0, column=0, pady=10, padx=10)
-    console_output = scrolledtext.ScrolledText(console_frame, height=10)
-    console_output.grid(row=1, column=0, sticky="nsew")
+
+    # Create a thicker frame at the top for the hover effect
+    top_border = tk.Frame(console_frame, height=5, bg=style_out['bg_color'])
+    top_border.grid(row=0, column=0, sticky="ew", pady=(0, 2))
+
+    # 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)
+    console_output.grid(row=1, column=0, sticky="nsew")  # Use grid for console_output
+
+    # Configure the grid to allow expansion
     console_frame.grid_rowconfigure(1, weight=1)
     console_frame.grid_columnconfigure(0, weight=1)
-    containers = [console_frame]
-    widgets = [console_label, console_output]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    return console_output
+
+    def on_enter(event):
+        top_border.config(bg=style_out['active_color'])
+
+    def on_leave(event):
+        top_border.config(bg=style_out['bg_color'])
+
+    console_output.bind("<Enter>", on_enter)
+    console_output.bind("<Leave>", on_leave)
+
+    return console_output, console_frame
 
 def setup_progress_frame(vertical_container):
     global progress_output
@@ -387,278 +320,257 @@ def setup_progress_frame(vertical_container):
     _ = set_dark_style(style, containers=containers, widgets=widgets)
     return progress_output
 
-def download_hug_dataset():
-    global vars_dict, q
-    dataset_repo_id = "einarolafsson/toxo_mito"
-    settings_repo_id = "einarolafsson/spacr_settings"
-    dataset_subfolder = "plate1"
-    local_dir = os.path.join(os.path.expanduser("~"), "datasets")  # Set to the home directory
-
-    # Download the dataset
-    try:
-        dataset_path = download_dataset(dataset_repo_id, dataset_subfolder, local_dir)
-        if 'src' in vars_dict:
-            vars_dict['src'][2].set(dataset_path)
-            q.put(f"Set source path to: {vars_dict['src'][2].get()}\n")
-        q.put(f"Dataset downloaded to: {dataset_path}\n")
-    except Exception as e:
-        q.put(f"Failed to download dataset: {e}\n")
-
-    # Download the settings files
-    try:
-        settings_path = download_dataset(settings_repo_id, "", local_dir)
-        q.put(f"Settings downloaded to: {settings_path}\n")
-    except Exception as e:
-        q.put(f"Failed to download settings: {e}\n")
-
-def download_dataset(repo_id, subfolder, local_dir=None, retries=5, delay=5):
-    global q
-    """
-    Downloads a dataset or settings files from Hugging Face and returns the local path.
-
-    Args:
-        repo_id (str): The repository ID (e.g., 'einarolafsson/toxo_mito' or 'einarolafsson/spacr_settings').
-        subfolder (str): The subfolder path within the repository (e.g., 'plate1' or the settings subfolder).
-        local_dir (str): The local directory where the files will be saved. Defaults to the user's home directory.
-        retries (int): Number of retry attempts in case of failure.
-        delay (int): Delay in seconds between retries.
-
-    Returns:
-        str: The local path to the downloaded files.
-    """
-    if local_dir is None:
-        local_dir = os.path.join(os.path.expanduser("~"), "datasets")
-
-    local_subfolder_dir = os.path.join(local_dir, subfolder if subfolder else "settings")
-    if not os.path.exists(local_subfolder_dir):
-        os.makedirs(local_subfolder_dir)
-    elif len(os.listdir(local_subfolder_dir)) > 0:
-        q.put(f"Files already downloaded to: {local_subfolder_dir}")
-        return local_subfolder_dir
-
-    attempt = 0
-    while attempt < retries:
-        try:
-            files = list_repo_files(repo_id, repo_type="dataset")
-            subfolder_files = [file for file in files if file.startswith(subfolder) or (subfolder == "" and file.endswith('.csv'))]
-
-            for file_name in subfolder_files:
-                for download_attempt in range(retries):
-                    try:
-                        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{file_name}?download=true"
-                        response = requests.get(url, stream=True)
-                        response.raise_for_status()
-
-                        local_file_path = os.path.join(local_subfolder_dir, os.path.basename(file_name))
-                        with open(local_file_path, 'wb') as file:
-                            for chunk in response.iter_content(chunk_size=8192):
-                                file.write(chunk)
-                        q.put(f"Downloaded file: {file_name}")
-                        break
-                    except (requests.HTTPError, requests.Timeout) as e:
-                        q.put(f"Error downloading {file_name}: {e}. Retrying in {delay} seconds...")
-                        time.sleep(delay)
-                else:
-                    raise Exception(f"Failed to download {file_name} after multiple attempts.")
-
-            return local_subfolder_dir
-
-        except (requests.HTTPError, requests.Timeout) as e:
-            q.put(f"Error downloading files: {e}. Retrying in {delay} seconds...")
-            attempt += 1
-            time.sleep(delay)
-
-    raise Exception("Failed to download files after multiple attempts.")
-
-def setup_button_section(horizontal_container, settings_type='mask', window_dimensions=[500, 1000], run=True, abort=True, download=True, import_btn=True):
-    global button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
-    from .settings import descriptions
+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
 
-    width = (window_dimensions[0]) // 8
-    height = window_dimensions[1]
+    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)
 
-    button_frame = tk.Frame(horizontal_container)
     horizontal_container.add(button_frame, stretch="always", sticky="nsew")
-    button_frame.grid_rowconfigure(0, weight=0)
-    button_frame.grid_rowconfigure(1, weight=1)
-    button_frame.grid_columnconfigure(0, weight=1)
-
-    categories_label = spacrLabel(button_frame, text="Categories", anchor='center', justify='center', align="center")
-    categories_label.grid(row=0, column=0, pady=10, padx=10)
-    button_scrollable_frame = spacrFrame(button_frame)
+    button_scrollable_frame = spacrFrame(button_frame, scrollbar=False)
     button_scrollable_frame.grid(row=1, column=0, sticky="nsew")
-
-    widgets = [categories_label, button_scrollable_frame.scrollable_frame]
+    widgets = [button_scrollable_frame.scrollable_frame]
 
     btn_col = 0
-    btn_row = 1
+    btn_row = 0
 
     if run:
-        print(f'settings_type: {settings_type}')
-        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="run", command=lambda: start_process(q, fig_queue, settings_type))
+        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="run", command=lambda: start_process(q, fig_queue, settings_type), show_text=False, size=size_dict['btn_size'], animation=False)
         run_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(run_button)
-        btn_row += 1
+        btn_col += 1
 
     if abort and settings_type in ['mask', 'measure', 'classify', 'sequencing', 'umap']:
-        abort_button = spacrButton(button_scrollable_frame.scrollable_frame, text="abort", command=initiate_abort)
+        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)
-        btn_row += 1
+        btn_col += 1
 
     if download and settings_type in ['mask']:
-        download_dataset_button = spacrButton(button_scrollable_frame.scrollable_frame, text="download", command=download_hug_dataset)
+        download_dataset_button = spacrButton(button_scrollable_frame.scrollable_frame, text="download", command=lambda: download_hug_dataset(q, vars_dict), show_text=False, size=size_dict['btn_size'], animation=False)
         download_dataset_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(download_dataset_button)
-        btn_row += 1
+        btn_col += 1
 
     if import_btn:
-        import_button = spacrButton(button_scrollable_frame.scrollable_frame, text="settings", command=lambda: import_settings(settings_type))
+        import_button = spacrButton(button_scrollable_frame.scrollable_frame, text="settings", command=lambda: import_settings(settings_type), show_text=False, size=size_dict['btn_size'], animation=False)
         import_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(import_button)
         btn_row += 1
 
+    # Add the progress bar under the settings category menu
     progress_bar = spacrProgressBar(button_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate')
-    progress_bar.grid(row=0, column=0, columnspan=2, pady=5, padx=5, sticky='ew')
+    progress_bar.grid(row=btn_row, column=0, columnspan=6, pady=5, padx=5, sticky='ew')
+    progress_bar.set_label_position()  # Set the label position after grid placement
     widgets.append(progress_bar)
 
     if vars_dict is not None:
         toggle_settings(button_scrollable_frame)
 
-    description_frame = tk.Frame(horizontal_container)
-    horizontal_container.add(description_frame, stretch="always", sticky="nsew")
-    description_frame.grid_columnconfigure(0, weight=1)
-    description_frame.grid_rowconfigure(0, weight=1)
-
-    description_label = tk.Label(description_frame, text="Module Description", anchor='nw', justify='left', wraplength=width - 50)
-    description_label.grid(row=0, column=0, pady=50, padx=20, sticky='nsew')
-    description_text = descriptions.get(settings_type, "No description available for this module.")
-    description_label.config(text=description_text)
-
-    def update_wraplength(event):
-        new_width = event.width - 40  # Adjust as needed
-        description_label.config(wraplength=new_width)
-
-    description_label.bind('<Configure>', update_wraplength)
-
-    containers = [button_frame, description_frame]
-    widgets.extend([description_label])
-
     style = ttk.Style(horizontal_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-
-    return button_scrollable_frame
-
-
-def hide_all_settings(vars_dict, categories):
-    """
-    Function to initially hide all settings in the GUI.
-
-    Parameters:
-    - categories: dict, The categories of settings with their corresponding settings.
-    - vars_dict: dict, The dictionary containing the settings and their corresponding widgets.
-    """
-
-    if categories is None:
-        from .settings import categories
+    _ = set_dark_style(style, containers=[button_frame], widgets=widgets)
+
+    return button_scrollable_frame, btn_col
+
+def setup_usage_panel(horizontal_container, btn_col):
+    global usage_bars
+    from .gui_utils import set_element_size
+    from .gui_elements import set_dark_style
+
+    usg_col = 1
+
+    def update_usage(ram_bar, vram_bar, gpu_bar, usage_bars, parent_frame):
+        # Update RAM usage
+        ram_usage = psutil.virtual_memory().percent
+        ram_bar['value'] = ram_usage
+
+        # Update GPU and VRAM usage
+        gpus = GPUtil.getGPUs()
+        if gpus:
+            gpu = gpus[0]
+            vram_usage = gpu.memoryUtil * 100
+            gpu_usage = gpu.load * 100
+            vram_bar['value'] = vram_usage
+            gpu_bar['value'] = gpu_usage
+
+        # Update CPU usage for each core
+        cpu_percentages = psutil.cpu_percent(percpu=True)
+        for bar, usage in zip(usage_bars[3:], cpu_percentages):
+            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)
+
+    size_dict = set_element_size()
+    usage_panel_height = size_dict['panel_height']
+    usage_frame = tk.Frame(horizontal_container, height=usage_panel_height)
+    horizontal_container.add(usage_frame)
+
+    usage_frame.grid_rowconfigure(0, weight=0)
+    usage_frame.grid_rowconfigure(1, weight=1)
+    usage_frame.grid_columnconfigure(0, weight=1)
+    usage_frame.grid_columnconfigure(1, weight=1)
+
+    usage_scrollable_frame = spacrFrame(usage_frame, scrollbar=False)
+    usage_scrollable_frame.grid(row=1, column=0, sticky="nsew", columnspan=2)
+    widgets = [usage_scrollable_frame.scrollable_frame]
+    
+    usage_bars = []
+    max_elements_per_column = 4
+    row = 0
+    col = 0
 
-    for category, settings in categories.items():
-        if any(setting in vars_dict for setting in settings):
-            vars_dict[category] = (None, None, tk.IntVar(value=0))
-            
-            # Initially hide all settings
-            for setting in settings:
-                if setting in vars_dict:
-                    label, widget, _ = vars_dict[setting]
-                    label.grid_remove()
-                    widget.grid_remove()
-    return vars_dict
+    # Initialize RAM, VRAM, and GPU bars as None
+    ram_bar, vram_bar, gpu_bar = None, None, None
+    
+    # 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'])
+
+    # 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.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')
+        widgets.append(label)
+        widgets.append(ram_bar)
+        usage_bars.append(ram_bar)
+        row += 1
+    except Exception as e:
+        print(f"Could not add RAM usage bar: {e}")
 
-def toggle_settings(button_scrollable_frame):
-    global vars_dict
-    from .settings import categories
+    # Try adding VRAM and GPU usage bars
+    try:
+        gpus = GPUtil.getGPUs()
+        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.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')
+            widgets.append(label)
+            widgets.append(vram_bar)
+            usage_bars.append(vram_bar)
+            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.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')
+            widgets.append(label)
+            widgets.append(gpu_bar)
+            usage_bars.append(gpu_bar)
+            row += 1
+    except Exception as e:
+        print(f"Could not add VRAM or GPU usage bars: {e}")
 
-    if vars_dict is None:
-        raise ValueError("vars_dict is not initialized.")
+    # Add CPU core usage bars
+    try:
+        cpu_cores = psutil.cpu_count(logical=True)
+        cpu_freq = psutil.cpu_freq()
+
+        for core in range(cpu_cores):
+            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.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')
+            widgets.append(label)
+            widgets.append(bar)
+            usage_bars.append(bar)
+            row += 1
+    except Exception as e:
+        print(f"Could not add CPU core usage bars: {e}")
 
-    active_categories = set()
+    style = ttk.Style(horizontal_container)
+    _ = set_dark_style(style, containers=[usage_frame], widgets=widgets)
+
+    if ram_bar is None:
+        ram_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
+    if vram_bar is None:
+        vram_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
+    if gpu_bar is None:
+        gpu_bar = spacrProgressBar(usage_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate', length=size_dict['bar_size'], label=False)
+    
+    update_usage(ram_bar, vram_bar, gpu_bar, usage_bars, usage_frame)    
+    return usage_scrollable_frame, usage_bars, usg_col
 
-    def toggle_category(settings):
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                if widget.grid_info():
-                    label.grid_remove()
-                    widget.grid_remove()
-                else:
-                    label.grid()
-                    widget.grid()
+def initiate_abort():
+    global thread_control, q, parent_frame
+    if thread_control.get("run_thread") is not None:
+        try:
+            q.put("Aborting processes...")
+            thread_control.get("run_thread").terminate()
+            thread_control["run_thread"] = None
+            q.put("Processes aborted.")
+        except Exception as e:
+            q.put(f"Error aborting process: {e}")
 
-    def on_category_select(selected_category):
-        if selected_category == "Select Category":
-            return
-        if selected_category in categories:
-            toggle_category(categories[selected_category])
-            if selected_category in active_categories:
-                active_categories.remove(selected_category)
-            else:
-                active_categories.add(selected_category)
-        category_dropdown.update_styles(active_categories)
-        category_var.set("Select Category")
+    thread_control = {"run_thread": None, "stop_requested": False}
 
-    category_var = tk.StringVar()
-    non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
-    category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
-    category_dropdown.grid(row=5, column=0, 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 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
 
-    def clear_canvas(canvas):
-        for ax in canvas.figure.get_axes():
-            ax.clear()
-        canvas.draw_idle()
+    if q is None:
+        q = Queue()
+    if fig_queue is None:
+        fig_queue = Queue()
 
     try:
-        while not fig_queue.empty():
-            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
-            fig.tight_layout()
-            fig.set_facecolor('black')
-            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()
-    except Exception as e:
-        traceback.print_exc()
-    finally:
-        after_id = canvas_widget.after(100, process_fig_queue)
-        parent_frame.after_tasks.append(after_id)
+        settings = check_settings(vars_dict, expected_types, q)
+    except ValueError as e:
+        q.put(f"Error: {e}")
+        return
 
-def process_console_queue_v1():
-    global q, console_output, parent_frame
-    while not q.empty():
-        message = q.get_nowait()
-        console_output.insert(tk.END, message)
-        console_output.see(tk.END)
-    after_id = console_output.after(100, process_console_queue_v1)
-    parent_frame.after_tasks.append(after_id)
+    if thread_control.get("run_thread") is not None:
+        initiate_abort()
+    
+    stop_requested = Value('i', 0)
+    thread_control["stop_requested"] = stop_requested
+
+    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)
+    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, progress_label
+    global q, console_output, parent_frame, progress_bar
 
     # Initialize function attribute if it doesn't exist
     if not hasattr(process_console_queue, "completed_tasks"):
         process_console_queue.completed_tasks = []
+    if not hasattr(process_console_queue, "current_maximum"):
+        process_console_queue.current_maximum = None
 
     ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
-    
+
     while not q.empty():
         message = q.get_nowait()
         clean_message = ansi_escape_pattern.sub('', message)
@@ -666,17 +578,24 @@ def process_console_queue():
         console_output.see(tk.END)
         
         # Check if the message contains progress information
-        if clean_message.startswith("Progress"):
+        if clean_message.startswith("Progress:"):
             try:
                 # Extract the progress information
-                match = re.search(r'(\d+)/(\d+)', 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()
+
+                    # Check if the maximum value has changed
+                    if process_console_queue.current_maximum != total_progress:
+                        process_console_queue.current_maximum = total_progress
+                        process_console_queue.completed_tasks = []
 
                     # Add the task to the completed set
                     process_console_queue.completed_tasks.append(current_progress)
-                    #print('completed_tasks', process_console_queue.completed_tasks)
                     
                     # Calculate the unique progress count
                     unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
@@ -686,85 +605,64 @@ def process_console_queue():
                         progress_bar['maximum'] = total_progress
                         progress_bar['value'] = unique_progress_count
 
+                    # Extract and update additional information
+                    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))
+
                     # Update the progress label
-                    if progress_label:
-                        progress_label_text = f"Processing: {unique_progress_count}/{total_progress}"
-                        progress_label.config(text=progress_label_text)
+                    if progress_bar.progress_label:
+                        progress_bar.update_label()
                         
                     # Clear completed tasks when progress is complete
-                    if unique_progress_count > total_progress:
+                    if unique_progress_count >= total_progress:
                         process_console_queue.completed_tasks.clear()
+
             except Exception as e:
                 print(f"Error parsing progress message: {e}")
-    
-    after_id = console_output.after(100, process_console_queue)
+        #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)
     parent_frame.after_tasks.append(after_id)
 
-
-def set_globals(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):
-    global q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue, progress_bar
-    q = q_var
-    console_output = console_output_var
-    parent_frame = parent_frame_var
-    vars_dict = vars_dict_var
-    canvas = canvas_var
-    canvas_widget = canvas_widget_var
-    scrollable_frame = scrollable_frame_var
-    fig_queue = fig_queue_var
-    progress_bar = progress_bar_var
-
-def create_containers(parent_frame):
-    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL)
-    horizontal_container = tk.PanedWindow(vertical_container, orient=tk.HORIZONTAL)
-    settings_frame = tk.Frame(horizontal_container)
-    return vertical_container, horizontal_container, settings_frame
-
-def setup_frame(parent_frame):
-    style = ttk.Style(parent_frame)
-    vertical_container, horizontal_container, settings_frame = create_containers(parent_frame)
-    containers = [vertical_container, horizontal_container, settings_frame]
-    
-    set_dark_style(style, parent_frame, containers)
-    set_default_font(parent_frame, font_name="Helvetica", size=8)
-    
-    vertical_container.grid(row=0, column=0, sticky=tk.NSEW)
-    vertical_container.add(horizontal_container, stretch="always")
-    horizontal_container.grid_columnconfigure(0, weight=1)
-    horizontal_container.grid_columnconfigure(1, weight=1)
-    settings_frame.grid_rowconfigure(0, weight=0)
-    settings_frame.grid_rowconfigure(1, weight=1)
-    settings_frame.grid_columnconfigure(0, weight=1)
-    horizontal_container.add(settings_frame, stretch="always", sticky="nsew")
-    
-    return parent_frame, vertical_container, horizontal_container
-
 def initiate_root(parent, settings_type='mask'):
-    global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar
-    from .gui_utils import main_thread_update_function
+    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
+    from .settings import descriptions
+
     set_start_method('spawn', force=True)
     print("Initializing root with settings_type:", settings_type)
 
     parent_frame = parent
-    parent_frame.update_idletasks()
-    frame_width = int(parent_frame.winfo_width())
-    frame_height = int(parent_frame.winfo_height())
-    print(frame_width, frame_height)
-    dims = [frame_width, frame_height]
 
-    if not hasattr(parent_frame, 'after_tasks'):
-        parent_frame.after_tasks = []
+    if not isinstance(parent_frame, (tk.Tk, tk.Toplevel)):
+        parent_window = parent_frame.winfo_toplevel()
+    else:
+        parent_window = parent_frame
 
-    # Clear previous content instead of destroying the root
-    for widget in parent_frame.winfo_children():
-        try:
-            widget.destroy()
-        except tk.TclError as e:
-            print(f"Error destroying widget: {e}")
+    parent_window.update_idletasks()
+
+    if not hasattr(parent_window, 'after_tasks'):
+        parent_window.after_tasks = []
 
     q = Queue()
     fig_queue = Queue()
-    parent_frame, vertical_container, horizontal_container = setup_frame(parent_frame)
+    parent_frame, vertical_container, horizontal_container, settings_container = setup_frame(parent_frame)
 
     if settings_type == 'annotate':
         from .app_annotate import initiate_annotation_app
@@ -773,17 +671,26 @@ def initiate_root(parent, settings_type='mask'):
         from .app_make_masks import initiate_make_mask_app
         initiate_make_mask_app(horizontal_container)
     else:
-        scrollable_frame, vars_dict = setup_settings_panel(horizontal_container, settings_type, window_dimensions=dims)
-        button_scrollable_frame = setup_button_section(horizontal_container, settings_type, window_dimensions=dims)
+        scrollable_frame, vars_dict = setup_settings_panel(settings_container, settings_type)
+        print('setup_settings_panel')
         canvas, canvas_widget = setup_plot_section(vertical_container)
-        console_output = setup_console(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)
 
-        set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, progress_bar)
+        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, progress_bar, usage_bars)
+        description_text = descriptions.get(settings_type, "No description available for this module.")
+        
+        q.put(f"Console")
+        q.put(f" ")
+        q.put(description_text)
+        
         process_console_queue()
         process_fig_queue()
-        after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget))
-        parent_frame.after_tasks.append(after_id)
+        after_id = parent_window.after(100, lambda: main_thread_update_function(parent_window, q, fig_queue, canvas_widget))
+        parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")
     return parent_frame, vars_dict
 
+