spacr 0.2.1__tar.gz → 0.2.3__tar.gz

{spacr-0.2.1/spacr.egg-info → spacr-0.2.3}/PKG-INFO

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

{spacr-0.2.1 → spacr-0.2.3}/setup.py

@@ -50,7 +50,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.2.1",
+    version="0.2.3",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",

{spacr-0.2.1 → spacr-0.2.3}/spacr/gui.py

@@ -97,7 +97,7 @@ class MainApp(tk.Tk):
         # 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."
+        self.main_buttons[logo_button] = "SpaCr provides a flexible toolset to extract single-cell images and measurements from high-content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate, and analyze pooled CRISPR-Cas9 imaging screens.."
 
         # Create icon buttons for the main apps
         for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
@@ -115,6 +115,7 @@ class MainApp(tk.Tk):
 
         # Update description initially
         self.update_description()
+        #
 
     def update_description(self):
         # Check all buttons and update description if any has the active color

{spacr-0.2.1 → spacr-0.2.3}/spacr/gui_core.py

@@ -1,4 +1,4 @@
-import os, traceback, ctypes, matplotlib, requests, csv, matplotlib, time, requests
+import os, traceback, ctypes, matplotlib, requests, csv, matplotlib, time, requests, re
 import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 import tkinter as tk
@@ -10,14 +10,14 @@ from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
 from huggingface_hub import list_repo_files
-
+import numpy as np
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
 from .settings import set_default_train_test_model, get_measure_crop_settings, set_default_settings_preprocess_generate_masks, get_analyze_reads_default_settings, set_default_umap_image_settings
-from .gui_elements import spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
+from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
 
 # Define global variables
 q = None
@@ -89,7 +89,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     from .sim import run_multiple_simulations
     from .deep_spacr import train_test_model
     from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
-    process_stdout_stderr(q)    
+    process_stdout_stderr(q)
+
+    print(f'run_function_gui settings_type: {settings_type}') 
     
     if settings_type == 'mask':
         function = preprocess_generate_masks
@@ -127,21 +129,6 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'recruitment':
         function = analyze_recruitment
         imports = 2
-    #elif settings_type == 'cellpose_dataset':
-    #    function = generate_cellpose_train_test
-    #    imports = 1
-    #elif settings_type == 'plaques':
-    #    function = analyze_plaques
-    #    imports = 1
-    #elif settings_type == 'cellpose_compare':
-    #    function = compare_cellpose_masks
-    #    imports = 1
-    #elif settings_type == 'vision_scores':
-    #    function = apply_model_to_tar
-    #    imports = 1
-    #elif settings_type == 'vision_dataset':
-    #    function = generate_dataset
-    #    imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:
@@ -484,7 +471,7 @@ 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):
-    global button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
+    global button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
     from .settings import descriptions
 
     width = (window_dimensions[0]) // 8
@@ -507,6 +494,7 @@ def setup_button_section(horizontal_container, settings_type='mask', window_dime
     btn_row = 1
 
     if run:
+        print(f'settings_type: {settings_type}')
         run_button = spacrButton(button_scrollable_frame.scrollable_frame, text="run", command=lambda: start_process(q, fig_queue, settings_type))
         run_button.grid(row=btn_row, column=btn_col, pady=5, padx=5, sticky='ew')
         widgets.append(run_button)
@@ -528,6 +516,11 @@ def setup_button_section(horizontal_container, settings_type='mask', window_dime
         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)
+        btn_row += 1
+
+    progress_bar = spacrProgressBar(button_scrollable_frame.scrollable_frame, orient='horizontal', mode='determinate')
+    progress_bar.grid(row=0, column=0, columnspan=2, pady=5, padx=5, sticky='ew')
+    widgets.append(progress_bar)
 
     if vars_dict is not None:
         toggle_settings(button_scrollable_frame)
@@ -535,7 +528,7 @@ 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_frame.grid_rowconfigure(0, weight=1)
 
     description_label = tk.Label(description_frame, text="Module Description", anchor='nw', justify='left', wraplength=width - 50)
     description_label.grid(row=0, column=0, pady=50, padx=20, sticky='nsew')
@@ -554,7 +547,8 @@ def setup_button_section(horizontal_container, settings_type='mask', window_dime
     style = ttk.Style(horizontal_container)
     _ = set_dark_style(style, containers=containers, widgets=widgets)
 
-    return button_frame, button_scrollable_frame, description_frame, description_label
+    return button_scrollable_frame
+
 
 def hide_all_settings(vars_dict, categories):
     """
@@ -647,17 +641,68 @@ def process_fig_queue():
         after_id = canvas_widget.after(100, process_fig_queue)
         parent_frame.after_tasks.append(after_id)
 
-def process_console_queue():
+def process_console_queue_v1():
     global q, console_output, parent_frame
     while not q.empty():
         message = q.get_nowait()
         console_output.insert(tk.END, message)
         console_output.see(tk.END)
+    after_id = console_output.after(100, process_console_queue_v1)
+    parent_frame.after_tasks.append(after_id)
+
+def process_console_queue():
+    global q, console_output, parent_frame, progress_bar, progress_label
+
+    # Initialize function attribute if it doesn't exist
+    if not hasattr(process_console_queue, "completed_tasks"):
+        process_console_queue.completed_tasks = []
+
+    ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+    
+    while not q.empty():
+        message = q.get_nowait()
+        clean_message = ansi_escape_pattern.sub('', message)
+        console_output.insert(tk.END, clean_message + "\n")
+        console_output.see(tk.END)
+        
+        # Check if the message contains progress information
+        if clean_message.startswith("Progress"):
+            try:
+                # Extract the progress information
+                match = re.search(r'(\d+)/(\d+)', clean_message)
+                if match:
+                    current_progress = int(match.group(1))
+                    total_progress = int(match.group(2))
+
+                    # Add the task to the completed set
+                    process_console_queue.completed_tasks.append(current_progress)
+                    #print('completed_tasks', process_console_queue.completed_tasks)
+                    
+                    # Calculate the unique progress count
+                    unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
+                    
+                    # Update the progress bar
+                    if progress_bar:
+                        progress_bar['maximum'] = total_progress
+                        progress_bar['value'] = unique_progress_count
+
+                    # Update the progress label
+                    if progress_label:
+                        progress_label_text = f"Processing: {unique_progress_count}/{total_progress}"
+                        progress_label.config(text=progress_label_text)
+                        
+                    # Clear completed tasks when progress is complete
+                    if unique_progress_count > total_progress:
+                        process_console_queue.completed_tasks.clear()
+            except Exception as e:
+                print(f"Error parsing progress message: {e}")
+    
     after_id = console_output.after(100, process_console_queue)
     parent_frame.after_tasks.append(after_id)
 
-def set_globals(q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, progress_label_var, fig_queue_var):
-    global q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue
+
+def set_globals(q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, progress_bar_var):
+    global q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue, progress_bar
     q = q_var
     console_output = console_output_var
     parent_frame = parent_frame_var
@@ -665,8 +710,8 @@ def set_globals(q_var, console_output_var, parent_frame_var, vars_dict_var, canv
     canvas = canvas_var
     canvas_widget = canvas_widget_var
     scrollable_frame = scrollable_frame_var
-    progress_label = progress_label_var
     fig_queue = fig_queue_var
+    progress_bar = progress_bar_var
 
 def create_containers(parent_frame):
     vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL)
@@ -694,7 +739,7 @@ def setup_frame(parent_frame):
     return parent_frame, vertical_container, horizontal_container
 
 def initiate_root(parent, settings_type='mask'):
-    global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, progress_label, progress_output, button_scrollable_frame
+    global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar
     from .gui_utils import main_thread_update_function
     from .gui import gui_app
     set_start_method('spawn', force=True)
@@ -733,16 +778,12 @@ def initiate_root(parent, settings_type='mask'):
         canvas, canvas_widget = setup_plot_section(vertical_container)
         console_output = setup_console(vertical_container)
 
-        if settings_type in ['mask', 'measure', 'classify', 'sequencing']:
-            progress_output = setup_progress_frame(vertical_container)
-        else:
-            progress_output = None
-
-        set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue)
+        set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, progress_bar)
         process_console_queue()
         process_fig_queue()
-        after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget, progress_label))
+        after_id = parent_frame.after(100, lambda: main_thread_update_function(parent_frame, q, fig_queue, canvas_widget))
         parent_frame.after_tasks.append(after_id)
 
     print("Root initialization complete")
     return parent_frame, vars_dict
+

{spacr-0.2.1 → spacr-0.2.3}/spacr/gui_elements.py

@@ -15,19 +15,20 @@ 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='blue', inactive_color='dark_gray'):
+def set_default_font(root, font_name="Arial", size=12):
+    default_font = (font_name, size)
+    root.option_add("*Font", default_font)
+    root.option_add("*TButton.Font", default_font)
+    root.option_add("*TLabel.Font", default_font)
+    root.option_add("*TEntry.Font", default_font)
     
-    if platform.system() == 'Darwin':
-        bg_color = '#313131'
-    else:
-        bg_color = '#000000'
+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 active_color == 'teal':
         active_color = '#008080'
     if inactive_color == 'dark_gray':
-        inactive_color = '#050505'
+        inactive_color = '#2B2B2B' # '#333333' #'#050505'
     if bg_color == 'black':
         bg_color = '#000000'
     if fg_color == 'white':
@@ -35,27 +36,39 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
     if active_color == 'blue':
         active_color = '#007BFF'
 
+    padding = '5 5 5 5'
     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)
-    style.configure('TCombobox', fieldbackground=bg_color, background=bg_color, foreground=fg_color, selectbackground=bg_color, selectforeground=fg_color, font=font_style)
-    style.map('TCombobox', fieldbackground=[('readonly', bg_color)], foreground=[('readonly', fg_color)], selectbackground=[('readonly', bg_color)], selectforeground=[('readonly', fg_color)])
-    style.configure('Custom.TButton', background=bg_color, foreground=fg_color, bordercolor=fg_color, focusthickness=3, focuscolor=fg_color, font=(font_family, font_size))
-    style.map('Custom.TButton', background=[('active', active_color), ('!active', bg_color)], foreground=[('active', fg_color), ('!active', fg_color)], bordercolor=[('active', fg_color), ('!active', fg_color)])
-    style.configure('Custom.TLabel', padding='5 5 5 5', borderwidth=1, relief='flat', background=bg_color, foreground=fg_color, font=font_style)
-    style.configure('Spacr.TCheckbutton', background=bg_color, foreground=fg_color, indicatoron=False, relief='flat', font="15")
-    style.map('Spacr.TCheckbutton', background=[('selected', bg_color), ('active', bg_color)], foreground=[('selected', fg_color), ('active', fg_color)])
-    style.configure('TLabel', background=bg_color, foreground=fg_color, font=font_style)
+
+    style.theme_use('clam')
+    
+    style.configure('TEntry', padding=padding)
+    style.configure('TCombobox', padding=padding)
+    style.configure('Spacr.TEntry', padding=padding)
+    style.configure('TEntry', padding=padding)
+    style.configure('Spacr.TEntry', padding=padding)
+    style.configure('Custom.TLabel', padding=padding)
+    #style.configure('Spacr.TCheckbutton', padding=padding)
+    style.configure('TButton', padding=padding)
+
     style.configure('TFrame', background=bg_color)
     style.configure('TPanedwindow', background=bg_color)
-    style.configure('TNotebook', background=bg_color, tabmargins=[2, 5, 2, 0])
-    style.configure('TNotebook.Tab', background=bg_color, foreground=fg_color, padding=[5, 5], font=font_style)
-    style.map('TNotebook.Tab', background=[('selected', active_color), ('active', active_color)], foreground=[('selected', fg_color), ('active', fg_color)])
-    style.configure('TButton', background=bg_color, foreground=fg_color, padding='5 5 5 5', font=font_style)
-    style.map('TButton', background=[('active', active_color), ('disabled', inactive_color)])
-    style.configure('Vertical.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
-    style.configure('Horizontal.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
-    style.configure('Custom.TLabelFrame', font=(font_family, font_size, 'bold'), background=bg_color, foreground='white', relief='solid', borderwidth=1)
-    style.configure('Custom.TLabelFrame.Label', background=bg_color, foreground='white', font=(font_family, font_size, 'bold'))
+    style.configure('TLabel', background=bg_color, foreground=fg_color, font=font_style)
+
+
+    #style.configure('Custom.TLabel', padding='5 5 5 5', borderwidth=1, relief='flat', background=bg_color, foreground=fg_color, font=font_style)
+    #style.configure('Spacr.TCheckbutton', background=bg_color, foreground=fg_color, indicatoron=False, relief='flat', font="15")
+    #style.map('Spacr.TCheckbutton', background=[('selected', bg_color), ('active', bg_color)], foreground=[('selected', fg_color), ('active', fg_color)])
+    
+
+    #style.configure('TNotebook', background=bg_color, tabmargins=[2, 5, 2, 0])
+    #style.configure('TNotebook.Tab', background=bg_color, foreground=fg_color, padding=[5, 5], font=font_style)
+    #style.map('TNotebook.Tab', background=[('selected', active_color), ('active', active_color)], foreground=[('selected', fg_color), ('active', fg_color)])
+    #style.configure('TButton', background=bg_color, foreground=fg_color, padding='5 5 5 5', font=font_style)
+    #style.map('TButton', background=[('active', active_color), ('disabled', inactive_color)])
+    #style.configure('Vertical.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
+    #style.configure('Horizontal.TScrollbar', background=bg_color, troughcolor=bg_color, bordercolor=bg_color)
+    #style.configure('Custom.TLabelFrame', font=(font_family, font_size, 'bold'), background=bg_color, foreground='white', relief='solid', borderwidth=1)
+    #style.configure('Custom.TLabelFrame.Label', background=bg_color, foreground='white', font=(font_family, font_size, 'bold'))
 
     if parent_frame:
         parent_frame.configure(bg=bg_color)
@@ -86,20 +99,245 @@ def set_dark_style(style, parent_frame=None, containers=None, widgets=None, font
 
     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)
-    root.option_add("*Font", default_font)
-    root.option_add("*TButton.Font", default_font)
-    root.option_add("*TLabel.Font", default_font)
-    root.option_add("*TEntry.Font", default_font)
+class spacrEntry(tk.Frame):
+    def __init__(self, parent, textvariable=None, outline=False, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        
+        # Set dark style
+        style_out = set_dark_style(ttk.Style())
+        self.bg_color = style_out['inactive_color']
+        self.active_color = style_out['active_color']
+        self.fg_color = style_out['fg_color']
+        self.outline = outline
+        self.font_family = style_out['font_family']
+        self.font_size = style_out['font_size']
+        
+        # Set the background color of the frame
+        self.configure(bg=style_out['bg_color'])
+
+        # Create a canvas for the rounded rectangle background
+        self.canvas_width = 220  # Adjusted for padding
+        self.canvas_height = 40   # Adjusted for padding
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg=style_out['bg_color'])
+        self.canvas.pack()
+        
+        self.entry = tk.Entry(self, textvariable=textvariable, bd=0, highlightthickness=0, fg=self.fg_color, font=(self.font_family, self.font_size), bg=self.bg_color)
+        self.entry.place(relx=0.5, rely=0.5, anchor=tk.CENTER, width=190, height=20)  # Centered positioning
+        
+        # Bind events to change the background color on focus
+        self.entry.bind("<FocusIn>", self.on_focus_in)
+        self.entry.bind("<FocusOut>", self.on_focus_out)
+        
+        self.draw_rounded_rectangle(self.bg_color)
+
+    def draw_rounded_rectangle(self, color):
+        radius = 15  # Increased radius for more rounded corners
+        x0, y0 = 10, 5
+        x1, y1 = 210, 35
+        self.canvas.delete("all")
+        self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x0, y1 - radius, x0 + radius, y1), start=180, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y1 - radius, x1, y1), start=270, extent=90, fill=color, outline=color)
+        self.canvas.create_rectangle((x0 + radius / 2, y0, x1 - radius / 2, y1), fill=color, outline=color)
+        self.canvas.create_rectangle((x0, y0 + radius / 2, x1, y1 - radius / 2), fill=color, outline=color)
+    
+    def on_focus_in(self, event):
+        self.draw_rounded_rectangle(self.active_color)
+        self.entry.config(bg=self.active_color)
+    
+    def on_focus_out(self, event):
+        self.draw_rounded_rectangle(self.bg_color)
+        self.entry.config(bg=self.bg_color)
+
+class spacrCheck(tk.Frame):
+    def __init__(self, parent, text="", variable=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        
+        style_out = set_dark_style(ttk.Style())
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+        self.fg_color = style_out['fg_color']
+        self.inactive_color = style_out['inactive_color']
+        self.variable = variable
+
+        self.configure(bg=self.bg_color)
+
+        # Create a canvas for the rounded square background
+        self.canvas_width = 20
+        self.canvas_height = 20
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg=self.bg_color)
+        self.canvas.pack()
+
+        # Draw the initial rounded square based on the variable's value
+        self.draw_rounded_square(self.active_color if self.variable.get() else self.inactive_color)
+
+        # Bind variable changes to update the checkbox
+        self.variable.trace_add('write', self.update_check)
+
+        # Bind click event to toggle the variable
+        self.canvas.bind("<Button-1>", self.toggle_variable)
+
+    def draw_rounded_square(self, color):
+        radius = 5  # Adjust the radius for more rounded corners
+        x0, y0 = 2, 2
+        x1, y1 = 18, 18
+        self.canvas.delete("all")
+        self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=self.fg_color)
+        self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=self.fg_color)
+        self.canvas.create_arc((x0, y1 - radius, x0 + radius, y1), start=180, extent=90, fill=color, outline=self.fg_color)
+        self.canvas.create_arc((x1 - radius, y1 - radius, x1, y1), start=270, extent=90, fill=color, outline=self.fg_color)
+        self.canvas.create_rectangle((x0 + radius / 2, y0, x1 - radius / 2, y1), fill=color, outline=color)
+        self.canvas.create_rectangle((x0, y0 + radius / 2, x1, y1 - radius / 2), fill=color, outline=color)
+        self.canvas.create_line(x0 + radius / 2, y0, x1 - radius / 2, y0, fill=self.fg_color)
+        self.canvas.create_line(x0 + radius / 2, y1, x1 - radius / 2, y1, fill=self.fg_color)
+        self.canvas.create_line(x0, y0 + radius / 2, x0, y1 - radius / 2, fill=self.fg_color)
+        self.canvas.create_line(x1, y0 + radius / 2, x1, y1 - radius / 2, fill=self.fg_color)
+
+    def update_check(self, *args):
+        self.draw_rounded_square(self.active_color if self.variable.get() else self.inactive_color)
+
+    def toggle_variable(self, event):
+        self.variable.set(not self.variable.get())
+
+class spacrCombo(tk.Frame):
+    def __init__(self, parent, textvariable=None, values=None, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+        
+        # Set dark style
+        style_out = set_dark_style(ttk.Style())
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+        self.fg_color = style_out['fg_color']
+        self.inactive_color = style_out['inactive_color']
+        self.font_family = style_out['font_family']
+        self.font_size = style_out['font_size']
+
+        self.values = values or []
+
+        # Create a canvas for the rounded rectangle background
+        self.canvas_width = 220  # Adjusted for padding
+        self.canvas_height = 40   # Adjusted for padding
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg=self.bg_color)
+        self.canvas.pack()
+        
+        self.var = textvariable if textvariable else tk.StringVar()
+        self.selected_value = self.var.get()
+        
+        # Create the label to display the selected value
+        self.label = tk.Label(self, text=self.selected_value, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size))
+        self.label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
+        
+        # Bind events to open the dropdown menu
+        self.canvas.bind("<Button-1>", self.on_click)
+        self.label.bind("<Button-1>", self.on_click)
+        
+        self.draw_rounded_rectangle(self.inactive_color)
+
+        self.dropdown_menu = None
+
+    def draw_rounded_rectangle(self, color):
+        radius = 15  # Increased radius for more rounded corners
+        x0, y0 = 10, 5
+        x1, y1 = 210, 35
+        self.canvas.delete("all")
+        self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x0, y1 - radius, x0 + radius, y1), start=180, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y1 - radius, x1, y1), start=270, extent=90, fill=color, outline=color)
+        self.canvas.create_rectangle((x0 + radius / 2, y0, x1 - radius / 2, y1), fill=color, outline=color)
+        self.canvas.create_rectangle((x0, y0 + radius / 2, x1, y1 - radius / 2), fill=color, outline=color)
+        self.label.config(bg=color)  # Update label background to match rectangle color
+
+    def on_click(self, event):
+        if self.dropdown_menu is None:
+            self.open_dropdown()
+        else:
+            self.close_dropdown()
+
+    def open_dropdown(self):
+        self.draw_rounded_rectangle(self.active_color)
+        
+        self.dropdown_menu = tk.Toplevel(self)
+        self.dropdown_menu.wm_overrideredirect(True)
+        
+        x, y, width, height = self.winfo_rootx(), self.winfo_rooty(), self.winfo_width(), self.winfo_height()
+        self.dropdown_menu.geometry(f"{width}x{len(self.values) * 30}+{x}+{y + height}")
+        
+        for index, value in enumerate(self.values):
+            display_text = value if value is not None else 'None'
+            item = tk.Label(self.dropdown_menu, text=display_text, bg=self.inactive_color, fg=self.fg_color, font=(self.font_family, self.font_size), anchor='w')
+            item.pack(fill='both')
+            item.bind("<Button-1>", lambda e, v=value: self.on_select(v))
+            item.bind("<Enter>", lambda e, w=item: w.config(bg=self.active_color))
+            item.bind("<Leave>", lambda e, w=item: w.config(bg=self.inactive_color))
+
+    def close_dropdown(self):
+        self.draw_rounded_rectangle(self.inactive_color)
+        
+        if self.dropdown_menu:
+            self.dropdown_menu.destroy()
+            self.dropdown_menu = None
+
+    def on_select(self, value):
+        display_text = value if value is not None else 'None'
+        self.var.set(value)
+        self.label.config(text=display_text)
+        self.selected_value = value
+        self.close_dropdown()
+
+    def set(self, value):
+        display_text = value if value is not None else 'None'
+        self.var.set(value)
+        self.label.config(text=display_text)
+        self.selected_value = value
 
 class spacrDropdownMenu(tk.OptionMenu):
     def __init__(self, parent, variable, options, command=None, **kwargs):
         self.variable = variable
-        self.variable.set("Select Category")
+        self.variable.set("Settings Category")
         super().__init__(parent, self.variable, *options, command=command, **kwargs)
         self.update_styles()
 
+        # Hide the original button
+        self.configure(highlightthickness=0, relief='flat', bg='#2B2B2B', fg='#2B2B2B')
+
+        # Create custom button
+        self.create_custom_button()
+
+    def create_custom_button(self):
+        self.canvas_width = self.winfo_reqwidth()  # Use the required width of the widget
+        self.canvas_height = 40  # Adjust the height as needed
+        self.canvas = tk.Canvas(self, width=self.canvas_width, height=self.canvas_height, bd=0, highlightthickness=0, relief='ridge', bg='#2B2B2B')
+        self.canvas.pack()
+        self.label = tk.Label(self.canvas, text="Settings Category", bg='#2B2B2B', fg='#ffffff', font=('Arial', 12))
+        self.label.place(relx=0.5, rely=0.5, anchor=tk.CENTER)
+        self.draw_rounded_rectangle('#2B2B2B')
+
+        # Bind the click event to open the dropdown menu
+        self.canvas.bind("<Button-1>", self.on_click)
+        self.label.bind("<Button-1>", self.on_click)
+
+    def draw_rounded_rectangle(self, color):
+        radius = 15
+        x0, y0 = 10, 5
+        x1, y1 = self.canvas_width - 10, self.canvas_height - 5  # Adjust based on canvas size
+        self.canvas.delete("all")
+        self.canvas.create_arc((x0, y0, x0 + radius, y0 + radius), start=90, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y0, x1, y0 + radius), start=0, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x0, y1 - radius, x0 + radius, y1), start=180, extent=90, fill=color, outline=color)
+        self.canvas.create_arc((x1 - radius, y1 - radius, x1, y1), start=270, extent=90, fill=color, outline=color)
+        self.canvas.create_rectangle((x0 + radius / 2, y0, x1 - radius / 2, y1), fill=color, outline=color)
+        self.canvas.create_rectangle((x0, y0 + radius / 2, x1, y1 - radius / 2), fill=color, outline=color)
+        self.label.config(bg=color)  # Update label background to match rectangle color
+
+    def on_click(self, event):
+        self.post_menu()
+
+    def post_menu(self):
+        x, y, width, height = self.winfo_rootx(), self.winfo_rooty(), self.winfo_width(), self.winfo_height()
+        self.menu.post(x, y + height)
+
     def update_styles(self, active_categories=None):
         style = ttk.Style()
         style_out = set_dark_style(style, widgets=[self])
@@ -124,6 +362,31 @@ class spacrCheckbutton(ttk.Checkbutton):
         style = ttk.Style()
         _ = set_dark_style(style, widgets=[self])
 
+class spacrProgressBar(ttk.Progressbar):
+    def __init__(self, parent, *args, **kwargs):
+        super().__init__(parent, *args, **kwargs)
+
+        # Get the style colors
+        style_out = set_dark_style(ttk.Style())
+        self.inactive_color = style_out['inactive_color']
+        self.bg_color = style_out['bg_color']
+        self.active_color = style_out['active_color']
+
+        # Configure the style for the progress bar
+        self.style = ttk.Style()
+        self.style.configure(
+            "spacr.Horizontal.TProgressbar",
+            troughcolor=self.bg_color,
+            background=self.active_color,
+            thickness=20,
+            troughrelief='flat',
+            borderwidth=0
+        )
+        self.configure(style="spacr.Horizontal.TProgressbar")
+
+        # Set initial value to 0
+        self['value'] = 0
+
 class spacrFrame(ttk.Frame):
     def __init__(self, container, width=None, *args, bg='black', **kwargs):
         super().__init__(container, *args, **kwargs)
@@ -196,7 +459,7 @@ 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, icon_name=None, size=50, show_text=True, outline=True, *args, **kwargs):
+    def __init__(self, parent, text="", command=None, font=None, icon_name=None, size=50, show_text=True, outline=False, *args, **kwargs):
         super().__init__(parent, *args, **kwargs)
         
         self.text = text.capitalize()  # Capitalize only the first letter of the text
@@ -220,10 +483,12 @@ class spacrButton(tk.Frame):
         # Apply dark style and get color settings
         color_settings = set_dark_style(ttk.Style(), containers=[self], widgets=[self.canvas])
 
+        self.inactive_color = color_settings['inactive_color']
+
         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'])
+            self.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=self.inactive_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.button_bg = self.create_rounded_rectangle(2, 2, self.button_width + 2, self.size + 2, radius=20, fill=self.inactive_color, outline=self.inactive_color)
         
         self.load_icon()
         self.font_style = font if font else ("Arial", 12)  # Default font if not provided
@@ -238,7 +503,7 @@ class spacrButton(tk.Frame):
         self.canvas.bind("<Leave>", self.on_leave)
         self.canvas.bind("<Button-1>", self.on_click)
 
-        self.bg_color = color_settings['bg_color']
+        self.bg_color = self.inactive_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
@@ -255,7 +520,7 @@ class spacrButton(tk.Frame):
                 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
+        initial_size = int(self.size * 0.65)  # 65% of button size initially
         self.original_icon_image = icon_image.resize((initial_size, initial_size), Image.Resampling.LANCZOS)
         self.icon_photo = ImageTk.PhotoImage(self.original_icon_image)
 
@@ -270,13 +535,13 @@ class spacrButton(tk.Frame):
         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%
+            self.animate_zoom(0.85)  # Zoom in the icon to 85% of button size
 
     def on_leave(self, event=None):
-        self.canvas.itemconfig(self.button_bg, fill=self.bg_color)
+        self.canvas.itemconfig(self.button_bg, fill=self.inactive_color)
         self.clear_description(event)
         if self.is_zoomed_in:
-            self.animate_zoom(1.0)  # Reset the icon size
+            self.animate_zoom(0.65)  # Reset the icon size to 65% of button size
 
     def on_click(self, event=None):
         if self.command:
@@ -308,7 +573,7 @@ class spacrButton(tk.Frame):
         parent = self.master
         while parent:
             if hasattr(parent, 'show_description'):
-                parent.show_description(parent.main_buttons.get(self, "No description available."))
+                parent.show_description(parent.main_buttons.get(self, parent.additional_buttons.get(self, "No description available.")))
                 return
             parent = parent.master
 
@@ -321,7 +586,7 @@ class spacrButton(tk.Frame):
             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
+        current_scale = 0.85 if self.is_zoomed_in else 0.65
         step_scale = (target_scale - current_scale) / steps
         self._animate_step(current_scale, step_scale, steps, delay)
 
@@ -335,14 +600,13 @@ class spacrButton(tk.Frame):
 
     def zoom_icon(self, scale_factor):
         # Resize the original icon image
-        new_size = int(self.size * 0.9 * scale_factor)
+        new_size = int(self.size * 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
-
+        self.canvas.image = self.icon_photo
 
 class spacrSwitch(ttk.Frame):
     def __init__(self, parent, text="", variable=None, command=None, *args, **kwargs):
@@ -1608,20 +1872,20 @@ class AnnotateApp:
 def create_menu_bar(root):
     from .gui import initiate_root
     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."),
-        "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.")
+        "Mask": (lambda frame: initiate_root(frame, settings_type='mask'), "Generate cellpose masks for cells, nuclei and pathogen images."),
+        "Measure": (lambda frame: initiate_root(frame, settings_type='measure'), "Measure single object intensity and morphological feature. Crop and save single object image"),
+        "Annotate": (lambda frame: initiate_root(frame, settings_type='annotate'), "Annotation single object images on a grid. Annotations are saved to database."),
+        "Make Masks": (lambda frame: initiate_root(frame, settings_type='make_masks'), "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
+        "Classify": (lambda frame: initiate_root(frame, settings_type='classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images."),
+        "Sequencing": (lambda frame: initiate_root(frame, settings_type='sequencing'), "Analyze sequencing data."),
+        "Umap": (lambda frame: initiate_root(frame, settings_type='umap'), "Generate UMAP embeddings with datapoints represented as images."),
+        "Train Cellpose": (lambda frame: initiate_root(frame, settings_type='train_cellpose'), "Train custom Cellpose models."),
+        "ML Analyze": (lambda frame: initiate_root(frame, settings_type='ml_analyze'), "Machine learning analysis of data."),
+        "Cellpose Masks": (lambda frame: initiate_root(frame, settings_type='cellpose_masks'), "Generate Cellpose masks."),
+        "Cellpose All": (lambda frame: initiate_root(frame, settings_type='cellpose_all'), "Run Cellpose on all images."),
+        "Map Barcodes": (lambda frame: initiate_root(frame, settings_type='map_barcodes'), "Map barcodes to data."),
+        "Regression": (lambda frame: initiate_root(frame, settings_type='regression'), "Perform regression analysis."),
+        "Recruitment": (lambda frame: initiate_root(frame, settings_type='recruitment'), "Analyze recruitment data.")
     }
 
     def load_app_wrapper(app_name, app_func):

{spacr-0.2.1 → spacr-0.2.3}/spacr/gui_utils.py

@@ -3,20 +3,13 @@ import tkinter as tk
 from tkinter import ttk
 
 from . gui_core import initiate_root
-from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp
+from .gui_elements import spacrLabel, spacrCheckbutton, AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
 
-def set_default_font(root, font_name="Helvetica", size=12):
-    default_font = (font_name, size)
-    root.option_add("*Font", default_font)
-    root.option_add("*TButton.Font", default_font)
-    root.option_add("*TLabel.Font", default_font)
-    root.option_add("*TEntry.Font", default_font)
-
 def proceed_with_app_v1(root, app_name, app_func):
     from .gui import gui_app
 
@@ -98,6 +91,7 @@ def parse_list(value):
     except (ValueError, SyntaxError) as e:
         raise ValueError(f"Invalid format for list: {value}. Error: {e}")
     
+# Usage example in your create_input_field function
 def create_input_field(frame, label_text, row, var_type='entry', options=None, default_value=None):
     label_column = 0
     widget_column = 1
@@ -107,22 +101,22 @@ def create_input_field(frame, label_text, row, var_type='entry', options=None, d
     frame.grid_columnconfigure(widget_column, weight=1)  # Allow the widget column to expand
 
     # Right-align the label text and the label itself
-    label = spacrLabel(frame, text=label_text, background="black", foreground="white", anchor='e', justify='right')
+    label = ttk.Label(frame, text=label_text, background="black", foreground="white", anchor='e', justify='right')
     label.grid(column=label_column, row=row, sticky=tk.E, padx=(5, 2), pady=5)  # Align label to the right
 
     if var_type == 'entry':
         var = tk.StringVar(value=default_value)  # Set default value
-        entry = ttk.Entry(frame, textvariable=var, style='TEntry')  # Apply TEntry style for entries
+        entry = spacrEntry(frame, textvariable=var, outline=False)
         entry.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         return (label, entry, var)  # Return both the label and the entry, and the variable
     elif var_type == 'check':
         var = tk.BooleanVar(value=default_value)  # Set default value (True/False)
-        check = spacrCheckbutton(frame, text="", variable=var, style='TCheckbutton')
+        check = spacrCheck(frame, text="", variable=var)
         check.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         return (label, check, var)  # Return both the label and the checkbutton, and the variable
     elif var_type == 'combo':
         var = tk.StringVar(value=default_value)  # Set default value
-        combo = ttk.Combobox(frame, textvariable=var, values=options, style='TCombobox')  # Apply TCombobox style
+        combo = spacrCombo(frame, textvariable=var, values=options)  # Apply TCombobox style
         combo.grid(column=widget_column, row=row, sticky=tk.W, padx=(2, 5), pady=5)  # Align widget to the left
         if default_value:
             combo.set(default_value)
@@ -158,32 +152,32 @@ def cancel_after_tasks(frame):
             frame.after_cancel(task)
         frame.after_tasks.clear()
 
-def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
+def main_thread_update_function(root, q, fig_queue, canvas_widget):
     try:
-        ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
+        #ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
         while not q.empty():
             message = q.get_nowait()
-            clean_message = ansi_escape_pattern.sub('', message)
-            if clean_message.startswith("Progress"):
-                progress_label.config(text=clean_message)
-            if clean_message.startswith("\rProgress"):
-                progress_label.config(text=clean_message)
-            elif clean_message.startswith("Successfully"):
-                progress_label.config(text=clean_message)
-            elif clean_message.startswith("Processing"):
-                progress_label.config(text=clean_message)
-            elif clean_message.startswith("scale"):
-                pass
-            elif clean_message.startswith("plot_cropped_arrays"):
-                pass
-            elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
-                pass
-            else:
-                print(clean_message)
+            #clean_message = ansi_escape_pattern.sub('', message)
+            #if clean_message.startswith("Progress"):
+            #    progress_label.config(text=clean_message)
+            #if clean_message.startswith("\rProgress"):
+            #    progress_label.config(text=clean_message)
+            #elif clean_message.startswith("Successfully"):
+            #    progress_label.config(text=clean_message)
+            #elif clean_message.startswith("Processing"):
+            #    progress_label.config(text=clean_message)
+            #elif clean_message.startswith("scale"):
+            #    pass
+            #elif clean_message.startswith("plot_cropped_arrays"):
+            #    pass
+            #elif clean_message == "" or clean_message == "\r" or clean_message.strip() == "":
+            #    pass
+            #else:
+            #    print(clean_message)
     except Exception as e:
         print(f"Error updating GUI canvas: {e}")
     finally:
-        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label))
+        root.after(100, lambda: main_thread_update_function(root, q, fig_queue, canvas_widget))
 
 def annotate(settings):
     from .settings import set_annotate_default_settings

{spacr-0.2.1 → spacr-0.2.3/spacr.egg-info}/PKG-INFO

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

{spacr-0.2.1 → spacr-0.2.3}/spacr.egg-info/SOURCES.txt

@@ -38,6 +38,7 @@ spacr.egg-info/requires.txt
 spacr.egg-info/top_level.txt
 spacr/resources/icons/abort.png
 spacr/resources/icons/annotate.png
+spacr/resources/icons/cellpose_all.png
 spacr/resources/icons/cellpose_masks.png
 spacr/resources/icons/classify.png
 spacr/resources/icons/default.png
@@ -47,10 +48,13 @@ 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/ml_analyze.png
+spacr/resources/icons/recruitment.png
 spacr/resources/icons/regression.png
 spacr/resources/icons/run.png
 spacr/resources/icons/sequencing.png
 spacr/resources/icons/settings.png
+spacr/resources/icons/spacr_logo_rotation.gif
 spacr/resources/icons/train_cellpose.png
 spacr/resources/icons/umap.png
 spacr/resources/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model