spacr 0.2.5__py3-none-any.whl → 0.2.8__py3-none-any.whl

spacr/gui_utils.py

@@ -1,20 +1,48 @@
-import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback, pyautogui
-import traceback
+import os, io, sys, ast, ctypes, ast, sqlite3, requests, time, traceback, torch
 import tkinter as tk
 from tkinter import ttk
 import matplotlib
 import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 from huggingface_hub import list_repo_files
-import traceback
+import psutil
 
-from . gui_core import initiate_root
-from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo, set_default_font
+from .gui_elements import AnnotateApp, spacrEntry, spacrCheck, spacrCombo
 
 try:
     ctypes.windll.shcore.SetProcessDpiAwareness(True)
 except AttributeError:
     pass
+
+def initialize_cuda():
+    """
+    Initializes CUDA in the main process by performing a simple GPU operation.
+    """
+    if torch.cuda.is_available():
+        # Allocate a small tensor on the GPU
+        _ = torch.tensor([0.0], device='cuda')
+        print("CUDA initialized in the main process.")
+    else:
+        print("CUDA is not available.")
+
+def set_high_priority(process):
+    try:
+        p = psutil.Process(process.pid)
+        if os.name == 'nt':  # Windows
+            p.nice(psutil.HIGH_PRIORITY_CLASS)
+        else:  # Unix-like systems
+            p.nice(-10)  # Adjusted priority level
+        print(f"Successfully set high priority for process: {process.pid}")
+    except psutil.AccessDenied as e:
+        print(f"Access denied when trying to set high priority for process {process.pid}: {e}")
+    except psutil.NoSuchProcess as e:
+        print(f"No such process {process.pid}: {e}")
+    except Exception as e:
+        print(f"Failed to set high priority for process {process.pid}: {e}")
+
+def set_cpu_affinity(process):
+    p = psutil.Process(process.pid)
+    p.cpu_affinity(list(range(os.cpu_count())))
     
 def proceed_with_app(root, app_name, app_func):
     # Clear the current content frame
@@ -29,6 +57,10 @@ def proceed_with_app(root, app_name, app_func):
     app_func(root.content_frame)
 
 def load_app(root, app_name, app_func):
+    # Clear the canvas if it exists
+    if root.canvas is not None:
+        root.clear_frame(root.canvas)
+
     # Cancel all scheduled after tasks
     if hasattr(root, 'after_tasks'):
         for task in root.after_tasks:
@@ -38,42 +70,72 @@ def load_app(root, app_name, app_func):
     # Exit functionality only for the annotation and make_masks apps
     if app_name not in ["Annotate", "make_masks"] and hasattr(root, 'current_app_exit_func'):
         root.next_app_func = proceed_with_app
-        root.next_app_args = (app_name, app_func)  # Ensure correct arguments
+        root.next_app_args = (app_name, app_func)
         root.current_app_exit_func()
     else:
         proceed_with_app(root, app_name, app_func)
-
-def parse_list_v1(value):
-    try:
-        parsed_value = ast.literal_eval(value)
-        if isinstance(parsed_value, list):
-            return parsed_value
-        else:
-            raise ValueError
-    except (ValueError, SyntaxError):
-        raise ValueError("Invalid format for list")
     
 def parse_list(value):
+    """
+    Parses a string representation of a list and returns the parsed list.
+
+    Args:
+        value (str): The string representation of the list.
+
+    Returns:
+        list: The parsed list.
+
+    Raises:
+        ValueError: If the input value is not a valid list format or contains mixed types or unsupported types.
+    """
     try:
         parsed_value = ast.literal_eval(value)
         if isinstance(parsed_value, list):
-            return parsed_value
+            # Check if the list elements are homogeneous (all int or all str)
+            if all(isinstance(item, int) for item in parsed_value):
+                return parsed_value
+            elif all(isinstance(item, str) for item in parsed_value):
+                return parsed_value
+            else:
+                raise ValueError("List contains mixed types or unsupported types")
         else:
             raise ValueError(f"Expected a list but got {type(parsed_value).__name__}")
     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):
-    from .gui_elements import set_dark_style
+    """
+    Create an input field in the specified frame.
+
+    Args:
+        frame (tk.Frame): The frame in which the input field will be created.
+        label_text (str): The text to be displayed as the label for the input field.
+        row (int): The row in which the input field will be placed.
+        var_type (str, optional): The type of input field to create. Defaults to 'entry'.
+        options (list, optional): The list of options for a combo box input field. Defaults to None.
+        default_value (str, optional): The default value for the input field. Defaults to None.
+
+    Returns:
+        tuple: A tuple containing the label, input widget, variable, and custom frame.
+
+    Raises:
+        Exception: If an error occurs while creating the input field.
+
+    """
+    from .gui_elements import set_dark_style, set_element_size
+    
     label_column = 0
     widget_column = 0  # Both label and widget will be in the same column
 
     style_out = set_dark_style(ttk.Style())
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size']
     size_dict = set_element_size()
     size_dict['settings_width'] = size_dict['settings_width'] - int(size_dict['settings_width']*0.1)
 
     # Replace underscores with spaces and capitalize the first letter
+
     label_text = label_text.replace('_', ' ').capitalize()
 
     # Configure the column widths
@@ -86,34 +148,37 @@ def create_input_field(frame, label_text, row, var_type='entry', options=None, d
     # Apply styles to custom frame
     custom_frame.update_idletasks()
     custom_frame.config(highlightbackground=style_out['bg_color'], highlightthickness=1, bd=2)
-    #custom_frame.bind("<Enter>", lambda e: custom_frame.config(highlightbackground=style_out['active_color']))
-    #custom_frame.bind("<Leave>", lambda e: custom_frame.config(highlightbackground="white"))
 
     # Create and configure the label
-    label = ttk.Label(custom_frame, text=label_text, background=style_out['bg_color'], foreground=style_out['fg_color'], font=(style_out['font_family'], style_out['font_size']), anchor='e', justify='right')
+    label = tk.Label(custom_frame, text=label_text, bg=style_out['bg_color'], fg=style_out['fg_color'], font=font_loader.get_font(size=font_size), anchor='e', justify='right')
     label.grid(column=label_column, row=0, sticky=tk.W, padx=(5, 2), pady=5)  # Place the label in the first row
 
     # Create and configure the input widget based on var_type
-    if var_type == 'entry':
-        var = tk.StringVar(value=default_value)
-        entry = spacrEntry(custom_frame, textvariable=var, outline=False, width=size_dict['settings_width'])
-        entry.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the entry in the second row
-        return (label, entry, var, custom_frame)  # 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 = spacrCheck(custom_frame, text="", variable=var)
-        check.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the checkbutton in the second row
-        return (label, check, var, custom_frame)  # Return both the label and the checkbutton, and the variable
-    elif var_type == 'combo':
-        var = tk.StringVar(value=default_value)  # Set default value
-        combo = spacrCombo(custom_frame, textvariable=var, values=options, width=size_dict['settings_width'])  # Apply TCombobox style
-        combo.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the combobox in the second row
-        if default_value:
-            combo.set(default_value)
-        return (label, combo, var, custom_frame)  # Return both the label and the combobox, and the variable
-    else:
-        var = None  # Placeholder in case of an undefined var_type
-        return (label, None, var, custom_frame)
+    try:
+        if var_type == 'entry':
+            var = tk.StringVar(value=default_value)
+            entry = spacrEntry(custom_frame, textvariable=var, outline=False, width=size_dict['settings_width'])
+            entry.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the entry in the second row
+            return (label, entry, var, custom_frame)  # 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 = spacrCheck(custom_frame, text="", variable=var)
+            check.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the checkbutton in the second row
+            return (label, check, var, custom_frame)  # Return both the label and the checkbutton, and the variable
+        elif var_type == 'combo':
+            var = tk.StringVar(value=default_value)  # Set default value
+            combo = spacrCombo(custom_frame, textvariable=var, values=options, width=size_dict['settings_width'])  # Apply TCombobox style
+            combo.grid(column=widget_column, row=1, sticky=tk.W, padx=(2, 5), pady=5)  # Place the combobox in the second row
+            if default_value:
+                combo.set(default_value)
+            return (label, combo, var, custom_frame)  # Return both the label and the combobox, and the variable
+        else:
+            var = None  # Placeholder in case of an undefined var_type
+            return (label, None, var, custom_frame)
+    except Exception as e:
+        traceback.print_exc()
+        print(f"Error creating input field: {e}")
+        print(f"Wrong type for {label_text} Expected {var_type}")
 
 def process_stdout_stderr(q):
     """
@@ -141,16 +206,6 @@ def cancel_after_tasks(frame):
             frame.after_cancel(task)
         frame.after_tasks.clear()
 
-def main_thread_update_function(root, q, fig_queue, canvas_widget):
-    try:
-        #ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
-        while not q.empty():
-            message = q.get_nowait()
-    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))
-
 def annotate(settings):
     from .settings import set_annotate_default_settings
     settings = set_annotate_default_settings(settings)
@@ -181,6 +236,12 @@ def annotate(settings):
 
 def generate_annotate_fields(frame):
     from .settings import set_annotate_default_settings
+    from .gui_elements import set_dark_style
+
+    style_out = set_dark_style(ttk.Style())
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size'] - 2
+
     vars_dict = {}
     settings = set_annotate_default_settings(settings={})
     
@@ -192,8 +253,8 @@ def generate_annotate_fields(frame):
 
     # Arrange input fields and labels
     for row, (name, data) in enumerate(vars_dict.items()):
-        ttk.Label(frame, text=f"{name.replace('_', ' ').capitalize()}:",
-                  background="black", foreground="white").grid(row=row, column=0)
+        tk.Label(frame, text=f"{name.replace('_', ' ').capitalize()}:", bg=style_out['bg_color'], fg=style_out['fg_color'], font=font_loader.get_font(size=font_size)).grid(row=row, column=0)
+        #ttk.Label(frame, text=f"{name.replace('_', ' ').capitalize()}:", background="black", foreground="white").grid(row=row, column=0)
         if isinstance(data['value'], list):
             # Convert lists to comma-separated strings
             data['entry'].insert(0, ','.join(map(str, data['value'])))
@@ -321,27 +382,6 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     # Call load_images after setting up the root window
     app.load_images()
 
-def set_element_size():
-
-    screen_width, screen_height = pyautogui.size()
-    screen_area = screen_width * screen_height
-    
-    # Calculate sizes based on screen dimensions
-    btn_size = int((screen_area * 0.002) ** 0.5)  # Button size as a fraction of screen area
-    bar_size = screen_height // 30  # Bar size based on screen height
-    settings_width = screen_width // 4  # Settings panel width as a fraction of screen width
-    panel_width = screen_width - settings_width  # Panel width as a fraction of screen width
-    panel_height = screen_height // 10  # Panel height as a fraction of screen height
-    
-    size_dict = {
-        'btn_size': btn_size,
-        'bar_size': bar_size,
-        'settings_width': settings_width,
-        'panel_width': panel_width,
-        'panel_height': panel_height
-    }
-    return size_dict
-
 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)]
@@ -351,7 +391,9 @@ def convert_settings_dict_for_gui(settings):
     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]'),
+        'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
         'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
         'cell_mask_dim': ('combo', chans, None),
         'cell_chann_dim': ('combo', chans, None),
         'nucleus_mask_dim': ('combo', chans, None),
@@ -397,6 +439,7 @@ def convert_settings_dict_for_gui(settings):
             variables[key] = ('entry', None, str(value))
         else:
             variables[key] = ('entry', None, str(value))
+    
     return variables
 
 
@@ -440,15 +483,15 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
         # Restore the original plt.show function
         plt.show = original_show
 
-
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
+    
     from .gui_utils import process_stdout_stderr
-    from .core import preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
+    from .core import generate_image_umap, preprocess_generate_masks, generate_ml_scores, identify_masks_finetune, check_cellpose_models, analyze_recruitment, train_cellpose, compare_cellpose_masks, analyze_plaques, generate_dataset, apply_model_to_tar
     from .io import generate_cellpose_train_test
     from .measure import measure_crop
     from .sim import run_multiple_simulations
-    from .deep_spacr import train_test_model
-    from .sequencing import analyze_reads, map_barcodes_folder, perform_regression
+    from .deep_spacr import deep_spacr
+    from .sequencing import generate_barecode_mapping, perform_regression
     process_stdout_stderr(q)
 
     print(f'run_function_gui settings_type: {settings_type}') 
@@ -462,12 +505,9 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     elif settings_type == 'simulation':
         function = run_multiple_simulations
         imports = 1
-    elif settings_type == 'sequencing':
-        function = analyze_reads
-        imports = 1
     elif settings_type == 'classify':
-        function = train_test_model
-        imports = 2
+        function = deep_spacr
+        imports = 1
     elif settings_type == 'train_cellpose':
         function = train_cellpose
         imports = 1
@@ -481,14 +521,17 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
         function = check_cellpose_models
         imports = 1
     elif settings_type == 'map_barcodes':
-        function = map_barcodes_folder
-        imports = 2
+        function = generate_barecode_mapping
+        imports = 1
     elif settings_type == 'regression':
         function = perform_regression
         imports = 2
     elif settings_type == 'recruitment':
         function = analyze_recruitment
-        imports = 2
+        imports = 1
+    elif settings_type == 'umap':
+        function = generate_image_umap
+        imports = 1
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
     try:
@@ -499,7 +542,6 @@ def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     finally:
         stop_requested.value = 1
 
-
 def hide_all_settings(vars_dict, categories):
     """
     Function to initially hide all settings in the GUI.
@@ -526,38 +568,49 @@ def hide_all_settings(vars_dict, categories):
     return vars_dict
 
 def setup_frame(parent_frame):
-    from .gui_elements import set_dark_style, set_default_font
+    from .gui_elements import set_dark_style, set_element_size
 
     style = ttk.Style(parent_frame)
     size_dict = set_element_size()
     style_out = set_dark_style(style)
 
-    settings_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['settings_width'], bg=style_out['bg_color'])
-    vertical_container = tk.PanedWindow(parent_frame, orient=tk.VERTICAL, width=size_dict['panel_width'], bg=style_out['bg_color'])
-    horizontal_container = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'], width=size_dict['panel_width'], bg=style_out['bg_color'])
+    # Configure the main layout using PanedWindow
+    main_paned = tk.PanedWindow(parent_frame, orient=tk.HORIZONTAL, bg=style_out['bg_color'], bd=0, relief='flat')
+    main_paned.grid(row=0, column=0, sticky="nsew")
 
+    # Allow the main_paned to expand and fill the window
     parent_frame.grid_rowconfigure(0, weight=1)
-    parent_frame.grid_rowconfigure(1, weight=0)
-    parent_frame.grid_columnconfigure(0, weight=0)
-    parent_frame.grid_columnconfigure(1, weight=1)
+    parent_frame.grid_columnconfigure(0, weight=1)
 
-    settings_container.grid(row=0, column=0, rowspan=2, sticky="nsew")
-    vertical_container.grid(row=0, column=1, sticky="nsew")
-    horizontal_container.grid(row=1, column=1, sticky="ew")
+    # Create the settings container on the left
+    settings_container = tk.PanedWindow(main_paned, orient=tk.VERTICAL, width=size_dict['settings_width'], bg=style_out['bg_color'], bd=0, relief='flat')
+    main_paned.add(settings_container, minsize=100)  # Allow resizing with a minimum size
 
-    # Ensure settings_container maintains its width
-    settings_container.grid_propagate(False)
-    settings_container.update_idletasks()
+    # Create a right container frame to hold vertical and horizontal containers
+    right_frame = tk.Frame(main_paned, bg=style_out['bg_color'], bd=0, highlightthickness=0, relief='flat')
+    main_paned.add(right_frame, stretch="always")
 
-    tk.Label(settings_container, text="Settings Container", bg=style_out['bg_color']).grid(row=0, column=0, sticky="ew")
+    # Configure the right_frame grid layout
+    right_frame.grid_rowconfigure(0, weight=1)  # Vertical container expands
+    right_frame.grid_rowconfigure(1, weight=0)  # Horizontal container at bottom
+    right_frame.grid_columnconfigure(0, weight=1)
 
-    set_dark_style(style, parent_frame, [settings_container, vertical_container, horizontal_container])
-    
-    size = style_out['font_size'] - 2
-    set_default_font(parent_frame, font_name=style_out['font_family'], size=size)
+    # Inside right_frame, add vertical_container at the top
+    vertical_container = tk.PanedWindow(right_frame, orient=tk.VERTICAL, bg=style_out['bg_color'], bd=0, relief='flat')
+    vertical_container.grid(row=0, column=0, sticky="nsew")
+
+    # Add horizontal_container aligned with the bottom of settings_container
+    horizontal_container = tk.PanedWindow(right_frame, orient=tk.HORIZONTAL, height=size_dict['panel_height'], bg=style_out['bg_color'], bd=0, relief='flat')
+    horizontal_container.grid(row=1, column=0, sticky="ew")
+
+    # Example content for settings_container
+    tk.Label(settings_container, text="Settings Container", bg=style_out['bg_color']).pack(fill=tk.BOTH, expand=True)
+
+    set_dark_style(style, parent_frame, [settings_container, vertical_container, horizontal_container, main_paned])
 
     return parent_frame, vertical_container, horizontal_container, settings_container
 
+
 def download_hug_dataset(q, vars_dict):
     dataset_repo_id = "einarolafsson/toxo_mito"
     settings_repo_id = "einarolafsson/spacr_settings"
@@ -638,3 +691,7 @@ def download_dataset(q, repo_id, subfolder, local_dir=None, retries=5, delay=5):
             time.sleep(delay)
 
     raise Exception("Failed to download files after multiple attempts.")
+
+def ensure_after_tasks(frame):
+    if not hasattr(frame, 'after_tasks'):
+        frame.after_tasks = []