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

spacr/gui_core.py

@@ -1,29 +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
+from multiprocessing import Process, Value, Queue, set_start_method
 from multiprocessing.sharedctypes import Synchronized
-from multiprocessing import set_start_method
 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
@@ -46,26 +41,116 @@ def initiate_abort():
         thread_control["run_thread"].join()
         thread_control["run_thread"] = None
 
-def start_process_v1(q, fig_queue, settings_type='mask'):
-    global thread_control, vars_dict
-    from .settings import check_settings, expected_types
+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)
 
-    settings = check_settings(vars_dict, expected_types, q)
-    if thread_control.get("run_thread") is not None:
-        initiate_abort()
-    stop_requested = Value('i', 0)  # multiprocessing shared value for inter-process communication
-    thread_control["stop_requested"] = stop_requested
+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':
-        thread_control["run_thread"] = Process(target=run_mask_gui, args=(settings, q, fig_queue, stop_requested))
+        function = preprocess_generate_masks
+        imports = 2
     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))
+        function = measure_crop
+        imports = 1
+    elif settings_type == 'simulation':
+        function = run_multiple_simulations
+        imports = 1
     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))
-    thread_control["run_thread"].start()
+        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
@@ -85,25 +170,15 @@ def start_process(q=None, fig_queue=None, settings_type='mask'):
     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
 
-    process_args = (settings, q, fig_queue, stop_requested)
-
-    if settings_type == 'mask':
-        thread_control["run_thread"] = Process(target=run_mask_gui, args=process_args)
-    elif settings_type == 'measure':
-        thread_control["run_thread"] = Process(target=run_measure_gui, args=process_args)
-    elif settings_type == 'classify':
-        thread_control["run_thread"] = Process(target=run_classify_gui, args=process_args)
-    elif settings_type == 'sequencing':
-        thread_control["run_thread"] = Process(target=run_sequencing_gui, args=process_args)
-    elif settings_type == 'umap':
-        thread_control["run_thread"] = Process(target=run_umap_gui, args=process_args)
+    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'):
@@ -194,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)
@@ -217,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")
@@ -353,18 +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', settings_row=5, run=True, abort=True, download=True, import_btn=True):
+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
+
+    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")
 
@@ -393,6 +502,16 @@ 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)
+
+    # 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)
+
     return button_scrollable_frame
 
 def hide_all_settings(vars_dict, categories):
@@ -529,80 +648,55 @@ 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
+    from .gui_utils import main_thread_update_function
+    from .gui import gui_app
     set_start_method('spawn', force=True)
-
-    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
     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()