spacr 0.1.76__tar.gz → 0.1.81__tar.gz

{spacr-0.1.76/spacr.egg-info → spacr-0.1.81}/PKG-INFO

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

{spacr-0.1.76 → spacr-0.1.81}/setup.py

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

{spacr-0.1.76 → spacr-0.1.81}/spacr/core.py

@@ -994,7 +994,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     model = torch.load(model_path)
     
     dataset = TarImageDataset(tar_path, transform=transform)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_jobs=n_jobs, pin_memory=True)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=n_jobs, pin_memory=True)
     
     model_name = os.path.splitext(os.path.basename(model_path))[0] 
     dataset_name = os.path.splitext(os.path.basename(tar_path))[0]  
@@ -1055,7 +1055,7 @@ def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True,
     
     print(f'Loading dataset in {src} with {len(src)} images')
     dataset = NoClassDataset(data_dir=src, transform=transform, shuffle=True, load_to_memory=False)
-    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_jobs=n_jobs)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, num_workers=n_jobs)
     print(f'Loaded {len(src)} images')
     
     result_loc = os.path.splitext(model_path)[0]+datetime.date.today().strftime('%y%m%d')+'_'+os.path.splitext(model_path)[1]+'_test_result.csv'
@@ -1404,10 +1404,10 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                 #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                 print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
-            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
         else:
-            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
         
     elif train_mode == 'irm':
         data = MyDataset(data_dir, classes, transform=transform, shuffle=shuffle, pin_memory=pin_memory)
@@ -1436,13 +1436,13 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
                     #val_dataset = augment_dataset(val_dataset, is_grayscale=(len(channels) == 1))
                     print(f'Data after augmentation: Train: {len(train_dataset)}')#, Validataion:{len(val_dataset)}')
 
-                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
-                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
 
                 train_loaders.append(train_loader)
                 val_loaders.append(val_loader)
             else:
-                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, n_jobs=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, num_workers=n_jobs if n_jobs is not None else 0, pin_memory=pin_memory)
                 train_loaders.append(train_loader)
                 val_loaders.append(None)
     

{spacr-0.1.76 → spacr-0.1.81}/spacr/gui.py

@@ -17,21 +17,33 @@ class MainApp(tk.Tk):
         style = ttk.Style()
         set_dark_style(style)
 
-        self.gui_apps = {
+        self.main_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"),
+            "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 sequensing data."),
-            "Umap": (lambda frame: initiate_root(frame, 'umap'), "Generate UMAP embedings with datapoints represented as images.")
+        }
+
+        self.additional_gui_apps = {
+            "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.")
         }
 
         self.selected_app = tk.StringVar()
         self.create_widgets()
 
-        if default_app in self.gui_apps:
-            self.load_app(default_app, self.gui_apps[default_app][0])
+        if default_app in self.main_gui_apps:
+            self.load_app(default_app, self.main_gui_apps[default_app][0])
+        elif default_app in self.additional_gui_apps:
+            self.load_app(default_app, self.additional_gui_apps[default_app][0])
 
     def create_widgets(self):
         # Create the menu bar
@@ -47,7 +59,7 @@ class MainApp(tk.Tk):
         self.content_frame = tk.Frame(self.canvas, bg="black")
         self.content_frame.pack(fill=tk.BOTH, expand=True)
 
-        # Create startup screen with buttons for each GUI app
+        # Create startup screen with buttons for each main GUI app and drop-down for additional apps
         self.create_startup_screen()
 
     def create_startup_screen(self):
@@ -68,7 +80,7 @@ class MainApp(tk.Tk):
         buttons_frame = tk.Frame(self.content_frame, bg="black")
         buttons_frame.pack(pady=10, expand=True, padx=10)
 
-        for i, (app_name, app_data) in enumerate(self.gui_apps.items()):
+        for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
             app_func, app_desc = app_data
 
             # Create custom button with text
@@ -78,6 +90,17 @@ class MainApp(tk.Tk):
             description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Helvetica', 12))
             description_label.grid(row=i, column=1, pady=10, padx=10, sticky="w")
 
+        # Add drop-down menu for additional apps
+        dropdown_frame = tk.Frame(buttons_frame, bg="black")
+        dropdown_frame.grid(row=len(self.main_gui_apps), column=0, columnspan=2, pady=20)
+
+        tk.Label(dropdown_frame, text="Additional Apps", bg="black", fg="white", font=('Helvetica', 12)).pack(side=tk.LEFT, padx=5)
+        self.additional_apps_var = tk.StringVar(value="Select an app")
+        dropdown = ttk.Combobox(dropdown_frame, textvariable=self.additional_apps_var, values=list(self.additional_gui_apps.keys()))
+        dropdown.pack(side=tk.LEFT, padx=5)
+        load_button = spacrButton(dropdown_frame, text="Load", command=self.load_additional_app, font=('Helvetica', 12))
+        load_button.pack(side=tk.LEFT, padx=5)
+
         # Ensure buttons have a fixed width
         buttons_frame.grid_columnconfigure(0, minsize=150)
         # Ensure descriptions expand as needed
@@ -135,6 +158,11 @@ class MainApp(tk.Tk):
         app_frame.pack(fill=tk.BOTH, expand=True)
         app_func(app_frame)
 
+    def load_additional_app(self):
+        selected_app = self.additional_apps_var.get()
+        if selected_app in self.additional_gui_apps:
+            self.load_app(selected_app, self.additional_gui_apps[selected_app][0])
+
     def clear_frame(self, frame):
         for widget in frame.winfo_children():
             widget.destroy()

{spacr-0.1.76 → spacr-0.1.81}/spacr/gui_core.py

@@ -1,27 +1,24 @@
-import os, traceback, ctypes, matplotlib, requests, csv
+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
 from tkinter import filedialog
-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, 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
@@ -44,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
@@ -83,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,7 +271,7 @@ def convert_settings_dict_for_gui(settings):
 
 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, descriptions
+    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]
@@ -219,9 +296,36 @@ def setup_settings_panel(vertical_container, settings_type='mask', window_dimens
         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")
@@ -402,8 +506,9 @@ def setup_button_section(horizontal_container, settings_type='mask',  window_dim
     # Description frame
     description_frame = tk.Frame(horizontal_container, bg='black', height=height, width=width)
     horizontal_container.add(description_frame, stretch="always", sticky="nsew")
-    description_label = tk.Label(description_frame, text="Module Description", bg='black', fg='white', anchor='nw', justify='left', wraplength=width//2-100)
-    description_label.pack(pady=10, padx=10)
+    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)
 

{spacr-0.1.76 → spacr-0.1.81}/spacr/gui_elements.py

@@ -1439,7 +1439,14 @@ def create_menu_bar(root):
         "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.")
+        "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.")
     }
 
     def load_app_wrapper(app_name, app_func):
@@ -1460,6 +1467,7 @@ def create_menu_bar(root):
     # Configure the menu for the root window
     root.config(menu=menu_bar)
 
+
 def set_dark_style(style):
     font_style = tkFont.Font(family="Helvetica", size=24)
     style.configure('TEntry', padding='5 5 5 5', borderwidth=1, relief='solid', fieldbackground='black', foreground='#ffffff', font=font_style)

{spacr-0.1.76 → spacr-0.1.81}/spacr/io.py

@@ -1693,7 +1693,7 @@ def _save_settings_to_db(settings):
     settings_df['setting_value'] = settings_df['setting_value'].apply(str)
     display(settings_df)
     # Determine the directory path
-    src = os.path.dirname(settings['input_folder'])
+    src = os.path.dirname(settings['src'])
     directory = f'{src}/measurements'
     # Create the directory if it doesn't exist
     os.makedirs(directory, exist_ok=True)

{spacr-0.1.76 → spacr-0.1.81}/spacr/measure.py

@@ -610,7 +610,7 @@ def _measure_crop_core(index, time_ls, file, settings):
     
     start = time.time() 
     try:
-        source_folder = os.path.dirname(settings['input_folder'])
+        source_folder = os.path.dirname(settings['src'])
         #if not os.path.basename(source_folder).endswith('merged'):
         #    source_folder = os.path.join(source_folder, 'merged')
         #    print(f'changed source_folder to {source_folder}')
@@ -619,7 +619,7 @@ def _measure_crop_core(index, time_ls, file, settings):
         #    return
 
         file_name = os.path.splitext(file)[0]
-        data = np.load(os.path.join(settings['input_folder'], file))
+        data = np.load(os.path.join(settings['src'], file))
         data_type = data.dtype
         if data_type not in ['uint8','uint16']:
             data_type_before = data_type
@@ -663,7 +663,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                     cell_mask, nucleus_mask = _relabel_parent_with_child_labels(cell_mask, nucleus_mask)
                     data[:, :, settings['cell_mask_dim']] = cell_mask
                     data[:, :, settings['nucleus_mask_dim']] = nucleus_mask
-                    save_folder = settings['input_folder']
+                    save_folder = settings['src']
                     np.save(os.path.join(save_folder, file), data)
         else:
             nucleus_mask = np.zeros_like(data[:, :, 0])
@@ -941,13 +941,13 @@ def measure_crop(settings):
     settings = get_measure_crop_settings(settings)
     settings = measure_test_mode(settings)
 
-    #src_fldr = settings['input_folder']
+    #src_fldr = settings['src']
     #if not os.path.basename(src_fldr).endswith('merged'):
-    #    settings['input_folder'] = os.path.join(src_fldr, 'merged')
-    #    print(f"changed input_folder to {src_fldr}")
+    #    settings['src'] = os.path.join(src_fldr, 'merged')
+    #    print(f"changed src to {src_fldr}")
 
-    #if not os.path.exists(settings['input_folder']):
-    #    print(f'input_folder: {settings["input_folder"]} does not exist')
+    #if not os.path.exists(settings['src']):
+    #    print(f'src: {settings["src"]} does not exist')
     #    return
     
     if settings['cell_mask_dim'] is None:
@@ -961,7 +961,7 @@ def measure_crop(settings):
     else:
         settings['cytoplasm'] = False
     
-    dirname = os.path.dirname(settings['input_folder'])
+    dirname = os.path.dirname(settings['src'])
     settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
     settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
     os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
@@ -997,7 +997,7 @@ def measure_crop(settings):
     
     _save_settings_to_db(settings)
 
-    files = [f for f in os.listdir(settings['input_folder']) if f.endswith('.npy')]
+    files = [f for f in os.listdir(settings['src']) if f.endswith('.npy')]
     n_jobs = settings['n_jobs'] or mp.cpu_count()-4
     print(f'using {n_jobs} cpu cores')
 
@@ -1018,7 +1018,7 @@ def measure_crop(settings):
 
     if settings['representative_images']:
         if settings['save_png']:
-            img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
+            img_fldr = os.path.join(os.path.dirname(settings['src']), 'data')
             sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
 
             for i, well_src in enumerate(sc_img_fldrs):
@@ -1037,7 +1037,7 @@ def measure_crop(settings):
                     #traceback.print_exc()
     
         if settings['save_measurements']:
-            db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
+            db_path = os.path.join(os.path.dirname(settings['src']), 'measurements', 'measurements.db')
             channel_indices = settings['png_dims']
             channel_indices = [min(value, 2) for value in channel_indices]
             _generate_representative_images(db_path,
@@ -1061,13 +1061,13 @@ def measure_crop(settings):
 
     if settings['timelapse']:
         if settings['timelapse_objects'] == 'nucleus':
-            folder_path = settings['input_folder']
+            folder_path = settings['src']
             mask_channels = [settings['nucleus_mask_dim'], settings['pathogen_mask_dim'],settings['cell_mask_dim']]
             object_types = ['nucleus','pathogen','cell']
             _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
 
         #if settings['save_png']:
-            img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
+            img_fldr = os.path.join(os.path.dirname(settings['src']), 'data')
             sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
             _scmovie(sc_img_fldrs)
     print("Successfully completed run")