spacr 0.2.67__py3-none-any.whl → 0.2.81__py3-none-any.whl

spacr/core.py

@@ -1638,7 +1638,7 @@ def preprocess_generate_masks(src, settings={}):
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
     settings['src'] = src
-    save_settings(settings)
+    save_settings(settings, name='gen_mask')
 
     if not settings['pathogen_channel'] is None:
         custom_model_ls = ['toxo_pv_lumen','toxo_cyto']

spacr/gui.py

@@ -3,6 +3,7 @@ from tkinter import ttk
 from multiprocessing import set_start_method
 from .gui_elements import spacrButton, create_menu_bar, set_dark_style
 from .gui_core import initiate_root
+from screeninfo import get_monitors
 
 class MainApp(tk.Tk):
     def __init__(self, default_app=None):
@@ -12,12 +13,23 @@ class MainApp(tk.Tk):
         self.geometry("100x100")
         self.update_idletasks()
 
-        # Expand the window to fullscreen
-        self.attributes('-fullscreen', True)
+        # Get the current window position
         self.update_idletasks()
-
-        width = self.winfo_screenwidth()
-        height = self.winfo_screenheight()
+        x = self.winfo_x()
+        y = self.winfo_y()
+
+        # Find the monitor where the window is located
+        for monitor in get_monitors():
+            if monitor.x <= x < monitor.x + monitor.width and monitor.y <= y < monitor.y + monitor.height:
+                width = monitor.width
+                height = monitor.height
+                break
+        else:
+            monitor = get_monitors()[0]
+            width = monitor.width
+            height = monitor.height
+
+        # Set the window size to the dimensions of the monitor where it is located
         self.geometry(f"{width}x{height}")
         self.title("SpaCr GUI Collection")
         self.configure(bg='#333333')  # Set window background to dark gray
@@ -36,7 +48,6 @@ class MainApp(tk.Tk):
         }
 
         self.additional_gui_apps = {
-            #"Sequencing": (lambda frame: initiate_root(self, 'sequencing'), "Analyze sequencing data."),
             "Umap": (lambda frame: initiate_root(self, 'umap'), "Generate UMAP embeddings with datapoints represented as images."),
             "Train Cellpose": (lambda frame: initiate_root(self, 'train_cellpose'), "Train custom Cellpose models."),
             "ML Analyze": (lambda frame: initiate_root(self, 'ml_analyze'), "Machine learning analysis of data."),
@@ -58,32 +69,36 @@ class MainApp(tk.Tk):
     def create_widgets(self):
         create_menu_bar(self)
 
-        self.canvas = tk.Canvas(self, highlightthickness=0)
-        self.canvas.grid(row=0, column=0, sticky="nsew")
+        # Use a grid layout for centering
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
-        self.content_frame = tk.Frame(self.canvas)
+        self.content_frame = tk.Frame(self)
         self.content_frame.grid(row=0, column=0, sticky="nsew")
+        
+        # Center the content frame within the window
+        self.content_frame.grid_rowconfigure(0, weight=1)
+        self.content_frame.grid_columnconfigure(0, weight=1)
 
-        self.canvas.create_window((self.winfo_screenwidth() // 2, self.winfo_screenheight() // 2), window=self.content_frame, anchor="center")
-
-        set_dark_style(ttk.Style(), containers=[self.canvas, self.content_frame])
+        self.inner_frame = tk.Frame(self.content_frame)
+        self.inner_frame.grid(row=0, column=0)
+        
+        set_dark_style(ttk.Style(), containers=[self.content_frame, self.inner_frame])
 
         self.create_startup_screen()
 
     def create_startup_screen(self):
-        self.clear_frame(self.content_frame)
+        self.clear_frame(self.inner_frame)
 
-        main_buttons_frame = tk.Frame(self.content_frame)
+        main_buttons_frame = tk.Frame(self.inner_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 = tk.Frame(self.inner_frame)
         additional_buttons_frame.pack(pady=10)
         set_dark_style(ttk.Style(), containers=[additional_buttons_frame])
 
-        description_frame = tk.Frame(self.content_frame, height=70)
+        description_frame = tk.Frame(self.inner_frame, height=70)
         description_frame.pack(fill=tk.X, pady=10)
         description_frame.pack_propagate(False)
         set_dark_style(ttk.Style(), containers=[description_frame])
@@ -93,7 +108,7 @@ class MainApp(tk.Tk):
 
         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 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.."
+        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."
 
         for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
             app_func, app_desc = app_data
@@ -127,9 +142,9 @@ class MainApp(tk.Tk):
             self.description_label.update_idletasks()
 
     def load_app(self, app_name, app_func):
-        self.clear_frame(self.canvas)
+        self.clear_frame(self.inner_frame)
 
-        app_frame = tk.Frame(self.canvas)
+        app_frame = tk.Frame(self.inner_frame)
         app_frame.pack(fill=tk.BOTH, expand=True)
         set_dark_style(ttk.Style(), containers=[app_frame])
         app_func(app_frame)
@@ -144,4 +159,4 @@ def gui_app():
 
 if __name__ == "__main__":
     set_start_method('spawn', force=True)
-    gui_app()
+    gui_app()

spacr/gui_core.py

@@ -1,4 +1,4 @@
-import traceback, ctypes, csv, re
+import traceback, ctypes, csv, re, platform, time
 import tkinter as tk
 from tkinter import ttk
 from tkinter import filedialog
@@ -19,7 +19,7 @@ try:
 except AttributeError:
     pass
 
-from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , set_dark_style
+from .gui_elements import spacrProgressBar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu , spacrSlider, set_dark_style, standardize_figure
 
 # Define global variables
 q = None
@@ -35,8 +35,6 @@ figures = None
 figure_index = None
 progress_bar = None
 usage_bars = None
-fig_memory_limit = None
-figure_current_memory_usage = None
 
 thread_control = {"run_thread": None, "stop_requested": False}
 
@@ -80,35 +78,10 @@ def toggle_settings(button_scrollable_frame):
     category_dropdown.grid(row=0, column=4, sticky="ew", pady=2, padx=2)
     vars_dict = hide_all_settings(vars_dict, categories)
 
-def process_fig_queue():
-    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index
-
-    from .gui_elements import standardize_figure
-    try:
-        while not fig_queue.empty():
-            fig = fig_queue.get_nowait()
-
-            if fig is None:
-                print("Warning: Retrieved a None figure from fig_queue.")
-                continue  # Skip processing if the figure is None
-
-            # Standardize the figure appearance before adding it to the list
-            standardize_figure(fig)
-
-            figures.append(fig)
-            if figure_index == len(figures) - 2:
-                figure_index += 1
-                display_figure(fig)
-    except Exception as e:
-        traceback.print_exc()
-    finally:
-        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
-        parent_frame.after_tasks.append(after_id)
-
 def display_figure(fig):
     global canvas, canvas_widget
 
-    from .gui_elements import modify_figure_properties, save_figure_as_format, modify_figure
+    from .gui_elements import save_figure_as_format, modify_figure
 
     # Apply the dark style to the context menu
     style_out = set_dark_style(ttk.Style())
@@ -197,7 +170,7 @@ def display_figure(fig):
             #flash_feedback("right")
             show_next_figure()
 
-    def zoom(event):
+    def zoom_v1(event):
         nonlocal scale_factor
 
         zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
@@ -230,16 +203,55 @@ def display_figure(fig):
         # Redraw the figure
         fig.canvas.draw_idle()
 
+    def zoom(event):
+        nonlocal scale_factor
+
+        zoom_speed = 0.1  # Adjust the zoom speed for smoother experience
+
+        # Determine the zoom direction based on the scroll event
+        if event.num == 4 or event.delta > 0:  # Scroll up (zoom in)
+            scale_factor /= (1 + zoom_speed)  # Divide to zoom in
+        elif event.num == 5 or event.delta < 0:  # Scroll down (zoom out)
+            scale_factor *= (1 + zoom_speed)  # Multiply to zoom out
+
+        # Adjust the axes limits based on the new scale factor
+        for ax in canvas.figure.get_axes():
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+
+            x_center = (xlim[1] + xlim[0]) / 2
+            y_center = (ylim[1] + ylim[0]) / 2
+
+            x_range = (xlim[1] - xlim[0]) * scale_factor
+            y_range = (ylim[1] - ylim[0]) * scale_factor
+
+            # Set the new limits
+            ax.set_xlim([x_center - x_range / 2, x_center + x_range / 2])
+            ax.set_ylim([y_center - y_range / 2, y_center + y_range / 2])
+
+        # Redraw the figure efficiently
+        canvas.draw_idle()
+
+
     # Bind events for hover, click interactions, and zoom
     canvas_widget.bind("<Motion>", on_hover)
     canvas_widget.bind("<Leave>", on_leave)
     canvas_widget.bind("<Button-1>", on_click)
     canvas_widget.bind("<Button-3>", on_right_click)
 
-    # Bind mouse wheel for zooming (cross-platform)
-    canvas_widget.bind("<MouseWheel>", zoom)  # Windows
-    canvas_widget.bind("<Button-4>", zoom)  # Linux/macOS Scroll Up
-    canvas_widget.bind("<Button-5>", zoom)  # Linux/macOS Scroll Down
+
+    # Detect the operating system and bind the appropriate mouse wheel events
+    current_os = platform.system()
+
+    if current_os == "Windows":
+        canvas_widget.bind("<MouseWheel>", zoom)  # Windows
+    elif current_os == "Darwin":  # macOS
+        canvas_widget.bind("<MouseWheel>", zoom)
+        canvas_widget.bind("<Button-4>", zoom)  # Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Scroll down
+    elif current_os == "Linux":
+        canvas_widget.bind("<Button-4>", zoom)  # Linux Scroll up
+        canvas_widget.bind("<Button-5>", zoom)  # Linux Scroll down
 
 def clear_unused_figures():
     global figures, figure_index
@@ -253,6 +265,7 @@ def clear_unused_figures():
 
 def show_previous_figure():
     global figure_index, figures, fig_queue
+    
     if figure_index is not None and figure_index > 0:
         figure_index -= 1
         display_figure(figures[figure_index])
@@ -270,8 +283,104 @@ def show_next_figure():
         figure_index += 1
         display_figure(fig)
 
-def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, progress_bar_var, usage_bars_var, fig_memory_limit_var, figure_current_memory_usage_var):
-    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage
+def process_fig_queue():
+    global canvas, fig_queue, canvas_widget, parent_frame, uppdate_frequency, figures, figure_index, index_control
+
+    from .gui_elements import standardize_figure
+    try:
+        while not fig_queue.empty():
+            fig = fig_queue.get_nowait()
+
+            if fig is None:
+                print("Warning: Retrieved a None figure from fig_queue.")
+                continue  # Skip processing if the figure is None
+
+            # Standardize the figure appearance before adding it to the list
+            fig = standardize_figure(fig)
+
+            figures.append(fig)
+
+            # Update the slider range and set the value to the latest figure index
+            index_control.set_to(len(figures) - 1)
+
+            if figure_index == -1:
+                figure_index += 1
+                display_figure(figures[figure_index])
+                index_control.set(figure_index)
+            
+    except Exception as e:
+        traceback.print_exc()
+    finally:
+        after_id = canvas_widget.after(uppdate_frequency, process_fig_queue)
+        parent_frame.after_tasks.append(after_id)
+
+def update_figure(value):
+    global figure_index, figures
+
+    # Convert the value to an integer
+    index = int(value)
+    
+    # Check if the index is valid
+    if 0 <= index < len(figures):
+        figure_index = index
+        display_figure(figures[figure_index])
+
+    # Update the index control widget's range and value
+    index_control.set_to(len(figures) - 1)
+    index_control.set(figure_index)
+
+def setup_plot_section(vertical_container):
+    global canvas, canvas_widget, figures, figure_index, index_control
+
+    # Initialize deque for storing figures and the current index
+    figures = deque()
+
+    # Create a frame for the plot section
+    plot_frame = tk.Frame(vertical_container)
+    vertical_container.add(plot_frame, stretch="always")
+
+    # Set up the plot
+    figure = Figure(figsize=(30, 4), dpi=100)
+    plot = figure.add_subplot(111)
+    plot.plot([], [])
+    plot.axis('off')
+    
+    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
+    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
+    canvas_widget = canvas.get_tk_widget()
+    canvas_widget.grid(row=0, column=0, sticky="nsew")
+
+    plot_frame.grid_rowconfigure(0, weight=1)
+    plot_frame.grid_columnconfigure(0, weight=1)
+
+    canvas.draw()
+    canvas.figure = figure  # Ensure that the figure is linked to the canvas
+    style_out = set_dark_style(ttk.Style())
+    bg = style_out['bg_color']
+    fg = style_out['fg_color']
+
+    figure.patch.set_facecolor(bg)
+    plot.set_facecolor(bg)
+    containers = [plot_frame]
+
+    # Create slider
+    control_frame = tk.Frame(plot_frame, height=15*2,  bg=bg)  # Fixed height based on knob_radius
+    control_frame.grid(row=1, column=0, sticky="ew", padx=10, pady=5)
+    control_frame.grid_propagate(False)  # Prevent the frame from resizing
+
+    # Pass the update_figure function as the command to spacrSlider
+    index_control = spacrSlider(control_frame, from_=0, to=0, value=0, thickness=2, knob_radius=10, position="center", show_index=True, command=update_figure)
+    index_control.grid(row=0, column=0, sticky="ew")
+    control_frame.grid_columnconfigure(0, weight=1)
+
+    widgets = [canvas_widget, index_control]
+    style = ttk.Style(vertical_container)
+    _ = set_dark_style(style, containers=containers, widgets=widgets)
+
+    return canvas, canvas_widget
+
+def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var, vars_dict_var, canvas_var, canvas_widget_var, scrollable_frame_var, fig_queue_var, figures_var, figure_index_var, index_control_var, progress_bar_var, usage_bars_var):
+    global thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, index_control
     thread_control = thread_control_var
     q = q_var
     console_output = console_output_var
@@ -285,8 +394,7 @@ def set_globals(thread_control_var, q_var, console_output_var, parent_frame_var,
     figure_index = figure_index_var
     progress_bar = progress_bar_var
     usage_bars = usage_bars_var
-    fig_memory_limit = fig_memory_limit_var
-    figure_current_memory_usage = figure_current_memory_usage_var
+    index_control = index_control_var
 
 def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
@@ -400,46 +508,6 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     print("Settings panel setup complete")
     return scrollable_frame, vars_dict
 
-def setup_plot_section(vertical_container):
-    global canvas, canvas_widget, figures, figure_index
-
-    from .gui_elements import set_element_size
-
-    # Initialize deque for storing figures and the current index
-    figures = deque()
-    figure_index = -1
-
-    # Create a frame for the plot section
-    plot_frame = tk.Frame(vertical_container)
-    vertical_container.add(plot_frame, stretch="always")
-
-    # Set up the plot
-    figure = Figure(figsize=(30, 4), dpi=100)
-    plot = figure.add_subplot(111)
-    plot.plot([], [])
-    plot.axis('off')
-    
-    canvas = FigureCanvasTkAgg(figure, master=plot_frame)
-    canvas.get_tk_widget().configure(cursor='arrow', highlightthickness=0)
-    canvas_widget = canvas.get_tk_widget()
-    canvas_widget.grid(row=0, column=0, sticky="nsew")
-
-    plot_frame.grid_rowconfigure(0, weight=1)
-    plot_frame.grid_columnconfigure(0, weight=1)
-
-    canvas.draw()
-    canvas.figure = figure  # Ensure that the figure is linked to the canvas
-    style_out = set_dark_style(ttk.Style())
-
-    figure.patch.set_facecolor(style_out['bg_color'])
-    plot.set_facecolor(style_out['bg_color'])
-    containers = [plot_frame]
-    widgets = [canvas_widget]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    
-    return canvas, canvas_widget
-
 def setup_console(vertical_container):
     global console_output
     from .gui_elements import set_dark_style
@@ -479,27 +547,6 @@ def setup_console(vertical_container):
 
     return console_output, console_frame
 
-def setup_progress_frame(vertical_container):
-    global progress_output
-    style_out = set_dark_style(ttk.Style())
-    font_loader = style_out['font_loader']
-    font_size = style_out['font_size']
-    progress_frame = tk.Frame(vertical_container)
-    vertical_container.add(progress_frame, stretch="always")
-    label_frame = tk.Frame(progress_frame)
-    label_frame.grid(row=0, column=0, sticky="ew", pady=(5, 0), padx=10)
-    progress_label = spacrLabel(label_frame, text="Processing: 0%", font=font_loader.get_font(size=font_size), anchor='w', justify='left', align="left")
-    progress_label.grid(row=0, column=0, sticky="w")
-    progress_output = scrolledtext.ScrolledText(progress_frame, height=10)
-    progress_output.grid(row=1, column=0, sticky="nsew")
-    progress_frame.grid_rowconfigure(1, weight=1)
-    progress_frame.grid_columnconfigure(0, weight=1)
-    containers = [progress_frame, label_frame]
-    widgets = [progress_label, progress_output]
-    style = ttk.Style(vertical_container)
-    _ = set_dark_style(style, containers=containers, widgets=widgets)
-    return progress_output
-
 def setup_button_section(horizontal_container, settings_type='mask', run=True, abort=True, download=True, import_btn=True):
     global thread_control, parent_frame, button_frame, button_scrollable_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict, progress_bar
     from .gui_utils import download_hug_dataset
@@ -836,7 +883,7 @@ def initiate_root(parent, settings_type='mask'):
         tuple: A tuple containing the parent frame and the dictionary of variables used in the GUI.
     """
     
-    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, fig_memory_limit, figure_current_memory_usage
+    global q, fig_queue, thread_control, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, button_scrollable_frame, progress_bar, uppdate_frequency, figures, figure_index, index_control, usage_bars
     
     from .gui_utils import setup_frame
     from .settings import descriptions
@@ -853,8 +900,6 @@ def initiate_root(parent, settings_type='mask'):
     # Initialize global variables
     figures = deque()
     figure_index = -1
-    fig_memory_limit = 200 * 1024 * 1024  # 200 MB limit
-    figure_current_memory_usage = 0
 
     parent_frame = parent
 
@@ -886,7 +931,7 @@ def initiate_root(parent, settings_type='mask'):
         button_scrollable_frame, btn_col = setup_button_section(horizontal_container, settings_type)
         _, usage_bars, btn_col = setup_usage_panel(horizontal_container, btn_col, uppdate_frequency)
 
-        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, progress_bar, usage_bars, fig_memory_limit, figure_current_memory_usage)
+        set_globals(thread_control, q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, fig_queue, figures, figure_index, index_control, progress_bar, usage_bars)
         description_text = descriptions.get(settings_type, "No description available for this module.")
         
         q.put(f"Console")
@@ -899,4 +944,6 @@ def initiate_root(parent, settings_type='mask'):
         parent_window.after_tasks.append(after_id)
 
     print("Root initialization complete")
-    return parent_frame, vars_dict
+    return parent_frame, vars_dict
+
+