spacr 0.1.6__py3-none-any.whl → 0.1.8__py3-none-any.whl

spacr/gui_core.py

@@ -1,27 +1,24 @@
-import os, traceback, ctypes, matplotlib, requests, csv, re
+import os, traceback, ctypes, matplotlib, requests, csv, matplotlib, time, requests
+import matplotlib.pyplot as plt
 matplotlib.use('Agg')
 import tkinter as tk
 from tkinter import ttk
-import tkinter.font as tkFont
 from tkinter import filedialog
-from tkinter import font as tkFont
-from multiprocessing import Process, Value, Queue, Manager, set_start_method
+from multiprocessing import Process, Value, Queue, set_start_method
+from multiprocessing.sharedctypes import Synchronized
 from tkinter import ttk, scrolledtext
 from matplotlib.figure import Figure
 from matplotlib.backends.backend_tkagg import FigureCanvasTkAgg
-import time
-import requests
 from huggingface_hub import list_repo_files
 
-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 create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrCheckbutton, spacrDropdownMenu ,set_dark_style, set_default_font
-from . gui_run import run_mask_gui, run_measure_gui, run_classify_gui, run_sequencing_gui, run_umap_gui
-
 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 create_menu_bar, spacrButton, spacrLabel, spacrFrame, spacrDropdownMenu ,set_dark_style, set_default_font
+
 # Define global variables
 q = None
 console_output = None
@@ -37,40 +34,155 @@ thread_control = {"run_thread": None, "stop_requested": False}
 
 def initiate_abort():
     global thread_control
-    if thread_control.get("stop_requested") is not None:
-        if isinstance(thread_control["stop_requested"], Value):
-            thread_control["stop_requested"].value = 1
-
+    if isinstance(thread_control.get("stop_requested"), Synchronized):
+        thread_control["stop_requested"].value = 1
     if thread_control.get("run_thread") is not None:
-        thread_control["run_thread"].join(timeout=5)
-        if thread_control["run_thread"].is_alive():
-            thread_control["run_thread"].terminate()
+        thread_control["run_thread"].terminate()
+        thread_control["run_thread"].join()
         thread_control["run_thread"] = None
 
-def start_process(q, fig_queue, settings_type='mask'):
+def spacrFigShow(fig_queue=None):
+    """
+    Replacement for plt.show() that queues figures instead of displaying them.
+    """
+    fig = plt.gcf()
+    if fig_queue:
+        fig_queue.put(fig)
+    else:
+        fig.show()
+    plt.close(fig)
+
+def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imports=1):
+
+    """
+    Wraps the run_multiple_simulations function to integrate with GUI processes.
+    
+    Parameters:
+    - settings: dict, The settings for the run_multiple_simulations function.
+    - q: multiprocessing.Queue, Queue for logging messages to the GUI.
+    - fig_queue: multiprocessing.Queue, Queue for sending figures to the GUI.
+    """
+
+    # Temporarily override plt.show
+    original_show = plt.show
+    plt.show = lambda: spacrFigShow(fig_queue)
+
+    try:
+        if imports == 1:
+            function(settings=settings)
+        elif imports == 2:
+            function(src=settings['src'], settings=settings)
+    except Exception as e:
+        # Send the error message to the GUI via the queue
+        errorMessage = f"Error during processing: {e}"
+        q.put(errorMessage) 
+        traceback.print_exc()
+    finally:
+        # 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 .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
+    process_stdout_stderr(q)    
+    
+    if settings_type == 'mask':
+        function = preprocess_generate_masks
+        imports = 2
+    elif settings_type == 'measure':
+        function = measure_crop
+        imports = 1
+    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
+    elif settings_type == 'train_cellpose':
+        function = train_cellpose
+        imports = 1
+    elif settings_type == 'ml_analyze':
+        function = generate_ml_scores
+        imports = 2
+    elif settings_type == 'cellpose_masks':
+        function = identify_masks_finetune
+        imports = 1
+    elif settings_type == 'cellpose_all':
+        function = check_cellpose_models
+        imports = 1
+    elif settings_type == 'map_barcodes':
+        function = map_barcodes_folder
+        imports = 2
+    elif settings_type == 'regression':
+        function = perform_regression
+        imports = 2
+    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:
+        function_gui_wrapper(function, settings, q, fig_queue, imports)
+    except Exception as e:
+        q.put(f"Error during processing: {e}")
+        traceback.print_exc()
+    finally:
+        stop_requested.value = 1
+
+def start_process(q=None, fig_queue=None, settings_type='mask'):
     global thread_control, vars_dict
-    from .settings import check_settings
+    from .settings import check_settings, expected_types
+
+    if q is None:
+        q = Queue()
+    if fig_queue is None:
+        fig_queue = Queue()
+
+    try:
+        settings = check_settings(vars_dict, expected_types, q)
+    except ValueError as e:
+        q.put(f"Error: {e}")
+        return
 
-    settings = check_settings(vars_dict)
     if thread_control.get("run_thread") is not None:
         initiate_abort()
-    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
+    
+    stop_requested = Value('i', 0)
     thread_control["stop_requested"] = stop_requested
-    if settings_type == 'mask':
-        thread_control["run_thread"] = Process(target=run_mask_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'measure':
-        thread_control["run_thread"] = Process(target=run_measure_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'classify':
-        thread_control["run_thread"] = Process(target=run_classify_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'sequencing':
-        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=(settings, q, fig_queue, stop_requested))
-    elif settings_type == 'umap':
-        thread_control["run_thread"] = Process(target=run_umap_gui, args=(settings, q, fig_queue, stop_requested))
+
+    process_args = (settings_type, settings, q, fig_queue, stop_requested)
+    if settings_type in ['mask','measure','simulation','sequencing','classify','cellpose_dataset','train_cellpose','ml_analyze','cellpose_masks','cellpose_all','map_barcodes','regression','recruitment','plaques','cellpose_compare','vision_scores','vision_dataset']:
+        thread_control["run_thread"] = Process(target=run_function_gui, args=process_args)
+    else:
+        q.put(f"Error: Unknown settings type '{settings_type}'")
+        return
     thread_control["run_thread"].start()
 
 def import_settings(settings_type='mask'):
-
-    global vars_dict, scrollable_frame
+    global vars_dict, scrollable_frame, button_scrollable_frame
     from .settings import generate_fields
 
     def read_settings_from_csv(csv_file_path):
@@ -98,6 +210,7 @@ def import_settings(settings_type='mask'):
     if not csv_file_path:  # If no file is selected, return early
         return
     
+    #vars_dict = hide_all_settings(vars_dict, categories=None)
     csv_settings = read_settings_from_csv(csv_file_path)
     if settings_type == 'mask':
         settings = set_default_settings_preprocess_generate_masks(src='path', settings={})
@@ -115,6 +228,7 @@ def import_settings(settings_type='mask'):
     variables = convert_settings_dict_for_gui(settings)
     new_settings = update_settings_from_csv(variables, csv_settings)
     vars_dict = generate_fields(new_settings, scrollable_frame)
+    vars_dict = hide_all_settings(vars_dict, categories=None)
 
 def convert_settings_dict_for_gui(settings):
     variables = {}
@@ -155,15 +269,19 @@ def convert_settings_dict_for_gui(settings):
             variables[key] = ('entry', None, str(value))
     return variables
 
-def setup_settings_panel(vertical_container, settings_type='mask', frame_height=500, frame_width=1000):
+def setup_settings_panel(vertical_container, settings_type='mask', window_dimensions=[500, 1000]):
     global vars_dict, scrollable_frame
-    from .settings import set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, get_analyze_reads_default_settings, set_default_umap_image_settings, generate_fields
+    from .settings import descriptions, get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model, get_analyze_reads_default_settings, set_default_umap_image_settings, generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+
+    width = (window_dimensions[0])//6
+    height = window_dimensions[1]
 
-    settings_frame = tk.Frame(vertical_container, bg='black', height=frame_height, width=frame_width)
+    # Settings Frame
+    settings_frame = tk.Frame(vertical_container, bg='black', height=height, width=width)
     vertical_container.add(settings_frame, stretch="always")
     settings_label = spacrLabel(settings_frame, text="Settings", background="black", foreground="white", anchor='center', justify='center', align="center")
     settings_label.grid(row=0, column=0, pady=10, padx=10)
-    scrollable_frame = spacrFrame(settings_frame, bg='black', width=frame_width)
+    scrollable_frame = spacrFrame(settings_frame, bg='black', width=width)
     scrollable_frame.grid(row=1, column=0, sticky="nsew")
     settings_frame.grid_rowconfigure(1, weight=1)
     settings_frame.grid_columnconfigure(0, weight=1)
@@ -178,9 +296,36 @@ def setup_settings_panel(vertical_container, settings_type='mask', frame_height=
         settings = get_analyze_reads_default_settings(settings={})
     elif settings_type == 'umap':
         settings = set_default_umap_image_settings(settings={})
+    elif settings_type == 'train_cellpose':
+        settings = get_train_cellpose_default_settings(settings={})
+    elif settings_type == 'ml_analyze':
+        settings = set_default_analyze_screen(settings={})
+    elif settings_type == 'cellpose_masks':
+        settings = get_identify_masks_finetune_default_settings(settings={})
+    elif settings_type == 'cellpose_all':
+        settings = get_check_cellpose_models_default_settings(settings={})
+    elif settings_type == 'map_barcodes':
+        settings = get_map_barcodes_default_settings(settings={})
+    elif settings_type == 'regression':
+        settings = get_perform_regression_default_settings(settings={})
+    elif settings_type == 'recruitment':
+        settings = get_analyze_recruitment_default_settings(settings={})
+    #elif settings_type == 'simulation':
+    #    settings = set_default_
+    #elif settings_type == 'cellpose_dataset':
+    #    settings = set_default_
+    #elif settings_type == 'plaques':
+    #    settings = set_default_
+    #elif settings_type == 'cellpose_compare':
+    #    settings = set_default_
+    #elif settings_type == 'vision_scores':
+    #    settings = set_default_
+    #elif settings_type == 'vision_dataset':
+    #    settings = set_default_
     else:
         raise ValueError(f"Invalid settings type: {settings_type}")
 
+
     variables = convert_settings_dict_for_gui(settings)
     vars_dict = generate_fields(variables, scrollable_frame)
     print("Settings panel setup complete")
@@ -314,19 +459,21 @@ 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
+    from .settings import descriptions
 
-def setup_button_section(horizontal_container, settings_type='mask', settings_row=5, run=True, abort=True, download=True, import_btn=True):
-    global button_frame, run_button, abort_button, download_dataset_button, import_button, q, fig_queue, vars_dict
+    width = (window_dimensions[0])//8
+    height = window_dimensions[1]
 
-    button_frame = tk.Frame(horizontal_container, bg='black')
+    button_frame = tk.Frame(horizontal_container, bg='black', height=height, width=width)
     horizontal_container.add(button_frame, stretch="always", sticky="nsew")
     button_frame.grid_rowconfigure(0, weight=0)
     button_frame.grid_rowconfigure(1, weight=1)
     button_frame.grid_columnconfigure(0, weight=1)
 
-    categories_label = spacrLabel(button_frame, text="Categories", background="black", foreground="white", font=('Helvetica', 12), anchor='center', justify='center', align="center")  # Increase font size
+    categories_label = spacrLabel(button_frame, text="Categories", background="black", foreground="white", font=('Helvetica', 12), anchor='center', justify='center', align="center")
     categories_label.grid(row=0, column=0, pady=10, padx=10)
-
     button_scrollable_frame = spacrFrame(button_frame, bg='black')
     button_scrollable_frame.grid(row=1, column=0, sticky="nsew")
 
@@ -355,62 +502,41 @@ def setup_button_section(horizontal_container, settings_type='mask', settings_ro
     # Call toggle_settings after vars_dict is initialized
     if vars_dict is not None:
         toggle_settings(button_scrollable_frame)
-    return button_scrollable_frame
 
-def toggle_settings_v1(button_scrollable_frame):
-    global vars_dict
-    from .settings import categories
+    # Description frame
+    description_frame = tk.Frame(horizontal_container, bg='black', height=height, width=width)
+    horizontal_container.add(description_frame, stretch="always", sticky="nsew")
+    description_frame.grid_columnconfigure(0, weight=1)  # Make the column stretch
+    description_label = tk.Label(description_frame, text="Module Description", bg='black', fg='white', anchor='nw', justify='left', wraplength=width-50)
+    description_label.grid(row=0, column=0, pady=50, padx=20, sticky='nsew')  # Use sticky='nsew' to stretch the label
+    description_text = descriptions.get(settings_type, "No description available for this module.")
+    description_label.config(text=description_text)
 
-    if vars_dict is None:
-        raise ValueError("vars_dict is not initialized.")
+    return button_scrollable_frame
 
-    def toggle_category(settings, var):
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                if var.get() == 0:
-                    label.grid_remove()
-                    widget.grid_remove()
-                else:
-                    label.grid()
-                    widget.grid()
+def hide_all_settings(vars_dict, categories):
+    """
+    Function to initially hide all settings in the GUI.
+
+    Parameters:
+    - categories: dict, The categories of settings with their corresponding settings.
+    - vars_dict: dict, The dictionary containing the settings and their corresponding widgets.
+    """
 
-    row = 1
-    col = 3 
-    category_idx = 0
+    if categories is None:
+        from .settings import categories
 
     for category, settings in categories.items():
         if any(setting in vars_dict for setting in settings):
-            category_var = tk.IntVar(value=0)
-            vars_dict[category] = (None, None, category_var)
-            toggle = spacrCheckbutton(
-                button_scrollable_frame.scrollable_frame, 
-                text=category, 
-                variable=category_var, 
-                command=lambda cat=settings, var=category_var: toggle_category(cat, var)
-            )
-            # Directly set the style
-            style = ttk.Style()
-            font_style = tkFont.Font(family="Helvetica", size=12, weight="bold")
-            style.configure('Spacr.TCheckbutton', font=font_style, background='black', foreground='#ffffff', indicatoron=False, relief='flat')
-            style.map('Spacr.TCheckbutton', background=[('selected', 'black'), ('active', 'black')], foreground=[('selected', '#ffffff'), ('active', '#ffffff')])
-            toggle.configure(style='Spacr.TCheckbutton')
-            toggle.grid(row=row, column=col, sticky="w", pady=2, padx=2)
-            #row += 1
-            col += 1
-            category_idx += 1
-
-            if category_idx % 4 == 0:  
-                row += 1
-                col = 2
-
-    for settings in categories.values():
-        for setting in settings:
-            if setting in vars_dict:
-                label, widget, _ = vars_dict[setting]
-                label.grid_remove()
-                widget.grid_remove()
-
+            vars_dict[category] = (None, None, tk.IntVar(value=0))
+            
+            # Initially hide all settings
+            for setting in settings:
+                if setting in vars_dict:
+                    label, widget, _ = vars_dict[setting]
+                    label.grid_remove()
+                    widget.grid_remove()
+    return vars_dict
 
 def toggle_settings(button_scrollable_frame):
     global vars_dict
@@ -449,16 +575,7 @@ def toggle_settings(button_scrollable_frame):
     non_empty_categories = [category for category, settings in categories.items() if any(setting in vars_dict for setting in settings)]
     category_dropdown = spacrDropdownMenu(button_scrollable_frame.scrollable_frame, category_var, non_empty_categories, command=on_category_select)
     category_dropdown.grid(row=1, column=3, sticky="ew", pady=2, padx=2)
-
-    for category, settings in categories.items():
-        if any(setting in vars_dict for setting in settings):
-            vars_dict[category] = (None, None, tk.IntVar(value=0))
-            # Initially hide all settings
-            for setting in settings:
-                if setting in vars_dict:
-                    label, widget, _ = vars_dict[setting]
-                    label.grid_remove()
-                    widget.grid_remove()
+    vars_dict = hide_all_settings(vars_dict, categories)
 
 def process_fig_queue():
     global canvas, fig_queue, canvas_widget, parent_frame
@@ -531,78 +648,55 @@ def setup_frame(parent_frame):
     return parent_frame, vertical_container, horizontal_container
 
 def initiate_root(parent, settings_type='mask'):
-
-    def main_thread_update_function(root, q, fig_queue, canvas_widget, progress_label):
-        try:
-            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)
-        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))
-
-    global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, progress_label, button_scrollable_frame
+    global q, fig_queue, parent_frame, scrollable_frame, button_frame, vars_dict, canvas, canvas_widget, progress_label, progress_output, button_scrollable_frame
+    from .gui_utils import main_thread_update_function
+    from .gui import gui_app
+    set_start_method('spawn', force=True)
     print("Initializing root with settings_type:", settings_type)
+
     parent_frame = parent
+    parent_frame.update_idletasks()
+    frame_width = int(parent_frame.winfo_width())
+    frame_height = int(parent_frame.winfo_height())
+    print(frame_width, frame_height)
+    dims = [frame_width, frame_height]
 
     if not hasattr(parent_frame, 'after_tasks'):
         parent_frame.after_tasks = []
 
+    # Clear previous content instead of destroying the root
     for widget in parent_frame.winfo_children():
-        if widget.winfo_exists():
-            try:
-                widget.destroy()
-            except tk.TclError as e:
-                print(f"Error destroying widget: {e}")
+        try:
+            widget.destroy()
+        except tk.TclError as e:
+            print(f"Error destroying widget: {e}")
 
     q = Queue()
     fig_queue = Queue()
     parent_frame, vertical_container, horizontal_container = setup_frame(parent_frame)
-    scrollable_frame, vars_dict = setup_settings_panel(horizontal_container, settings_type)  # Adjust height and width as needed
-    button_scrollable_frame = setup_button_section(horizontal_container, settings_type)
-    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)
+    if settings_type == 'annotate':
+        from .app_annotate import initiate_annotation_app
+        initiate_annotation_app(horizontal_container)
+    elif settings_type == 'make_masks':
+        from .app_make_masks import initiate_make_mask_app
+        initiate_make_mask_app(horizontal_container)
     else:
-        progress_output = None
+        scrollable_frame, vars_dict = setup_settings_panel(horizontal_container, settings_type, window_dimensions=dims)
+        button_scrollable_frame = setup_button_section(horizontal_container, settings_type, window_dimensions=dims)
+        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)
+        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))
+        parent_frame.after_tasks.append(after_id)
 
-    set_globals(q, console_output, parent_frame, vars_dict, canvas, canvas_widget, scrollable_frame, progress_label, fig_queue)
-    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))
-    parent_frame.after_tasks.append(after_id)
     print("Root initialization complete")
     return parent_frame, vars_dict
-
-def start_gui_app(settings_type='mask'):
-    global q, fig_queue, parent_frame, scrollable_frame, vars_dict, canvas, canvas_widget, progress_label
-    root = tk.Tk()
-    width = root.winfo_screenwidth()
-    height = root.winfo_screenheight()
-    root.geometry(f"{width}x{height}")
-    root.title(f"SpaCr: {settings_type.capitalize()}")
-    root.content_frame = tk.Frame(root)
-    print("Starting GUI app with settings_type:", settings_type)
-    initiate_root(root.content_frame, settings_type)
-    create_menu_bar(root)
-    root.mainloop()