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

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/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/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/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/gui.py

@@ -1,7 +1,7 @@
 import tkinter as tk
 from tkinter import ttk
-from PIL import Image, ImageTk
-import os, requests
+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
@@ -13,10 +13,13 @@ class MainApp(tk.Tk):
         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."),
@@ -58,7 +61,10 @@ class MainApp(tk.Tk):
 
         # Create a frame inside the canvas to hold the main content
         self.content_frame = tk.Frame(self.canvas)
-        self.content_frame.pack(fill=tk.BOTH, expand=True)
+        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])
@@ -69,119 +75,75 @@ class MainApp(tk.Tk):
     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)
-        logo_frame.pack(pady=20, expand=True)
-        set_dark_style(ttk.Style(), containers=[logo_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])
 
-        # Load the logo image
-        if not self.load_logo(logo_frame):
-            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])
+        # Create a frame for the description below the icon grids
+        description_frame = tk.Frame(self.content_frame, height=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])
 
-        # Add SpaCr text below the logo with padding for sharper text
-        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])
+        # 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)
 
-        # Create a frame for the buttons and descriptions
-        buttons_frame = tk.Frame(self.content_frame)
-        buttons_frame.pack(pady=10, expand=True, padx=10)
-        set_dark_style(ttk.Style(), containers=[buttons_frame])
+        # 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 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, 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)
-        # Ensure descriptions expand as needed
-        buttons_frame.grid_columnconfigure(1, weight=1)
-
-    def load_logo(self, frame):
-        def download_image(url, save_path):
-            try:
-                response = requests.get(url, stream=True)
-                response.raise_for_status()  # Raise an HTTPError for bad responses
-                with open(save_path, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                return True
-            except requests.exceptions.RequestException as e:
-                print(f"Failed to download image from {url}: {e}")
-                return False
-
-        try:
-            img_path = os.path.join(os.path.dirname(__file__), 'logo_spacr.png')
-            logo_image = Image.open(img_path)
-        except (FileNotFoundError, Image.UnidentifiedImageError):
-            print(f"File {img_path} not found or is not a valid image. Attempting to download from GitHub.")
-            if download_image('https://raw.githubusercontent.com/EinarOlafsson/spacr/main/spacr/logo_spacr.png', img_path):
-                try:
-                    print(f"Downloaded file size: {os.path.getsize(img_path)} bytes")
-                    logo_image = Image.open(img_path)
-                except Image.UnidentifiedImageError as e:
-                    print(f"Downloaded file is not a valid image: {e}")
-                    return False
-            else:
-                return False
-        except Exception as e:
-            print(f"An error occurred while loading the logo: {e}")
-            return False
-        try:
-            screen_height = frame.winfo_screenheight()
-            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)
-            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}")
-            return False
+        # 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)
+            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.content_frame)
+        self.clear_frame(self.canvas)
 
         # Initialize the selected app
-        app_frame = tk.Frame(self.content_frame)
+        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 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_2.py

@@ -1,160 +1,157 @@
 import tkinter as tk
 from tkinter import ttk
-from tkinter import font as tkFont
-from PIL import Image, ImageTk
+from PIL import Image, ImageTk, ImageDraw
 import os
-import requests
-
-# Import your GUI apps
-from .gui_mask_app import initiate_mask_root
-from .gui_measure_app import initiate_measure_root
-from .annotate_app import initiate_annotation_app_root
-from .mask_app import initiate_mask_app_root
-from .gui_classify_app import initiate_classify_root
-
-from .gui_utils import CustomButton, style_text_boxes
+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):
+    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.geometry("1100x1500")
-        self.configure(bg="black")
-        #self.attributes('-fullscreen', True)
+        self.configure(bg='#333333')  # Set window background to dark gray
 
+        # Initialize style and apply dark style to the main window
         style = ttk.Style()
-        style_text_boxes(style)
-
-        self.gui_apps = {
-            "Mask": (initiate_mask_root, "Generate cellpose masks for cells, nuclei and pathogen images."),
-            "Measure": (initiate_measure_root, "Measure single object intensity and morphological feature. Crop and save single object image"),
-            "Annotate": (initiate_annotation_app_root, "Annotation single object images on a grid. Annotations are saved to database."),
-            "Make Masks": (initiate_mask_app_root, "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
-            "Classify": (initiate_classify_root, "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images.")
+        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_menu_bar(self)
+
         # Create a canvas to hold the selected app and other elements
-        self.canvas = tk.Canvas(self, bg="black", highlightthickness=0, width=4000, height=4000)
+        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.pack(fill=tk.BOTH, expand=True)
-        # Create startup screen with buttons for each GUI app
+        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 a frame for the logo and description
-        logo_frame = tk.Frame(self.content_frame, bg="black")
-        logo_frame.pack(pady=20, expand=True)
+        # 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])
 
-        # 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)
+        additional_buttons_frame = tk.Frame(self.content_frame)
+        additional_buttons_frame.pack(pady=10)
+        set_dark_style(ttk.Style(), containers=[additional_buttons_frame])
 
-        # 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)
+        # Create a frame for the description below the icon grids
+        description_frame = tk.Frame(self.content_frame, height=50)
+        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])
 
-        # Create a frame for the buttons and descriptions
-        buttons_frame = tk.Frame(self.content_frame, bg="black")
-        buttons_frame.pack(pady=10, expand=True, padx=10)
+        # 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)
 
-        for i, (app_name, app_data) in enumerate(self.gui_apps.items()):
-            app_func, app_desc = app_data
-
-            # Create custom button with text
-            button = CustomButton(buttons_frame, text=app_name, command=lambda app_name=app_name: 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.grid(row=i, column=1, pady=10, padx=10, sticky="w")
-
-        # Ensure buttons have a fixed width
-        buttons_frame.grid_columnconfigure(0, minsize=150)
-        # Ensure descriptions expand as needed
-        buttons_frame.grid_columnconfigure(1, weight=1)
-
-    def load_logo(self, frame):
-        def download_image(url, save_path):
-            try:
-                response = requests.get(url, stream=True)
-                response.raise_for_status()  # Raise an HTTPError for bad responses
-                with open(save_path, 'wb') as f:
-                    for chunk in response.iter_content(chunk_size=8192):
-                        f.write(chunk)
-                return True
-            except requests.exceptions.RequestException as e:
-                print(f"Failed to download image from {url}: {e}")
-                return False
-
-        try:
-            img_path = os.path.join(os.path.dirname(__file__), 'logo_spacr.png')
-            print(f"Trying to load logo from {img_path}")
-            logo_image = Image.open(img_path)
-        except (FileNotFoundError, Image.UnidentifiedImageError):
-            print(f"File {img_path} not found or is not a valid image. Attempting to download from GitHub.")
-            if download_image('https://raw.githubusercontent.com/EinarOlafsson/spacr/main/spacr/logo_spacr.png', img_path):
-                try:
-                    print(f"Downloaded file size: {os.path.getsize(img_path)} bytes")
-                    logo_image = Image.open(img_path)
-                except Image.UnidentifiedImageError as e:
-                    print(f"Downloaded file is not a valid image: {e}")
-                    return False
-            else:
-                return False
-        except Exception as e:
-            print(f"An error occurred while loading the logo: {e}")
-            return False
-        try:
-            logo_image = logo_image.resize((800, 800), Image.Resampling.LANCZOS)
-            logo_photo = ImageTk.PhotoImage(logo_image)
-            logo_label = tk.Label(frame, image=logo_photo, bg="black")
-            logo_label.image = logo_photo  # Keep a reference to avoid garbage collection
-            logo_label.pack()
-            return True
-        except Exception as e:
-            print(f"An error occurred while processing the logo image: {e}")
-            return False
-
-    def load_app_v1(self, app_name):
-        selected_app_func, _ = self.gui_apps[app_name]
-        self.clear_frame(self.content_frame)
-
-        app_frame = tk.Frame(self.content_frame, bg="black")
-        app_frame.pack(fill=tk.BOTH, expand=True)
-        selected_app_func(app_frame)
+        # 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."
 
-    def load_app(root, app_name, app_func):
-        if hasattr(root, 'current_app_id'):
-            root.after_cancel(root.current_app_id)
-        root.current_app_id = None
+        # 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)
+            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
-        for widget in root.content_frame.winfo_children():
-            widget.destroy()
+        self.clear_frame(self.canvas)
 
         # Initialize the selected app
-        app_frame = tk.Frame(root.content_frame, bg="black")
+        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__":
-    gui_app()
+    set_start_method('spawn', force=True)
+    gui_app()