spacr 0.1.81__tar.gz → 0.2.0__tar.gz

{spacr-0.1.81/spacr.egg-info → spacr-0.2.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.1.81
+Version: 0.2.0
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.1.81 → spacr-0.2.0}/setup.py

@@ -50,7 +50,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.1.81",
+    version="0.2.0",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",
@@ -58,7 +58,7 @@ setup(
     url="https://github.com/EinarOlafsson/spacr",
     packages=find_packages(exclude=["tests.*", "tests"]),
     include_package_data=True,
-    package_data={'spacr': ['models/cp/*'],},
+    package_data={'spacr': ['resources/models/cp/*', 'resources/icons/*'],},
     install_requires=dependencies,
     entry_points={
         'console_scripts': [

{spacr-0.1.81 → spacr-0.2.0}/spacr/__init__.py

@@ -16,8 +16,8 @@ from . import app_annotate
 from . import gui_utils
 from . import gui_elements
 from . import gui_core
-from . import gui_run
-from . import gui_wrappers
+from . import gui
+from . import gui
 from . import app_make_masks
 from . import app_mask
 from . import app_measure
@@ -40,6 +40,10 @@ __all__ = [
     "deep_spacr",
     "app_annotate",
     "gui_utils",
+    "gui_elements",
+    "gui_core",
+    "gui",
+    "gui",
     "app_make_masks",
     "app_mask",
     "app_measure",

{spacr-0.1.81 → spacr-0.2.0}/spacr/app_annotate.py

@@ -1,15 +1,16 @@
 import tkinter as tk
+from tkinter import ttk
 from .gui import MainApp
+from .gui_elements import set_dark_style
 
 def initiate_annotation_app(parent_frame):
     from .gui_utils import generate_annotate_fields, annotate_app
     # Set up the settings window
     settings_window = tk.Toplevel(parent_frame)
     settings_window.title("Annotation Settings")
-    settings_window.configure(bg='black')  # Set the background color to black
-    
-    # Use the existing function to create the settings UI
-    settings_frame = tk.Frame(settings_window, bg='black')  # Set the background color to black
+    style_out = set_dark_style(ttk.Style())
+    settings_window.configure(bg=style_out['bg_color'])
+    settings_frame = tk.Frame(settings_window, bg=style_out['bg_color'])
     settings_frame.pack(fill=tk.BOTH, expand=True)
     vars_dict = generate_annotate_fields(settings_frame)
     
@@ -41,7 +42,7 @@ def initiate_annotation_app(parent_frame):
         settings_window.destroy()
         annotate_app(parent_frame, settings)
     
-    start_button = tk.Button(settings_window, text="Start Annotation", command=start_annotation_app, bg='black', fg='white')
+    start_button = tk.Button(settings_window, text="Start Annotation", command=start_annotation_app, bg=style_out['bg_color'], fg=style_out['bg_color'])
     start_button.pack(pady=10)
 
 def start_annotate_app():

{spacr-0.1.81 → spacr-0.2.0}/spacr/app_make_masks.py

@@ -3,26 +3,22 @@ from tkinter import ttk
 from .gui import MainApp
 
 def initiate_make_mask_app(parent_frame):
-    from .gui_elements import modify_masks
-    # Set up the settings window
+    from .gui_elements import ModifyMaskApp, set_dark_style
     settings_window = tk.Toplevel(parent_frame)
     settings_window.title("Make Masks Settings")
-    settings_window.configure(bg='black')  # Set the background color to black
-    
-    # Use the existing function to create the settings UI
-    settings_frame = tk.Frame(settings_window, bg='black')  # Set the background color to black
+    style_out = set_dark_style(ttk.Style())
+    settings_window.configure(bg=style_out['bg_color'])
+    settings_frame = tk.Frame(settings_window, bg=style_out['bg_color'])
     settings_frame.pack(fill=tk.BOTH, expand=True)
     
     vars_dict = {
         'folder_path': ttk.Entry(settings_frame),
         'scale_factor': ttk.Entry(settings_frame)
     }
-
-    # Arrange input fields and labels
     row = 0
     for name, entry in vars_dict.items():
         ttk.Label(settings_frame, text=f"{name.replace('_', ' ').capitalize()}:",
-                  background="black", foreground="white").grid(row=row, column=0)
+                  background=style_out['bg_color'], foreground=style_out['fg_color']).grid(row=row, column=0)
         entry.grid(row=row, column=1)
         row += 1
 
@@ -32,15 +28,12 @@ def initiate_make_mask_app(parent_frame):
         try:
             scale_factor = float(vars_dict['scale_factor'].get())
         except ValueError:
-            scale_factor = None  # Handle invalid input gracefully
-
-        # Convert empty strings to None
+            scale_factor = None
         folder_path = folder_path if folder_path != '' else None
-
         settings_window.destroy()
-        modify_masks(parent_frame, folder_path, scale_factor)
+        ModifyMaskApp(parent_frame, folder_path, scale_factor)
     
-    run_button = tk.Button(settings_window, text="Start Make Masks", command=start_make_mask_app, bg='black', fg='white')
+    run_button = tk.Button(settings_window, text="Start Make Masks", command=start_make_mask_app, bg=style_out['bg_color'], fg=style_out['fg_color'])
     run_button.pack(pady=10)
 
 def start_make_mask_app():

{spacr-0.1.81 → spacr-0.2.0}/spacr/core.py

@@ -1738,7 +1738,7 @@ def preprocess_generate_masks(src, settings={}):
         if os.path.exists(os.path.join(src,'measurements')):
             _pivot_counts_table(db_path=os.path.join(src,'measurements', 'measurements.db'))
 
-        #Concatinate stack with masks
+        #Concatenate stack with masks
         _load_and_concatenate_arrays(src, settings['channels'], settings['cell_channel'], settings['nucleus_channel'], settings['pathogen_channel'])
         
         if settings['plot']:

spacr-0.2.0/spacr/gui.py

@@ -0,0 +1,157 @@
+import tkinter as tk
+from tkinter import ttk
+from PIL import Image, ImageTk, ImageDraw
+import os
+from multiprocessing import set_start_method
+from .gui_elements import spacrButton, create_menu_bar, set_dark_style
+from .gui_core import initiate_root
+
+class MainApp(tk.Tk):
+    def __init__(self, default_app=None):
+        super().__init__()
+        width = self.winfo_screenwidth()
+        height = self.winfo_screenheight()
+        self.geometry(f"{width}x{height}")
+        self.title("SpaCr GUI Collection")
+        self.configure(bg='#333333')  # Set window background to dark gray
+
+        # Initialize style and apply dark style to the main window
+        style = ttk.Style()
+        self.color_settings = set_dark_style(style, parent_frame=self)
+        self.main_buttons = {}  # Initialize main_buttons dictionary here
+        self.additional_buttons = {}  # Initialize additional_buttons dictionary here
+
+        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"),
+            "Classify": (lambda frame: initiate_root(frame, 'classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object 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.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, 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)
+        self.content_frame.grid(row=0, column=0, sticky="nsew")
+
+        # Center the content frame within the canvas
+        self.canvas.create_window((self.winfo_screenwidth() // 2, self.winfo_screenheight() // 2), window=self.content_frame, anchor="center")
+
+        # 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 frames for the grids
+        main_buttons_frame = tk.Frame(self.content_frame)
+        main_buttons_frame.pack(pady=10)
+        set_dark_style(ttk.Style(), containers=[main_buttons_frame])
+
+        additional_buttons_frame = tk.Frame(self.content_frame)
+        additional_buttons_frame.pack(pady=10)
+        set_dark_style(ttk.Style(), containers=[additional_buttons_frame])
+
+        # Create a frame for the description below the icon grids
+        description_frame = tk.Frame(self.content_frame, height=70)  # Increased height to 70
+        description_frame.pack(fill=tk.X, pady=10)
+        description_frame.pack_propagate(False)  # Prevent the frame from resizing based on its content
+        set_dark_style(ttk.Style(), containers=[description_frame])
+
+        # Use a Label widget to display descriptions
+        self.description_label = tk.Label(description_frame, text="", wraplength=800, justify="center", font=('Helvetica', 12), fg=self.color_settings['fg_color'], bg=self.color_settings['bg_color'])
+        self.description_label.pack(fill=tk.BOTH, pady=10)
+
+        # Load the logo image and place it in the main apps row
+        logo_button = spacrButton(main_buttons_frame, text="SpaCr", command=lambda: self.load_app("logo_spacr", initiate_root), icon_name="logo_spacr", size=100, show_text=False)
+        logo_button.grid(row=0, column=0, padx=5, pady=5)
+        self.main_buttons[logo_button] = "SpaCr: An advanced application suite for cellpose masks, measurements, annotations, and more."
+
+        # Create icon buttons for the main apps
+        for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
+            app_func, app_desc = app_data
+            button = spacrButton(main_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=100, show_text=False)
+            button.grid(row=0, column=i + 1, padx=5, pady=5)
+            self.main_buttons[button] = app_desc
+
+        # Create icon buttons for the additional apps
+        for i, (app_name, app_data) in enumerate(self.additional_gui_apps.items()):
+            app_func, app_desc = app_data
+            button = spacrButton(additional_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=75, show_text=False)
+            button.grid(row=0, column=i, padx=5, pady=5)  # Ensure all icons are in a single row
+            self.additional_buttons[button] = app_desc
+
+        # Update description initially
+        self.update_description()
+
+    def update_description(self):
+        # Check all buttons and update description if any has the active color
+        for button, desc in {**self.main_buttons, **self.additional_buttons}.items():
+            if button.canvas.itemcget(button.button_bg, "fill") == self.color_settings['active_color']:
+                self.show_description(desc)
+                return
+        self.clear_description()
+
+    def show_description(self, description):
+        if self.description_label.winfo_exists():
+            self.description_label.config(text=description)
+            self.description_label.update_idletasks()  # Ensure the label updates immediately
+
+    def clear_description(self):
+        if self.description_label.winfo_exists():
+            self.description_label.config(text="")
+            self.description_label.update_idletasks()  # Ensure the label updates immediately
+
+    def load_app(self, app_name, app_func):
+        # Clear the current content frame
+        self.clear_frame(self.canvas)
+
+        # Initialize the selected app
+        app_frame = tk.Frame(self.canvas)
+        app_frame.pack(fill=tk.BOTH, expand=True)
+        set_dark_style(ttk.Style(), containers=[app_frame])
+        app_func(app_frame)
+
+    def clear_frame(self, frame):
+        for widget in frame.winfo_children():
+            widget.destroy()
+
+def gui_app():
+    app = MainApp()
+    app.mainloop()
+
+if __name__ == "__main__":
+    set_start_method('spawn', force=True)
+    gui_app()

{spacr-0.1.81 → spacr-0.2.0}/spacr/gui_core.py

@@ -17,7 +17,7 @@ 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 create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
+from .gui_elements import spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
 
 # Define global variables
 q = None
@@ -231,25 +231,43 @@ def import_settings(settings_type='mask'):
     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]'),
-        'cell_mask_dim': ('combo', ['0', '1', '2', '3', '4', '5', '6', '7', '8', None], None),
-        'nucleus_mask_dim': ('combo', ['0', '1', '2', '3', '4', '5', '6', '7', '8', None], None),
-        'pathogen_mask_dim': ('combo', ['0', '1', '2', '3', '4', '5', '6', '7', '8', None], None),
-        #'crop_mode': ('combo', ['cell', 'nucleus', 'pathogen', '[cell, nucleus, pathogen]', '[cell,nucleus, pathogen]'], ['cell']),
+        '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', [0, 1, 2, 3, None], None),
-        'cell_channel': ('combo', [0, 1, 2, 3, None], None),
-        'pathogen_channel': ('combo', [0, 1, 2, 3, None], None),
+        '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', ['resnet50', 'other_model'], 'resnet50'),
+        '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():
@@ -271,17 +289,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 descriptions, 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 .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)
@@ -310,24 +327,18 @@ def setup_settings_panel(vertical_container, settings_type='mask', window_dimens
         settings = get_perform_regression_default_settings(settings={})
     elif settings_type == 'recruitment':
         settings = get_analyze_recruitment_default_settings(settings={})
-    #elif settings_type == 'simulation':
-    #    settings = set_default_
-    #elif settings_type == 'cellpose_dataset':
-    #    settings = set_default_
-    #elif settings_type == 'plaques':
-    #    settings = set_default_
-    #elif settings_type == 'cellpose_compare':
-    #    settings = set_default_
-    #elif settings_type == 'vision_scores':
-    #    settings = set_default_
-    #elif settings_type == 'vision_dataset':
-    #    settings = set_default_
     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
 
@@ -335,45 +346,58 @@ 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
+    style_out = set_dark_style(ttk.Style())
+
+    figure.patch.set_facecolor(style_out['bg_color'])
+    plot.set_facecolor(style_out['bg_color'])
+    containers = [plot_frame]
+    widgets = [canvas_widget]
+    style = ttk.Style(vertical_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
     return canvas, canvas_widget
 
 def setup_console(vertical_container):
     global console_output
-    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():
@@ -459,60 +483,78 @@ 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="settings", 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_frame.grid_columnconfigure(0, weight=1)  # Make the column stretch
-    description_label = tk.Label(description_frame, text="Module Description", bg='black', fg='white', anchor='nw', justify='left', wraplength=width-50)
-    description_label.grid(row=0, column=0, pady=50, padx=20, sticky='nsew')  # Use sticky='nsew' to stretch the label
+    description_frame.grid_columnconfigure(0, weight=1)
+    description_frame.grid_rowconfigure(0, weight=1)  # Add this line to make the row expandable
+
+    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
+    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_frame, button_scrollable_frame, description_frame, description_label
 
 def hide_all_settings(vars_dict, categories):
     """
@@ -561,7 +603,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:
@@ -569,12 +610,12 @@ 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)]
     category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
-    category_dropdown.grid(row=1, column=3, sticky="ew", pady=2, padx=2)
+    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():
@@ -627,24 +668,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'):