spacr 0.1.85__tar.gz → 0.2.0__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.1.85
+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.85 → spacr-0.2.0}/setup.py

@@ -50,7 +50,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.1.85",
+    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.85 → 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.85 → 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.85 → 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.85 → 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.85 → spacr-0.2.0}/spacr/gui_core.py

@@ -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():
@@ -338,9 +356,10 @@ def setup_plot_section(vertical_container):
     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')
+    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)
@@ -488,25 +507,25 @@ def setup_button_section(horizontal_container, settings_type='mask', window_dime
     btn_row = 1
 
     if run:
-        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="Run", command=lambda: start_process(q, fig_queue, settings_type))
+        run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="run", command=lambda: start_process(q, fig_queue, settings_type))
         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)
+        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)
+        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))
+        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)
 
@@ -516,11 +535,19 @@ def setup_button_section(horizontal_container, settings_type='mask', window_dime
     description_frame = tk.Frame(horizontal_container)
     horizontal_container.add(description_frame, stretch="always", sticky="nsew")
     description_frame.grid_columnconfigure(0, weight=1)
+    description_frame.grid_rowconfigure(0, weight=1)  # 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)
 
+    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])
 
@@ -588,7 +615,7 @@ def toggle_settings(button_scrollable_frame):
     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():

{spacr-0.1.85 → spacr-0.2.0}/spacr/gui_elements.py

@@ -15,17 +15,25 @@ from skimage.draw import polygon, line
 from skimage.transform import resize
 from scipy.ndimage import binary_fill_holes, label
 from tkinter import ttk, scrolledtext
+import platform
 
-def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font_family="Arial", font_size=12, bg_color='black', fg_color='white', active_color='teal', inactive_color='gray'):
+def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font_family="Arial", font_size=12, bg_color='black', fg_color='white', active_color='blue', inactive_color='dark_gray'):
+    
+    if platform.system() == 'Darwin':
+        bg_color = '#313131'
+    else:
+        bg_color = '#000000'
 
     if active_color == 'teal':
         active_color = '#008080'
-    if inactive_color == 'gray':
-        inactive_color = '#555555'
+    if inactive_color == 'dark_gray':
+        inactive_color = '#050505'
     if bg_color == 'black':
         bg_color = '#000000'
     if fg_color == 'white':
         fg_color = '#ffffff'
+    if active_color == 'blue':
+        active_color = '#007BFF'
 
     font_style = tkFont.Font(family=font_family, size=font_size)
     style.configure('TEntry', padding='5 5 5 5', borderwidth=1, relief='solid', fieldbackground=bg_color, foreground=fg_color, font=font_style)
@@ -76,7 +84,7 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
                 menu = widget['menu']
                 menu.configure(bg=bg_color, fg=fg_color, font=(font_family, font_size))
 
-    return {'font_family':font_family, 'font_size':font_size, 'bg_color':bg_color, 'fg_color':fg_color, 'active_color':active_color, 'inactive_color':inactive_color}
+    return {'font_family': font_family, 'font_size': font_size, 'bg_color': bg_color, 'fg_color': fg_color, 'active_color': active_color, 'inactive_color': inactive_color}
 
 def set_default_font(root, font_name="Arial", size=12):
     default_font = (font_name, size)
@@ -116,7 +124,6 @@ class spacrCheckbutton(ttk.Checkbutton):
         style = ttk.Style()
         _ = set_dark_style(style, widgets=[self])
 
-
 class spacrFrame(ttk.Frame):
     def __init__(self, container, width=None, *args, bg='black', **kwargs):
         super().__init__(container, *args, **kwargs)
@@ -189,25 +196,40 @@ class spacrLabel(tk.Frame):
             self.canvas.itemconfig(self.label_text, text=text)
 
 class spacrButton(tk.Frame):
-    def __init__(self, parent, text="", command=None, font=None, *args, **kwargs):
+    def __init__(self, parent, text="", command=None, font=None, icon_name=None, size=50, show_text=True, outline=True, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         
-        self.text = text
+        self.text = text.capitalize()  # Capitalize only the first letter of the text
         self.command = command
-        button_height = 50 
-        button_width = 140
+        self.icon_name = icon_name if icon_name else text.lower()
+        self.size = size
+        self.show_text = show_text
+        self.outline = outline
+
         style_out = set_dark_style(ttk.Style())
 
+        if self.show_text:
+            self.button_width = int(size * 3)
+        else:
+            self.button_width = self.size  # Make the button width equal to the size if show_text is False
+
         # Create the canvas first
-        self.canvas = tk.Canvas(self, width=button_width + 4, height=button_height + 4, highlightthickness=0, bg=style_out['bg_color'])
+        self.canvas = tk.Canvas(self, width=self.button_width + 4, height=self.size + 4, highlightthickness=0, bg=style_out['bg_color'])
         self.canvas.grid(row=0, column=0)
 
         # Apply dark style and get color settings
         color_settings = set_dark_style(ttk.Style(), containers=[self], widgets=[self.canvas])
 
-        self.button_bg = self.create_rounded_rectangle(2, 2, button_width + 2, button_height + 2, radius=20, fill=color_settings['bg_color'], outline=color_settings['fg_color'])
-        self.font_style = font if font else tkFont.Font(family=color_settings['font_family'], size=color_settings['font_size'], weight=tkFont.NORMAL)
-        self.button_text = self.canvas.create_text((button_width + 4) // 2, (button_height + 4) // 2, text=self.text, fill=color_settings['fg_color'], font=self.font_style)
+        if self.outline:
+            self.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=color_settings['bg_color'], outline=color_settings['fg_color'])
+        else:
+            self.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=color_settings['bg_color'], outline=color_settings['bg_color'])
+        
+        self.load_icon()
+        self.font_style = font if font else ("Arial", 12)  # Default font if not provided
+        
+        if self.show_text:
+            self.button_text = self.canvas.create_text(self.size + 10, self.size // 2 + 2, text=self.text, fill=color_settings['fg_color'], font=self.font_style, anchor="w")  # Align text to the left of the specified point
 
         self.bind("<Enter>", self.on_enter)
         self.bind("<Leave>", self.on_leave)
@@ -219,12 +241,42 @@ class spacrButton(tk.Frame):
         self.bg_color = color_settings['bg_color']
         self.active_color = color_settings['active_color']
         self.fg_color = color_settings['fg_color']
+        self.is_zoomed_in = False  # Track zoom state for smooth transitions
+
+    def load_icon(self):
+        icon_path = self.get_icon_path(self.icon_name)
+        try:
+            icon_image = Image.open(icon_path)
+        except (FileNotFoundError, Image.UnidentifiedImageError):
+            try:
+                icon_path = icon_path.replace(' ', '_')
+                icon_image = Image.open(icon_path)
+            except (FileNotFoundError, Image.UnidentifiedImageError):
+                icon_image = Image.open(self.get_icon_path("default"))
+                print(f'Icon not found: {icon_path}. Using default icon instead.')
+
+        initial_size = int(self.size * 0.9)  # Make the initial size slightly smaller
+        self.original_icon_image = icon_image.resize((initial_size, initial_size), Image.Resampling.LANCZOS)
+        self.icon_photo = ImageTk.PhotoImage(self.original_icon_image)
+
+        self.button_icon = self.canvas.create_image(self.size // 2 + 2, self.size // 2 + 2, image=self.icon_photo)
+        self.canvas.image = self.icon_photo  # Keep a reference to avoid garbage collection
+
+    def get_icon_path(self, icon_name):
+        icon_dir = os.path.join(os.path.dirname(__file__), 'resources', 'icons')
+        return os.path.join(icon_dir, f"{icon_name}.png")
 
     def on_enter(self, event=None):
         self.canvas.itemconfig(self.button_bg, fill=self.active_color)
+        self.update_description(event)
+        if not self.is_zoomed_in:
+            self.animate_zoom(1.1)  # Zoom in the icon by 10%
 
     def on_leave(self, event=None):
         self.canvas.itemconfig(self.button_bg, fill=self.bg_color)
+        self.clear_description(event)
+        if self.is_zoomed_in:
+            self.animate_zoom(1.0)  # Reset the icon size
 
     def on_click(self, event=None):
         if self.command:
@@ -232,18 +284,15 @@ class spacrButton(tk.Frame):
 
     def create_rounded_rectangle(self, x1, y1, x2, y2, radius=20, **kwargs):
         points = [
-            x1 + radius, y1,
             x1 + radius, y1,
             x2 - radius, y1,
             x2 - radius, y1,
             x2, y1,
             x2, y1 + radius,
-            x2, y1 + radius,
             x2, y2 - radius,
             x2, y2 - radius,
             x2, y2,
             x2 - radius, y2,
-            x2 - radius, y2,
             x1 + radius, y2,
             x1 + radius, y2,
             x1, y2,
@@ -254,6 +303,46 @@ class spacrButton(tk.Frame):
             x1, y1
         ]
         return self.canvas.create_polygon(points, **kwargs, smooth=True)
+    
+    def update_description(self, event):
+        parent = self.master
+        while parent:
+            if hasattr(parent, 'show_description'):
+                parent.show_description(parent.main_buttons.get(self, "No description available."))
+                return
+            parent = parent.master
+
+    def clear_description(self, event):
+        parent = self.master
+        while parent:
+            if hasattr(parent, 'clear_description'):
+                parent.clear_description()
+                return
+            parent = parent.master
+
+    def animate_zoom(self, target_scale, steps=10, delay=10):
+        current_scale = 1.1 if self.is_zoomed_in else 1.0
+        step_scale = (target_scale - current_scale) / steps
+        self._animate_step(current_scale, step_scale, steps, delay)
+
+    def _animate_step(self, current_scale, step_scale, steps, delay):
+        if steps > 0:
+            new_scale = current_scale + step_scale
+            self.zoom_icon(new_scale)
+            self.after(delay, self._animate_step, new_scale, step_scale, steps - 1, delay)
+        else:
+            self.is_zoomed_in = not self.is_zoomed_in
+
+    def zoom_icon(self, scale_factor):
+        # Resize the original icon image
+        new_size = int(self.size * 0.9 * scale_factor)
+        resized_icon = self.original_icon_image.resize((new_size, new_size), Image.Resampling.LANCZOS)
+        self.icon_photo = ImageTk.PhotoImage(resized_icon)
+
+        # Update the icon on the canvas
+        self.canvas.itemconfig(self.button_icon, image=self.icon_photo)
+        self.canvas.image = self.icon_photo  # Keep a reference to avoid garbage collection
+
 
 class spacrSwitch(ttk.Frame):
     def __init__(self, parent, text="", variable=None, command=None, *args, **kwargs):
@@ -363,7 +452,7 @@ class spacrToolTip:
             self.tooltip_window.destroy()
         self.tooltip_window = None
 
-class modify_masks:
+class ModifyMaskApp:
     def __init__(self, root, folder_path, scale_factor):
         self.root = root
         self.folder_path = folder_path
@@ -1207,7 +1296,7 @@ class modify_masks:
                 self.mask[labeled_mask == i] = 0  # Remove small objects
         self.update_display()
 
-class ImageApp:
+class AnnotateApp:
     def __init__(self, root, db_path, src, image_type=None, channels=None, grid_rows=None, grid_cols=None, image_size=(200, 200), annotation_column='annotate', normalize=False, percentiles=(1,99), measurement=None, threshold=None):
         self.root = root
         self.db_path = db_path
@@ -1471,7 +1560,7 @@ class ImageApp:
                 break
 
             if not self.update_queue.empty():
-                ImageApp.update_html("Do not exit, Updating database...")
+                AnnotateApp.update_html("Do not exit, Updating database...")
                 self.status_label.config(text='Do not exit, Updating database...')
 
                 pending_updates = self.update_queue.get()
@@ -1482,7 +1571,7 @@ class ImageApp:
                         c.execute(f'UPDATE png_list SET {self.annotation_column} = ? WHERE png_path = ?', (new_annotation, path))
                 conn.commit()
 
-                ImageApp.update_html('')
+                AnnotateApp.update_html('')
                 self.status_label.config(text='')
                 self.root.update()
             time.sleep(0.1)

{spacr-0.1.85 → spacr-0.2.0}/spacr/gui_utils.py

@@ -3,7 +3,7 @@ import tkinter as tk
 from tkinter import ttk
 
 from . gui_core import initiate_root
-from .gui_elements import spacrLabel, spacrCheckbutton, ImageApp
+from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
@@ -202,7 +202,7 @@ def annotate(settings):
 
     root = tk.Tk()
     root.geometry(settings['geom'])
-    app = ImageApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
     next_button = tk.Button(root, text="Next", command=app.next_page)
     next_button.grid(row=app.grid_rows, column=app.grid_cols - 1)
     back_button = tk.Button(root, text="Back", command=app.previous_page)
@@ -302,7 +302,7 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     conn.commit()
     conn.close()
 
-    app = ImageApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], grid_rows=settings['rows'], grid_cols=settings['columns'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'])
 
     # Set the canvas background to black
     root.configure(bg='black')

{spacr-0.1.85 → spacr-0.2.0}/spacr/settings.py

@@ -1114,29 +1114,29 @@ categories = {
 }
 
 descriptions = {
-    'mask': "Generate Cellpose masks for Cells, Nuclei, and Pathogens. This module uses: preprocess_generate_masks from spacr.core.\n\nKey Features:\n- Automated Mask Generation: Automatically generate accurate masks for various cellular components using Cellpose, a robust deep learning model for cell segmentation.\n- Versatility: Capable of handling different types of biological samples, including cells, nuclei, and pathogens.\n- Integration: Directly integrates with other modules, providing the foundational masks required for subsequent analysis.",
+    'mask': "Generate Cellpose masks for Cells, Nuclei, and Pathogens. Function: preprocess_generate_masks from spacr.core.\n\nKey Features:\n- Automated Mask Generation: Automatically generate accurate masks for various cellular components using Cellpose, a robust deep learning model for cell segmentation.\n- Versatility: Capable of handling different types of biological samples, including cells, nuclei, and pathogens.\n- Integration: Directly integrates with other modules, providing the foundational masks required for subsequent analysis.",
     
-    'measure': "Capture Measurements from Cells, Nuclei, Pathogens, and Cytoplasm objects. Generate single object PNG images for one or several objects. (Requires masks from the Mask module). This module uses: measure_crop from spacr.measure.\n\nKey Features:\n- Comprehensive Measurement Capture: Obtain detailed measurements for various cellular components, including area, perimeter, intensity, and more.\n- Image Generation: Create high-resolution PNG images of individual objects, facilitating further analysis and visualization.\n- Mask Dependency: Requires accurate masks generated by the Mask module to ensure precise measurements.",
+    'measure': "Capture Measurements from Cells, Nuclei, Pathogens, and Cytoplasm objects. Generate single object PNG images for one or several objects. (Requires masks from the Mask module). Function: measure_crop from spacr.measure.\n\nKey Features:\n- Comprehensive Measurement Capture: Obtain detailed measurements for various cellular components, including area, perimeter, intensity, and more.\n- Image Generation: Create high-resolution PNG images of individual objects, facilitating further analysis and visualization.\n- Mask Dependency: Requires accurate masks generated by the Mask module to ensure precise measurements.",
     
-    'classify': "Train and Test any Torch Computer vision model. (Requires PNG images from the Measure module). This module uses: train_test_model from spacr.deep_spacr.\n\nKey Features:\n- Deep Learning Integration: Train and evaluate state-of-the-art Torch models for various classification tasks.\n- Flexible Training: Supports a wide range of Torch models, allowing customization based on specific research needs.\n- Data Requirement: Requires PNG images generated by the Measure module for training and testing.",
+    'classify': "Train and Test any Torch Computer vision model. (Requires PNG images from the Measure module). Function: train_test_model from spacr.deep_spacr.\n\nKey Features:\n- Deep Learning Integration: Train and evaluate state-of-the-art Torch models for various classification tasks.\n- Flexible Training: Supports a wide range of Torch models, allowing customization based on specific research needs.\n- Data Requirement: Requires PNG images generated by the Measure module for training and testing.",
     
-    'sequencing': "Find Barcodes and gRNA sequences in FASTQ files. (Requires paired-end FASTQ files, R1 and R2). This module uses: analyze_reads from spacr.sequencing.\n\nKey Features:\n- Barcode and gRNA Identification: Efficiently detect and extract barcode and gRNA sequences from raw sequencing data.\n- Paired-End Support: Specifically designed to handle paired-end FASTQ files, ensuring accurate sequence alignment and analysis.\n- High Throughput: Capable of processing large sequencing datasets quickly and accurately.",
+    'sequencing': "Find Barcodes and gRNA sequences in FASTQ files. (Requires paired-end FASTQ files, R1 and R2). Function: analyze_reads from spacr.sequencing.\n\nKey Features:\n- Barcode and gRNA Identification: Efficiently detect and extract barcode and gRNA sequences from raw sequencing data.\n- Paired-End Support: Specifically designed to handle paired-end FASTQ files, ensuring accurate sequence alignment and analysis.\n- High Throughput: Capable of processing large sequencing datasets quickly and accurately.",
     
-    'umap': "Generate UMAP or tSNE embeddings and represent points as single cell images. (Requires measurements.db and PNG images from the Measure module). This module uses: generate_image_umap from spacr.core.\n\nKey Features:\n- Dimensionality Reduction: Employ UMAP or tSNE algorithms to reduce high-dimensional data into two dimensions for visualization.\n- Single Cell Representation: Visualize embedding points as single cell images, providing an intuitive understanding of data clusters.\n- Data Integration: Requires measurements and images generated by the Measure module, ensuring comprehensive data representation.",
+    'umap': "Generate UMAP or tSNE embeddings and represent points as single cell images. (Requires measurements.db and PNG images from the Measure module). Function: generate_image_umap from spacr.core.\n\nKey Features:\n- Dimensionality Reduction: Employ UMAP or tSNE algorithms to reduce high-dimensional data into two dimensions for visualization.\n- Single Cell Representation: Visualize embedding points as single cell images, providing an intuitive understanding of data clusters.\n- Data Integration: Requires measurements and images generated by the Measure module, ensuring comprehensive data representation.",
     
-    'train_cellpose': "Train custom Cellpose models for your specific dataset. This module uses: train_cellpose_model from spacr.core.\n\nKey Features:\n- Custom Model Training: Train Cellpose models on your dataset to improve segmentation accuracy.\n- Data Adaptation: Tailor the model to handle specific types of biological samples more effectively.\n- Advanced Training Options: Supports various training parameters and configurations for optimized performance.",
+    'train_cellpose': "Train custom Cellpose models for your specific dataset. Function: train_cellpose_model from spacr.core.\n\nKey Features:\n- Custom Model Training: Train Cellpose models on your dataset to improve segmentation accuracy.\n- Data Adaptation: Tailor the model to handle specific types of biological samples more effectively.\n- Advanced Training Options: Supports various training parameters and configurations for optimized performance.",
     
-    'ml_analyze': "Perform machine learning analysis on your data. This module uses: ml_analysis_tools from spacr.ml.\n\nKey Features:\n- Comprehensive Analysis: Utilize a suite of machine learning tools for data analysis.\n- Customizable Workflows: Configure and run different ML algorithms based on your research requirements.\n- Integration: Works seamlessly with other modules to analyze data produced from various steps.",
+    'ml_analyze': "Perform machine learning analysis on your data. Function: ml_analysis_tools from spacr.ml.\n\nKey Features:\n- Comprehensive Analysis: Utilize a suite of machine learning tools for data analysis.\n- Customizable Workflows: Configure and run different ML algorithms based on your research requirements.\n- Integration: Works seamlessly with other modules to analyze data produced from various steps.",
     
-    'cellpose_masks': "Generate masks using Cellpose for all images in your dataset. This module uses: generate_masks from spacr.cellpose.\n\nKey Features:\n- Batch Processing: Generate masks for large sets of images efficiently.\n- Robust Segmentation: Leverage Cellpose's capabilities for accurate segmentation across diverse samples.\n- Automation: Automate the mask generation process for streamlined workflows.",
+    'cellpose_masks': "Generate masks using Cellpose for all images in your dataset. Function: generate_masks from spacr.cellpose.\n\nKey Features:\n- Batch Processing: Generate masks for large sets of images efficiently.\n- Robust Segmentation: Leverage Cellpose's capabilities for accurate segmentation across diverse samples.\n- Automation: Automate the mask generation process for streamlined workflows.",
     
-    'cellpose_all': "Run Cellpose on all images in your dataset and obtain masks and measurements. This module uses: cellpose_analysis from spacr.cellpose.\n\nKey Features:\n- End-to-End Analysis: Perform both segmentation and measurement extraction in a single step.\n- Efficiency: Process entire datasets with minimal manual intervention.\n- Comprehensive Output: Obtain detailed masks and corresponding measurements for further analysis.",
+    'cellpose_all': "Run Cellpose on all images in your dataset and obtain masks and measurements. Function: cellpose_analysis from spacr.cellpose.\n\nKey Features:\n- End-to-End Analysis: Perform both segmentation and measurement extraction in a single step.\n- Efficiency: Process entire datasets with minimal manual intervention.\n- Comprehensive Output: Obtain detailed masks and corresponding measurements for further analysis.",
     
-    'map_barcodes': "Map barcodes to your data for identification and tracking. This module uses: barcode_mapping_tools from spacr.sequencing.\n\nKey Features:\n- Barcode Integration: Efficiently map and integrate barcode information into your dataset.\n- Tracking: Enable tracking and identification of samples using barcodes.\n- Compatibility: Works with sequencing data to ensure accurate mapping and analysis.",
+    'map_barcodes': "Map barcodes to your data for identification and tracking. Function: barcode_mapping_tools from spacr.sequencing.\n\nKey Features:\n- Barcode Integration: Efficiently map and integrate barcode information into your dataset.\n- Tracking: Enable tracking and identification of samples using barcodes.\n- Compatibility: Works with sequencing data to ensure accurate mapping and analysis.",
     
-    'regression': "Perform regression analysis on your data. This module uses: regression_tools from spacr.analysis.\n\nKey Features:\n- Statistical Analysis: Conduct various types of regression analysis to identify relationships within your data.\n- Flexible Options: Supports multiple regression models and configurations.\n- Data Insight: Gain deeper insights into your dataset through advanced regression techniques.",
+    'regression': "Perform regression analysis on your data. Function: regression_tools from spacr.analysis.\n\nKey Features:\n- Statistical Analysis: Conduct various types of regression analysis to identify relationships within your data.\n- Flexible Options: Supports multiple regression models and configurations.\n- Data Insight: Gain deeper insights into your dataset through advanced regression techniques.",
     
-    'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. This module uses: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
+    'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. Function: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
 }
 
 def set_annotate_default_settings(settings):

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.1.85
+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.85 → spacr-0.2.0}/spacr.egg-info/SOURCES.txt

@@ -36,9 +36,26 @@ spacr.egg-info/dependency_links.txt
 spacr.egg-info/entry_points.txt
 spacr.egg-info/requires.txt
 spacr.egg-info/top_level.txt
-spacr/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model
-spacr/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model_settings.csv
-spacr/models/cp/toxo_pv_lumen.CP_model
+spacr/resources/icons/abort.png
+spacr/resources/icons/annotate.png
+spacr/resources/icons/cellpose_masks.png
+spacr/resources/icons/classify.png
+spacr/resources/icons/default.png
+spacr/resources/icons/download.png
+spacr/resources/icons/logo_spacr.png
+spacr/resources/icons/make_masks.png
+spacr/resources/icons/map_barcodes.png
+spacr/resources/icons/mask.png
+spacr/resources/icons/measure.png
+spacr/resources/icons/regression.png
+spacr/resources/icons/run.png
+spacr/resources/icons/sequencing.png
+spacr/resources/icons/settings.png
+spacr/resources/icons/train_cellpose.png
+spacr/resources/icons/umap.png
+spacr/resources/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model
+spacr/resources/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model_settings.csv
+spacr/resources/models/cp/toxo_pv_lumen.CP_model
 tests/test_annotate_app.py
 tests/test_core.py
 tests/test_gui_classify_app.py

spacr-0.1.85/spacr/gui.py

@@ -1,195 +0,0 @@
-import tkinter as tk
-from tkinter import ttk
-from PIL import Image, ImageTk
-import os, requests
-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")
-
-        # 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_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.pack(fill=tk.BOTH, expand=True)
-
-        # 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)
-        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):
-            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
-        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)
-        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.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, 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
-
-    def load_app(self, app_name, app_func):
-        # Clear the current content frame
-        self.clear_frame(self.content_frame)
-
-        # Initialize the selected app
-        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()
-
-def gui_app():
-    app = MainApp()
-    app.mainloop()
-
-if __name__ == "__main__":
-    set_start_method('spawn', force=True)
-    gui_app()