spacr 0.1.77__py3-none-any.whl → 0.1.85__py3-none-any.whl

spacr/gui.py

@@ -11,72 +11,112 @@ class MainApp(tk.Tk):
         super().__init__()
         width = self.winfo_screenwidth()
         height = self.winfo_screenheight()
-        self.geometry(f"{width}x{height}")  
+        self.geometry(f"{width}x{height}")
         self.title("SpaCr GUI Collection")
-        self.configure(bg="black")
+
+        # Initialize style and apply dark style to the main window
         style = ttk.Style()
-        set_dark_style(style)
+        self.color_settings = set_dark_style(style, parent_frame=self)
 
-        self.gui_apps = {
+        self.main_gui_apps = {
             "Mask": (lambda frame: initiate_root(frame, 'mask'), "Generate cellpose masks for cells, nuclei and pathogen images."),
             "Measure": (lambda frame: initiate_root(frame, 'measure'), "Measure single object intensity and morphological feature. Crop and save single object image"),
             "Annotate": (lambda frame: initiate_root(frame, 'annotate'), "Annotation single object images on a grid. Annotations are saved to database."),
-            "Make Masks": (lambda frame: initiate_root(frame, 'make_masks'),"Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
+            "Make Masks": (lambda frame: initiate_root(frame, 'make_masks'), "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
             "Classify": (lambda frame: initiate_root(frame, 'classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images."),
-            "Sequencing": (lambda frame: initiate_root(frame, 'sequencing'), "Analyze sequensing data."),
-            "Umap": (lambda frame: initiate_root(frame, 'umap'), "Generate UMAP embedings with datapoints represented as images.")
+        }
+
+        self.additional_gui_apps = {
+            "Sequencing": (lambda frame: initiate_root(frame, 'sequencing'), "Analyze sequencing data."),
+            "Umap": (lambda frame: initiate_root(frame, 'umap'), "Generate UMAP embeddings with datapoints represented as images."),
+            "Train Cellpose": (lambda frame: initiate_root(frame, 'train_cellpose'), "Train custom Cellpose models."),
+            "ML Analyze": (lambda frame: initiate_root(frame, 'ml_analyze'), "Machine learning analysis of data."),
+            "Cellpose Masks": (lambda frame: initiate_root(frame, 'cellpose_masks'), "Generate Cellpose masks."),
+            "Cellpose All": (lambda frame: initiate_root(frame, 'cellpose_all'), "Run Cellpose on all images."),
+            "Map Barcodes": (lambda frame: initiate_root(frame, 'map_barcodes'), "Map barcodes to data."),
+            "Regression": (lambda frame: initiate_root(frame, 'regression'), "Perform regression analysis."),
+            "Recruitment": (lambda frame: initiate_root(frame, 'recruitment'), "Analyze recruitment data.")
         }
 
         self.selected_app = tk.StringVar()
         self.create_widgets()
 
-        if default_app in self.gui_apps:
-            self.load_app(default_app, self.gui_apps[default_app][0])
+        if default_app in self.main_gui_apps:
+            self.load_app(default_app, self.main_gui_apps[default_app][0])
+        elif default_app in self.additional_gui_apps:
+            self.load_app(default_app, self.additional_gui_apps[default_app][0])
 
     def create_widgets(self):
         # Create the menu bar
         create_menu_bar(self)
 
         # Create a canvas to hold the selected app and other elements
-        self.canvas = tk.Canvas(self, bg="black", highlightthickness=0)
+        self.canvas = tk.Canvas(self, highlightthickness=0)
         self.canvas.grid(row=0, column=0, sticky="nsew")
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
         # Create a frame inside the canvas to hold the main content
-        self.content_frame = tk.Frame(self.canvas, bg="black")
+        self.content_frame = tk.Frame(self.canvas)
         self.content_frame.pack(fill=tk.BOTH, expand=True)
 
-        # Create startup screen with buttons for each GUI app
+        # Apply dark style to canvas and content_frame
+        set_dark_style(ttk.Style(), containers=[self.canvas, self.content_frame])
+
+        # Create startup screen with buttons for each main GUI app and drop-down for additional apps
         self.create_startup_screen()
 
     def create_startup_screen(self):
         self.clear_frame(self.content_frame)
 
         # Create a frame for the logo and description
-        logo_frame = tk.Frame(self.content_frame, bg="black")
+        logo_frame = tk.Frame(self.content_frame)
         logo_frame.pack(pady=20, expand=True)
+        set_dark_style(ttk.Style(), containers=[logo_frame])
 
         # Load the logo image
         if not self.load_logo(logo_frame):
-            tk.Label(logo_frame, text="Logo not found", bg="black", fg="white", font=('Helvetica', 24)).pack(padx=10, pady=10)
+            logo_not_found = tk.Label(logo_frame, text="Logo not found", font=('Helvetica', 24))
+            logo_not_found.pack(padx=10, pady=10)
+            set_dark_style(ttk.Style(), widgets=[logo_not_found])
 
         # Add SpaCr text below the logo with padding for sharper text
-        tk.Label(logo_frame, text="SpaCr", bg="black", fg="#008080", font=('Helvetica', 24)).pack(padx=10, pady=10)
+        spacr_label = tk.Label(logo_frame, text="SpaCr", fg=self.color_settings['active_color'], font=('Helvetica', 24))
+        spacr_label.pack(padx=10, pady=10)
+        set_dark_style(ttk.Style(), widgets=[spacr_label])
 
         # Create a frame for the buttons and descriptions
-        buttons_frame = tk.Frame(self.content_frame, bg="black")
+        buttons_frame = tk.Frame(self.content_frame)
         buttons_frame.pack(pady=10, expand=True, padx=10)
+        set_dark_style(ttk.Style(), containers=[buttons_frame])
 
-        for i, (app_name, app_data) in enumerate(self.gui_apps.items()):
+        for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
             app_func, app_desc = app_data
 
             # Create custom button with text
             button = spacrButton(buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), font=('Helvetica', 12))
             button.grid(row=i, column=0, pady=10, padx=10, sticky="w")
 
-            description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Helvetica', 12))
+            description_label = tk.Label(buttons_frame, text=app_desc, wraplength=800, justify="left", font=('Helvetica', 12))
             description_label.grid(row=i, column=1, pady=10, padx=10, sticky="w")
+            set_dark_style(ttk.Style(), widgets=[description_label])
+
+        # Add drop-down menu for additional apps
+        dropdown_frame = tk.Frame(buttons_frame)
+        dropdown_frame.grid(row=len(self.main_gui_apps), column=0, columnspan=2, pady=20)
+        set_dark_style(ttk.Style(), containers=[dropdown_frame])
+
+        additional_apps_label = tk.Label(dropdown_frame, text="Additional Apps", font=('Helvetica', 12))
+        additional_apps_label.pack(side=tk.LEFT, padx=5)
+        set_dark_style(ttk.Style(), widgets=[additional_apps_label])
+
+        self.additional_apps_var = tk.StringVar(value="Select an app")
+        dropdown = ttk.Combobox(dropdown_frame, textvariable=self.additional_apps_var, values=list(self.additional_gui_apps.keys()))
+        dropdown.pack(side=tk.LEFT, padx=5)
+        set_dark_style(ttk.Style(), widgets=[dropdown])
+
+        load_button = spacrButton(dropdown_frame, text="Load", command=self.load_additional_app, font=('Helvetica', 12))
+        load_button.pack(side=tk.LEFT, padx=5)
 
         # Ensure buttons have a fixed width
         buttons_frame.grid_columnconfigure(0, minsize=150)
@@ -118,9 +158,10 @@ class MainApp(tk.Tk):
             new_height = int(screen_height // 4)
             logo_image = logo_image.resize((new_height, new_height), Image.Resampling.LANCZOS)
             logo_photo = ImageTk.PhotoImage(logo_image)
-            logo_label = tk.Label(frame, image=logo_photo, bg="black")
+            logo_label = tk.Label(frame, image=logo_photo)
             logo_label.image = logo_photo  # Keep a reference to avoid garbage collection
             logo_label.pack()
+            set_dark_style(ttk.Style(), widgets=[logo_label])
             return True
         except Exception as e:
             print(f"An error occurred while processing the logo image: {e}")
@@ -131,10 +172,16 @@ class MainApp(tk.Tk):
         self.clear_frame(self.content_frame)
 
         # Initialize the selected app
-        app_frame = tk.Frame(self.content_frame, bg="black")
+        app_frame = tk.Frame(self.content_frame)
         app_frame.pack(fill=tk.BOTH, expand=True)
+        set_dark_style(ttk.Style(), containers=[app_frame])
         app_func(app_frame)
 
+    def load_additional_app(self):
+        selected_app = self.additional_apps_var.get()
+        if selected_app in self.additional_gui_apps:
+            self.load_app(selected_app, self.additional_gui_apps[selected_app][0])
+
     def clear_frame(self, frame):
         for widget in frame.winfo_children():
             widget.destroy()

spacr/gui_core.py

@@ -1,27 +1,24 @@
-import os, traceback, ctypes, matplotlib, requests, csv
+import os, traceback, ctypes, matplotlib, requests, csv, matplotlib, time, requests
+import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
-from multiprocessing import Process, Value, Queue
+from multiprocessing import Process, Value, Queue, set_start_method
 from multiprocessing.sharedctypes import Synchronized
-from multiprocessing import set_start_method
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-import time
-import requests
 from huggingface_hub import list_repo_files
 
-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 create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
-from . gui_run import run_mask_gui, run_measure_gui, run_classify_gui, run_sequencing_gui, run_umap_gui
-
 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 spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
+
 # Define global variables
 q = None
 console_output = None
@@ -44,26 +41,116 @@ def initiate_abort():
         thread_control["run_thread"].join()
         thread_control["run_thread"] = None
 
-def start_process_v1(q, fig_queue, settings_type='mask'):
-    global thread_control, vars_dict
-    from .settings import check_settings, expected_types
+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)
 
-    settings = check_settings(vars_dict, expected_types, q)
-    if thread_control.get("run_thread") is not None:
-        initiate_abort()
-    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
-    thread_control["stop_requested"] = stop_requested
+def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imports=1):
+
+    """
+    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.
+    """
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = lambda: spacrFigShow(fig_queue)
+
+    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)    
+    
     if settings_type == 'mask':
-        thread_control["run_thread"] = Process(target=run_mask_gui, args=(settings, q, fig_queue, stop_requested))
+        function = preprocess_generate_masks
+        imports = 2
     elif settings_type == 'measure':
-        thread_control["run_thread"] = Process(target=run_measure_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'classify':
-        thread_control["run_thread"] = Process(target=run_classify_gui, args=(settings, q, fig_queue, stop_requested))
+        function = measure_crop
+        imports = 1
+    elif settings_type == 'simulation':
+        function = run_multiple_simulations
+        imports = 1
     elif settings_type == 'sequencing':
-        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'umap':
-        thread_control["run_thread"] = Process(target=run_umap_gui, args=(settings, q, fig_queue, stop_requested))
-    thread_control["run_thread"].start()
+        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
+    #elif settings_type == 'cellpose_dataset':
+    #    function = generate_cellpose_train_test
+    #    imports = 1
+    #elif settings_type == 'plaques':
+    #    function = analyze_plaques
+    #    imports = 1
+    #elif settings_type == 'cellpose_compare':
+    #    function = compare_cellpose_masks
+    #    imports = 1
+    #elif settings_type == 'vision_scores':
+    #    function = apply_model_to_tar
+    #    imports = 1
+    #elif settings_type == 'vision_dataset':
+    #    function = generate_dataset
+    #    imports = 1
+    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
 
 def start_process(q=None, fig_queue=None, settings_type='mask'):
     global thread_control, vars_dict
@@ -83,25 +170,15 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
     if thread_control.get("run_thread") is not None:
         initiate_abort()
     
-    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
+    stop_requested = Value('i', 0)
     thread_control["stop_requested"] = stop_requested
 
-    process_args = (settings, q, fig_queue, stop_requested)
-
-    if settings_type == 'mask':
-        thread_control["run_thread"] = Process(target=run_mask_gui, args=process_args)
-    elif settings_type == 'measure':
-        thread_control["run_thread"] = Process(target=run_measure_gui, args=process_args)
-    elif settings_type == 'classify':
-        thread_control["run_thread"] = Process(target=run_classify_gui, args=process_args)
-    elif settings_type == 'sequencing':
-        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=process_args)
-    elif settings_type == 'umap':
-        thread_control["run_thread"] = Process(target=run_umap_gui, args=process_args)
+    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 import_settings(settings_type='mask'):
@@ -194,17 +271,16 @@ def convert_settings_dict_for_gui(settings):
 
 def setup_settings_panel(vertical_container, settings_type='mask', window_dimensions=[500, 1000]):
     global vars_dict, scrollable_frame
-    from .settings import 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, descriptions
+    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
 
-    width = (window_dimensions[0])//6
+    width = (window_dimensions[0]) // 6
     height = window_dimensions[1]
 
-    # Settings Frame
-    settings_frame = tk.Frame(vertical_container, bg='black', height=height, width=width)
+    settings_frame = tk.Frame(vertical_container)
     vertical_container.add(settings_frame, stretch="always")
-    settings_label = spacrLabel(settings_frame, text="Settings", background="black", foreground="white", anchor='center', justify='center', align="center")
+    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, bg='black', width=width)
+    scrollable_frame = spacrFrame(settings_frame)
     scrollable_frame.grid(row=1, column=0, sticky="nsew")
     settings_frame.grid_rowconfigure(1, weight=1)
     settings_frame.grid_columnconfigure(0, weight=1)
@@ -219,11 +295,32 @@ def setup_settings_panel(vertical_container, settings_type='mask', window_dimens
         settings = get_analyze_reads_default_settings(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
+    elif settings_type == 'train_cellpose':
+        settings = get_train_cellpose_default_settings(settings={})
+    elif settings_type == 'ml_analyze':
+        settings = set_default_analyze_screen(settings={})
+    elif settings_type == 'cellpose_masks':
+        settings = get_identify_masks_finetune_default_settings(settings={})
+    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={})
+    elif settings_type == 'regression':
+        settings = get_perform_regression_default_settings(settings={})
+    elif settings_type == 'recruitment':
+        settings = get_analyze_recruitment_default_settings(settings={})
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
 
     variables = convert_settings_dict_for_gui(settings)
     vars_dict = generate_fields(variables, scrollable_frame)
+    
+    containers = [settings_frame]
+    widgets = [settings_label, scrollable_frame]
+
+    style = ttk.Style(vertical_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
+
     print("Settings panel setup complete")
     return scrollable_frame, vars_dict
 
@@ -231,45 +328,57 @@ def setup_plot_section(vertical_container):
     global canvas, canvas_widget
     plot_frame = tk.PanedWindow(vertical_container, orient=tk.VERTICAL)
     vertical_container.add(plot_frame, stretch="always")
-    figure = Figure(figsize=(30, 4), dpi=100, facecolor='black')
+    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', background='black', highlightthickness=0)
+    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
     canvas_widget = canvas.get_tk_widget()
     plot_frame.add(canvas_widget, stretch="always")
     canvas.draw()
     canvas.figure = figure
+    # Set the figure and axes background to black
+    figure.patch.set_facecolor('black')
+    plot.set_facecolor('black')
+    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
-    print("Setting up console frame")
-    console_frame = tk.Frame(vertical_container, bg='black')
+    console_frame = tk.Frame(vertical_container)
     vertical_container.add(console_frame, stretch="always")
-    console_label = spacrLabel(console_frame, text="Console", background="black", foreground="white", anchor='center', justify='center', align="center")
+    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, bg='black', fg='white', insertbackground='white')
+    console_output = scrolledtext.ScrolledText(console_frame, height=10)
     console_output.grid(row=1, column=0, sticky="nsew")
     console_frame.grid_rowconfigure(1, weight=1)
     console_frame.grid_columnconfigure(0, weight=1)
-    print("Console setup complete")
+    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 setup_progress_frame(vertical_container):
     global progress_output
-    progress_frame = tk.Frame(vertical_container, bg='black')
+    progress_frame = tk.Frame(vertical_container)
     vertical_container.add(progress_frame, stretch="always")
-    label_frame = tk.Frame(progress_frame, bg='black')
+    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%", background="black", foreground="white", font=('Helvetica', 12), anchor='w', justify='left', align="left")
+    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, bg='black', fg='white', insertbackground='white')
+    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)
-    print("Progress frame setup complete")
+    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 download_hug_dataset():
@@ -355,59 +464,70 @@ def download_dataset(repo_id, subfolder, local_dir=None, retries=5, delay=5):
 
     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):
+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
     from .settings import descriptions
 
-    width = (window_dimensions[0])//8
+    width = (window_dimensions[0]) // 8
     height = window_dimensions[1]
 
-    button_frame = tk.Frame(horizontal_container, bg='black', height=height, width=width)
+    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", background="black", foreground="white", font=('Helvetica', 12), anchor='center', justify='center', align="center")
+    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, bg='black')
+    button_scrollable_frame = spacrFrame(button_frame)
     button_scrollable_frame.grid(row=1, column=0, sticky="nsew")
 
+    widgets = [categories_label, button_scrollable_frame.scrollable_frame]
+
     btn_col = 0
     btn_row = 1
-    
+
     if run:
-        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue, settings_type), font=('Helvetica', 12))
+        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue, settings_type))
         run_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
+        widgets.append(run_button)
         btn_row += 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, font=('Helvetica', 12))
+        abort_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Abort", command=initiate_abort)
         abort_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
+        widgets.append(abort_button)
         btn_row += 1
 
     if download and settings_type in ['mask']:
-        download_dataset_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Download", command=download_hug_dataset, font=('Helvetica', 12))
+        download_dataset_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Download", command=download_hug_dataset)
         download_dataset_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
+        widgets.append(download_dataset_button)
         btn_row += 1
 
     if import_btn:
-        import_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Import", command=lambda: import_settings(settings_type), font=('Helvetica', 12))
+        import_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Import", command=lambda: import_settings(settings_type))
         import_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
+        widgets.append(import_button)
 
-    # Call toggle_settings after vars_dict is initialized
     if vars_dict is not None:
         toggle_settings(button_scrollable_frame)
 
-    # Description frame
-    description_frame = tk.Frame(horizontal_container, bg='black', height=height, width=width)
+    description_frame = tk.Frame(horizontal_container)
     horizontal_container.add(description_frame, stretch="always", sticky="nsew")
-    description_label = tk.Label(description_frame, text="Module Description", bg='black', fg='white', anchor='nw', justify='left', wraplength=width//2-100)
-    description_label.pack(pady=10, padx=10)
+    description_frame.grid_columnconfigure(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)
 
-    return button_scrollable_frame
+    containers = [button_frame, description_frame]
+    widgets.extend([description_label])
+
+    style = ttk.Style(horizontal_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
+
+    return button_frame, button_scrollable_frame, description_frame, description_label
 
 def hide_all_settings(vars_dict, categories):
     """
@@ -456,7 +576,6 @@ def toggle_settings(button_scrollable_frame):
     def on_category_select(selected_category):
         if selected_category == "Select Category":
             return
-        #print(f"Selected category: {selected_category}")
         if selected_category in categories:
             toggle_category(categories[selected_category])
             if selected_category in active_categories:
@@ -464,7 +583,7 @@ def toggle_settings(button_scrollable_frame):
             else:
                 active_categories.add(selected_category)
         category_dropdown.update_styles(active_categories)
-        category_var.set("Select Category")  # Reset dropdown text to "Select Category"
+        category_var.set("Select Category")
 
     category_var = tk.StringVar()
     non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
@@ -522,24 +641,29 @@ def set_globals(q_var, console_output_var, parent_frame_var, vars_dict_var, canv
     progress_label = progress_label_var
     fig_queue = fig_queue_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)
-    set_dark_style(style)
+    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)
-    parent_frame.configure(bg='black')
-    parent_frame.grid_rowconfigure(0, weight=1)
-    parent_frame.grid_columnconfigure(0, weight=1)
-    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, bg='black')
+    
     vertical_container.grid(row=0, column=0, sticky=tk.NSEW)
-    horizontal_container = tk.PanedWindow(vertical_container, orient=tk.HORIZONTAL, bg='black')
     vertical_container.add(horizontal_container, stretch="always")
     horizontal_container.grid_columnconfigure(0, weight=1)
     horizontal_container.grid_columnconfigure(1, weight=1)
-    settings_frame = tk.Frame(horizontal_container, bg='black')
     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'):