spacr 0.1.76__py3-none-any.whl → 0.1.81__py3-none-any.whl

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/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/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/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/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/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")

spacr/settings.py

@@ -292,6 +292,7 @@ def get_measure_crop_settings(settings):
     return settings
 
 def set_default_analyze_screen(settings):
+    settings.setdefault('src', 'path')
     settings.setdefault('model_type','xgboost')
     settings.setdefault('heatmap_feature','predictions')
     settings.setdefault('grouping','mean')
@@ -392,6 +393,7 @@ def get_analyze_reads_default_settings(settings):
     return settings
 
 def get_map_barcodes_default_settings(settings):
+    settings.setdefault('src', 'path')
     settings.setdefault('grna', '/home/carruthers/Documents/grna_barcodes.csv')
     settings.setdefault('barcodes', '/home/carruthers/Documents/SCREEN_BARCODES.csv')
     settings.setdefault('plate_dict', {'EO1': 'plate1', 'EO2': 'plate2', 'EO3': 'plate3', 'EO4': 'plate4', 'EO5': 'plate5', 'EO6': 'plate6', 'EO7': 'plate7', 'EO8': 'plate8'})
@@ -536,7 +538,7 @@ expected_types = {
     "plot": bool,
     "n_jobs": int,
     "verbose": bool,
-    "input_folder": str,
+    "src": str,
     "cell_mask_dim": int,
     "cell_min_size": int,
     "cytoplasm_min_size": int,
@@ -858,88 +860,227 @@ def generate_fields(variables, scrollable_frame):
     row = 1
     vars_dict = {}
     tooltips = {
-        "src": "Path to the folder containing the images.",
-        "metadata_type": "Type of metadata to expect in the images. This will determine how the images are processed. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names.",
-        "custom_regex": "Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' is selected for 'metadata_type'.",
-        "experiment": "Name of the experiment. This will be used to name the output files.",
-        "channels": "List of channels to use for the analysis. The first channel is 0, the second is 1, and so on. For example, [0,1,2] will use channels 0, 1, and 2.",
-        "magnification": "At what magnification the images were taken. This will be used to determine the size of the objects in the images.",
-        "nucleus_channel": "The channel to use for the nucleus. If None, the nucleus will not be segmented.",
-        "nucleus_background": "The background intensity for the nucleus channel. This will be used to remove background noise.",
-        "nucleus_Signal_to_noise": "The signal-to-noise ratio for the nucleus channel. This will be used to determine the range of intensities to normalize images to for nucleus segmentation.",
-        "nucleus_CP_prob": "The cellpose probability threshold for the nucleus channel. This will be used to segment the nucleus.",
-        "nucleus_FT": "The flow threshold for nucleus objects. This will be used in nuclues segmentation.",
-        "cell_channel": "The channel to use for the cell. If None, the cell will not be segmented.",
-        "cell_background": "The background intensity for the cell channel. This will be used to remove background noise.",
-        "cell_Signal_to_noise": "The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
-        "cell_CP_prob": "The cellpose probability threshold for the cell channel. This will be used in cell segmentation.",
-        "cell_FT": "The flow threshold for cell objects. This will be used to segment the cells.",
-        "pathogen_channel": "The channel to use for the pathogen. If None, the pathogen will not be segmented.",
-        "pathogen_background": "The background intensity for the pathogen channel. This will be used to remove background noise.",
-        "pathogen_Signal_to_noise": "The signal-to-noise ratio for the pathogen channel. This will be used to determine the range of intensities to normalize images to for pathogen segmentation.",
-        "pathogen_CP_prob": "The cellpose probability threshold for the pathogen channel. This will be used to segment the pathogen.",
-        "pathogen_FT": "The flow threshold for pathogen objects. This will be used in pathogen segmentation.",
-        "preprocess": "Whether to preprocess the images before segmentation. This includes background removal and normalization. Set to False only if this step has already been done.",
-        "masks": "Whether to generate masks for the segmented objects. If True, masks will be generated for the nucleus, cell, and pathogen.",
-        "examples_to_plot": "The number of images to plot for each segmented object. This will be used to visually inspect the segmentation results and normalization.",
-        "randomize": "Whether to randomize the order of the images before processing. Recommended to avoid bias in the segmentation.",
-        "batch_size": "The batch size to use for processing the images. This will determine how many images are processed at once. Images are normalized and segmented in batches. Lower if application runs out of RAM or VRAM.",
-        "timelapse": "Whether to process the images as a timelapse.",
-        "timelapse_displacement": "The displacement between frames in the timelapse. This will be used to align the frames before processing.",
-        "timelapse_memory": "The number of frames to in tandem objects must be present in to be considered the same object in the timelapse.",
-        "timelapse_frame_limits": "The frame limits to use for the timelapse. This will determine which frames are processed. For example, [5,20] will process frames 5 to 20.",
-        "timelapse_remove_transient": "Whether to remove transient objects in the timelapse. Transient objects are present in fewer than all frames.",
-        "timelapse_mode": "The mode to use for processing the timelapse. 'trackpy' uses the trackpy library for tracking objects, while 'btrack' uses the btrack library.",
-        "timelapse_objects": "The objects to track in the timelapse (cell, nucleus or pathogen). This will determine which objects are tracked over time. If None, all objects will be tracked.",
-        "fps": "Frames per second of the automatically generated timelapse movies.",
-        "remove_background": "Whether to remove background noise from the images. This will help improve the quality of the segmentation.",
-        "lower_percentile": "The lower quantile to use for normalizing the images. This will be used to determine the range of intensities to normalize images to.",
-        "merge_pathogens": "Whether to merge pathogen objects that share more than 75% of their perimeter.",
-        "normalize_plots": "Whether to normalize the plots.",
-        "all_to_mip": "Whether to convert all images to maximum intensity projections before processing.",
-        "pick_slice": "Whether to pick a single slice from the z-stack images. If False, the maximum intensity projection will be used.",
-        "skip_mode": "The mode to use for skipping images. This will determine how to handle images that cannot be processed.",
-        "save": "Whether to save the results to disk.",
-        "merge_edge_pathogen_cells": "Whether to merge cells that share pathogen objects.",
-        "plot": "Whether to plot the results.",
-        "n_jobs": "The number of n_jobs to use for processing the images. This will determine how many images are processed in parallel. Increase to speed up processing.",
-        "verbose": "Whether to print verbose output during processing.",
-        "input_folder": "Path to the folder containing the images.",
-        "cell_mask_dim": "The dimension of the array the cell mask is saved in.",
-        "cell_min_size": "The minimum size of cell objects in pixels^2.",
-        "cytoplasm": "Whether to segment the cytoplasm (Cell - Nucleus + Pathogen).",
-        "cytoplasm_min_size": "The minimum size of cytoplasm objects in pixels^2.",
-        "nucleus_mask_dim": "The dimension of the array the nucleus mask is saved in.",
-        "nucleus_min_size": "The minimum size of nucleus objects in pixels^2.",
-        "pathogen_mask_dim": "The dimension of the array the pathogen mask is saved in.",
-        "pathogen_min_size": "The minimum size of pathogen objects in pixels^2.",
-        "save_png": "Whether to save the segmented objects as PNG images.",
-        "crop_mode": "The mode to use for cropping the images. This will determine which objects are cropped from the images (cell, nucleus, pathogen, cytoplasm).",
-        "use_bounding_box": "Whether to use the bounding box of the objects for cropping. If False, only the object itself will be cropped.",
-        "png_size": "The size of the PNG images to save. This will determine the size of the saved images.",
-        "normalize": "The percentiles to use for normalizing the images. This will be used to determine the range of intensities to normalize images to. If None, no normalization is done.",
-        "png_dims": "The dimensions of the PNG images to save. This will determine the dimensions of the saved images. Maximum of 3 dimensions e.g. [1,2,3].",
-        "normalize_by": "Whether to normalize the images by field of view (fov) or by PNG image (png).",
-        "save_measurements": "Whether to save the measurements to disk.",
-        "representative_images": "Whether to save representative images of the segmented objects (Not working yet).",
-        "plot_filtration": "Whether to plot the filtration steps.",
-        "include_uninfected": "Whether to include uninfected cells in the analysis.",
-        "dialate_pngs": "Whether to dilate the PNG images before saving.",
-        "dialate_png_ratios": "The ratios to use for dilating the PNG images. This will determine the amount of dilation applied to the images before cropping.",
-        "n_jobs": "The number of n_jobs to use for processing the images. This will determine how many images are processed in parallel. Increase to speed up processing.",
-        "cells": "The cell types to include in the analysis.",
-        "cell_loc": "The locations of the cell types in the images.",
-        "pathogens": "The pathogen types to include in the analysis.",
-        "pathogen_loc": "The locations of the pathogen types in the images.",
-        "treatments": "The treatments to include in the analysis.",
-        "treatment_loc": "The locations of the treatments in the images.",
-        "channel_of_interest": "The channel of interest to use for the analysis.",
-        "compartments": "The compartments to measure in the images.",
-        "measurement": "The measurement to use for the analysis.",
-        "nr_imgs": "The number of images to plot.",
-        "um_per_pixel": "The micrometers per pixel for the images."
+        "adjust_cells": "(bool) - Adjust cell parameters for better segmentation.",
+        "agg_type": "(str) - Type of aggregation to use for the data.",
+        "alpha": "(float) - Alpha parameter for the regression model.",
+        "all_to_mip": "(bool) - Whether to convert all images to maximum intensity projections before processing.",
+        "amsgrad": "(bool) - Whether to use AMSGrad optimizer.",
+        "analyze_clusters": "(bool) - Whether to analyze the resulting clusters.",
+        "augment": "(dict) - Data augmentation settings.",
+        "background": "(float) - Background intensity for the images.",
+        "backgrounds": "(str) - Background settings for the analysis.",
+        "barcodes": "(str) - Path to the file containing barcodes.",
+        "batch_size": "(int) - The batch size to use for processing the images. This will determine how many images are processed at once. Images are normalized and segmented in batches. Lower if application runs out of RAM or VRAM.",
+        "black_background": "(bool) - Whether to use a black background for plots.",
+        "calculate_correlation": "(bool) - Whether to calculate correlations between features.",
+        "cell_CP_prob": "(float) - The cellpose probability threshold for the cell channel. This will be used in cell segmentation.",
+        "cell_FT": "(float) - The flow threshold for cell objects. This will be used to segment the cells.",
+        "cell_background": "(float) - The background intensity for the cell channel. This will be used to remove background noise.",
+        "cell_chann_dim": "(int) - Dimension of the channel to use for cell segmentation.",
+        "cell_channel": "(int) - The channel to use for the cell. If None, the cell will not be segmented.",
+        "cell_intensity_range": "(list) - Intensity range for cell segmentation.",
+        "cell_loc": "(list) - The locations of the cell types in the images.",
+        "cell_mask_dim": "(int) - The dimension of the array the cell mask is saved in.",
+        "cell_min_size": "(int) - The minimum size of cell objects in pixels^2.",
+        "cell_plate_metadata": "(str) - Metadata for the cell plate.",
+        "cell_Signal_to_noise": "(float) - The signal-to-noise ratio for the cell channel. This will be used to determine the range of intensities to normalize images to for cell segmentation.",
+        "cell_size_range": "(list) - Size range for cell segmentation.",
+        "cell_types": "(list) - Types of cells to include in the analysis.",
+        "cells": "(list) - The cell types to include in the analysis.",
+        "cells_per_well": "(int) - Number of cells per well.",
+        "channel_dims": "(list) - The dimensions of the image channels.",
+        "channel_of_interest": "(int) - The channel of interest to use for the analysis.",
+        "channels": "(list) - List of channels to use for the analysis. The first channel is 0, the second is 1, and so on. For example, [0,1,2] will use channels 0, 1, and 2.",
+        "chunk_size": "(int) - Chunk size for processing the sequencing data.",
+        "classes": "(list) - Classes to include in the training.",
+        "class_1_threshold": "(float) - Threshold for class 1 classification.",
+        "clustering": "(str) - Clustering algorithm to use.",
+        "col_to_compare": "(str) - Column to compare in the embeddings.",
+        "color_by": "(str) - Coloring scheme for the plots.",
+        "compartments": "(list) - The compartments to measure in the images.",
+        "CP_prob": "(float) - Cellpose probability threshold for segmentation.",
+        "crop_mode": "(str) - Mode to use for cropping images (cell, nucleus, pathogen, cytoplasm).",
+        "custom_model": "(str) - Path to a custom Cellpose model.",
+        "custom_regex": "(str) - Custom regex pattern to extract metadata from the image names. This will only be used if 'custom' is selected for 'metadata_type'.",
+        "cytoplasm": "(bool) - Whether to segment the cytoplasm (Cell - Nucleus + Pathogen).",
+        "cytoplasm_min_size": "(int) - The minimum size of cytoplasm objects in pixels^2.",
+        "dependent_variable": "(str) - The dependent variable for the regression analysis.",
+        "diameter": "(float) - Diameter of the objects to segment.",
+        "dialate_png_ratios": "(list) - The ratios to use for dilating the PNG images. This will determine the amount of dilation applied to the images before cropping.",
+        "dialate_pngs": "(bool) - Whether to dilate the PNG images before saving.",
+        "dot_size": "(int) - Size of dots in scatter plots.",
+        "downstream": "(str) - Downstream region for sequencing analysis.",
+        "dropout_rate": "(float) - Dropout rate for training.",
+        "eps": "(float) - Epsilon parameter for clustering.",
+        "epochs": "(int) - Number of epochs for training the deep learning model.",
+        "examples_to_plot": "(int) - The number of images to plot for each segmented object. This will be used to visually inspect the segmentation results and normalization.",
+        "exclude": "(list) - Conditions to exclude from the analysis.",
+        "exclude_conditions": "(list) - Specific conditions to exclude from the analysis.",
+        "experiment": "(str) - Name of the experiment. This will be used to name the output files.",
+        "figuresize": "(tuple) - Size of the figures to plot.",
+        "filter": "(dict) - Filter settings for the analysis.",
+        "filter_by": "(str) - Feature to filter the data by.",
+        "flow_threshold": "(float) - Flow threshold for segmentation.",
+        "fps": "(int) - Frames per second of the automatically generated timelapse movies.",
+        "fraction_threshold": "(float) - Threshold for the fraction of cells to consider in the analysis.",
+        "from_scratch": "(bool) - Whether to train the Cellpose model from scratch.",
+        "gene_weights_csv": "(str) - Path to the CSV file containing gene weights.",
+        "gradient_accumulation": "(bool) - Whether to use gradient accumulation.",
+        "gradient_accumulation_steps": "(int) - Number of steps for gradient accumulation.",
+        "grayscale": "(bool) - Whether to process the images in grayscale.",
+        "grna": "(str) - Path to the file containing gRNA sequences.",
+        "grouping": "(str) - Grouping variable for plotting.",
+        "heatmap_feature": "(str) - Feature to use for generating heatmaps.",
+        "homogeneity": "(float) - Measure of homogeneity for the objects.",
+        "homogeneity_distances": "(list) - Distances to use for measuring homogeneity.",
+        "image_nr": "(int) - Number of images to process.",
+        "image_size": "(int) - Size of the images for training.",
+        "img_zoom": "(float) - Zoom factor for the images in plots.",
+        "include_multinucleated": "(bool) - Whether to include multinucleated cells in the analysis.",
+        "include_multiinfected": "(bool) - Whether to include multi-infected cells in the analysis.",
+        "include_noninfected": "(bool) - Whether to include non-infected cells in the analysis.",
+        "include_uninfected": "(bool) - Whether to include uninfected cells in the analysis.",
+        "init_weights": "(bool) - Whether to initialize weights for the model.",
+        "src": "(str) - Path to the folder containing the images.",
+        "intermedeate_save": "(bool) - Whether to save intermediate results.",
+        "invert": "(bool) - Whether to invert the image intensities.",
+        "learning_rate": "(float) - Learning rate for training.",
+        "location_column": "(str) - Column name for the location information.",
+        "log_data": "(bool) - Whether to log-transform the data.",
+        "lower_percentile": "(float) - The lower quantile to use for normalizing the images. This will be used to determine the range of intensities to normalize images to.",
+        "magnification": "(int) - At what magnification the images were taken. This will be used to determine the size of the objects in the images.",
+        "manders_thresholds": "(list) - Thresholds for Manders' coefficients.",
+        "mask": "(bool) - Whether to generate masks for the segmented objects. If True, masks will be generated for the nucleus, cell, and pathogen.",
+        "measurement": "(str) - The measurement to use for the analysis.",
+        "metadata_type": "(str) - Type of metadata to expect in the images. This will determine how the images are processed. If 'custom' is selected, you can provide a custom regex pattern to extract metadata from the image names.",
+        "metadata_types": "(list) - Types of metadata to include in the analysis.",
+        "merge_edge_pathogen_cells": "(bool) - Whether to merge cells that share pathogen objects.",
+        "merge_pathogens": "(bool) - Whether to merge pathogen objects that share more than 75% of their perimeter.",
+        "metric": "(str) - Metric to use for UMAP.",
+        "min_cell_count": "(int) - Minimum number of cells required for analysis.",
+        "min_dist": "(float) - Minimum distance for UMAP.",
+        "min_max": "(tuple) - Minimum and maximum values for normalizing plots.",
+        "min_samples": "(int) - Minimum number of samples for clustering.",
+        "mix": "(dict) - Mixing settings for the samples.",
+        "model_name": "(str) - Name of the Cellpose model.",
+        "model_type": "(str) - Type of model to use for the analysis.",
+        "nc": "(str) - Negative control identifier.",
+        "nc_loc": "(str) - Location of the negative control in the images.",
+        "negative_control": "(str) - Identifier for the negative control.",
+        "n_estimators": "(int) - Number of estimators for the model.",
+        "n_epochs": "(int) - Number of epochs for training the Cellpose model.",
+        "n_jobs": "(int) - The number of n_jobs to use for processing the images. This will determine how many images are processed in parallel. Increase to speed up processing.",
+        "n_neighbors": "(int) - Number of neighbors for UMAP.",
+        "n_repeats": "(int) - Number of repeats for cross-validation.",
+        "normalize": "(list) - The percentiles to use for normalizing the images. This will be used to determine the range of intensities to normalize images to. If None, no normalization is done.",
+        "normalize_by": "(str) - Whether to normalize the images by field of view (fov) or by PNG image (png).",
+        "normalize_plots": "(bool) - Whether to normalize the plots.",
+        "nr_imgs": "(int) - The number of images to plot.",
+        "nucleus_CP_prob": "(float) - The cellpose probability threshold for the nucleus channel. This will be used to segment the nucleus.",
+        "nucleus_FT": "(float) - The flow threshold for nucleus objects. This will be used in nucleus segmentation.",
+        "nucleus_background": "(float) - The background intensity for the nucleus channel. This will be used to remove background noise.",
+        "nucleus_chann_dim": "(int) - Dimension of the channel to use for nucleus segmentation.",
+        "nucleus_channel": "(int) - The channel to use for the nucleus. If None, the nucleus will not be segmented.",
+        "nucleus_intensity_range": "(list) - Intensity range for nucleus segmentation.",
+        "nucleus_loc": "(str) - Location of the nucleus in the images.",
+        "nucleus_mask_dim": "(int) - The dimension of the array the nucleus mask is saved in.",
+        "nucleus_min_size": "(int) - The minimum size of nucleus objects in pixels^2.",
+        "nucleus_Signal_to_noise": "(float) - The signal-to-noise ratio for the nucleus channel. This will be used to determine the range of intensities to normalize images to for nucleus segmentation.",
+        "nucleus_size_range": "(list) - Size range for nucleus segmentation.",
+        "optimizer_type": "(str) - Type of optimizer to use.",
+        "other": "(dict) - Additional parameters for the regression analysis.",
+        "pathogen_CP_prob": "(float) - The cellpose probability threshold for the pathogen channel. This will be used to segment the pathogen.",
+        "pathogen_FT": "(float) - The flow threshold for pathogen objects. This will be used in pathogen segmentation.",
+        "pathogen_background": "(float) - The background intensity for the pathogen channel. This will be used to remove background noise.",
+        "pathogen_chann_dim": "(int) - Dimension of the channel to use for pathogen segmentation.",
+        "pathogen_channel": "(int) - The channel to use for the pathogen. If None, the pathogen will not be segmented.",
+        "pathogen_intensity_range": "(list) - Intensity range for pathogen segmentation.",
+        "pathogen_loc": "(list) - The locations of the pathogen types in the images.",
+        "pathogen_mask_dim": "(int) - The dimension of the array the pathogen mask is saved in.",
+        "pathogen_min_size": "(int) - The minimum size of pathogen objects in pixels^2.",
+        "pathogen_model": "(str) - Model to use for pathogen segmentation.",
+        "pathogen_plate_metadata": "(str) - Metadata for the pathogen plate.",
+        "pathogen_Signal_to_noise": "(float) - The signal-to-noise ratio for the pathogen channel. This will be used to determine the range of intensities to normalize images to for pathogen segmentation.",
+        "pathogen_size_range": "(list) - Size range for pathogen segmentation.",
+        "pathogen_types": "(list) - Types of pathogens to include in the analysis.",
+        "pc": "(str) - Positive control identifier.",
+        "pc_loc": "(str) - Location of the positive control in the images.",
+        "percentiles": "(list) - Percentiles to use for normalizing the images.",
+        "pick_slice": "(bool) - Whether to pick a single slice from the z-stack images. If False, the maximum intensity projection will be used.",
+        "pin_memory": "(bool) - Whether to pin memory for the data loader.",
+        "plate": "(str) - Plate identifier for the experiment.",
+        "plate_dict": "(dict) - Dictionary of plate metadata.",
+        "plot": "(bool) - Whether to plot the results.",
+        "plot_by_cluster": "(bool) - Whether to plot images by clusters.",
+        "plot_cluster_grids": "(bool) - Whether to plot grids of clustered images.",
+        "plot_control": "(dict) - Control settings for plotting.",
+        "plot_filtration": "(bool) - Whether to plot the filtration steps.",
+        "plot_images": "(bool) - Whether to plot images.",
+        "plot_nr": "(int) - Number of plots to generate.",
+        "plot_outlines": "(bool) - Whether to plot outlines of segmented objects.",
+        "png_dims": "(list) - The dimensions of the PNG images to save. This will determine the dimensions of the saved images. Maximum of 3 dimensions e.g. [1,2,3].",
+        "png_size": "(int) - The size of the PNG images to save. This will determine the size of the saved images.",
+        "positive_control": "(str) - Identifier for the positive control.",
+        "preprocess": "(bool) - Whether to preprocess the images before segmentation. This includes background removal and normalization. Set to False only if this step has already been done.",
+        "radial_dist": "(list) - Radial distances for measuring features.",
+        "random_test": "(bool) - Whether to randomly select images for testing.",
+        "randomize": "(bool) - Whether to randomize the order of the images before processing. Recommended to avoid bias in the segmentation.",
+        "regression_type": "(str) - Type of regression to perform.",
+        "remove_background": "(bool) - Whether to remove background noise from the images. This will help improve the quality of the segmentation.",
+        "remove_background_cell": "(bool) - Whether to remove background noise from the cell channel.",
+        "remove_background_nucleus": "(bool) - Whether to remove background noise from the nucleus channel.",
+        "remove_background_pathogen": "(bool) - Whether to remove background noise from the pathogen channel.",
+        "remove_cluster_noise": "(bool) - Whether to remove noise from the clusters.",
+        "remove_highly_correlated": "(bool) - Whether to remove highly correlated features.",
+        "remove_highly_correlated_features": "(bool) - Whether to remove highly correlated features from the analysis.",
+        "remove_image_canvas": "(bool) - Whether to remove the image canvas after plotting.",
+        "remove_low_variance_features": "(bool) - Whether to remove low variance features from the analysis.",
+        "remove_row_column_effect": "(bool) - Whether to remove row and column effects from the data.",
+        "representative_images": "(bool) - Whether to save representative images of the segmented objects (Not working yet).",
+        "resize": "(bool) - Resize factor for the images.",
+        "resample": "(bool) - Whether to resample the images during processing.",
+        "rescale": "(float) - Rescaling factor for the images.",
+        "reduction_method": "(str) - Dimensionality reduction method to use ().",
+        "resnet_features": "(bool) - Whether to use ResNet features for embedding.",
+        "row_limit": "(int) - Limit on the number of rows to plot.",
+        "save": "(bool) - Whether to save the results to disk.",
+        "save_arrays": "(bool) - Whether to save arrays of segmented objects.",
+        "save_figure": "(bool) - Whether to save the generated figures.",
+        "save_measurements": "(bool) - Whether to save the measurements to disk.",
+        "save_png": "(bool) - Whether to save the segmented objects as PNG images.",
+        "schedule": "(str) - Schedule for processing the data.",
+        "Signal_to_noise": "(float) - Signal-to-noise ratio for the images.",
+        "skip_mode": "(str) - The mode to use for skipping images. This will determine how to handle images that cannot be processed.",
+        "smooth_lines": "(bool) - Whether to smooth lines in the plots.",
+        "src": "(str, path) - Path to source directory.",
+        "target": "(str) - Target variable for the analysis.",
+        "target_height": "(int) - Target height for resizing the images.",
+        "target_intensity_min": "(float) - Minimum intensity for the target objects.",
+        "target_width": "(int) - Target width for resizing the images.",
+        "tables": "(list) - Tables to include in the analysis.",
+        "test": "(bool) - Whether to run the pipeline in test mode.",
+        "test_images": "(list) - List of images to use for testing.",
+        "test_mode": "(bool) - Mode to use for testing the analysis pipeline.",
+        "test_nr": "(int) - Number of test images.",
+        "test_size": "(float) - Size of the test set.",
+        "treatment_loc": "(list) - The locations of the treatments in the images.",
+        "treatments": "(list) - The treatments to include in the analysis.",
+        "top_features": "(int) - Top features to include in the analysis.",
+        "train": "(bool) - Whether to train the model.",
+        "train_mode": "(str) - Mode to use for training the model.",
+        "transform": "(dict) - Transformation to apply to the data.",
+        "upscale": "(bool) - Whether to upscale the images.",
+        "upscale_factor": "(float) - Factor by which to upscale the images.",
+        "upstream": "(str) - Upstream region for sequencing analysis.",
+        "val_split": "(float) - Validation split ratio.",
+        "visualize": "(bool) - Whether to visualize the embeddings.",
+        "verbose": "(bool) - Whether to print verbose output during processing.",
+        "weight_decay": "(float) - Weight decay for regularization.",
+        "width_height": "(tuple) - Width and height of the input images.",
+        "um_per_pixel": "(float) - The micrometers per pixel for the images."
     }
 
+
     for key, (var_type, options, default_value) in variables.items():
         label, widget, var = create_input_field(scrollable_frame.scrollable_frame, key, row, var_type, options, default_value)
         vars_dict[key] = (label, widget, var)  # Store the label, widget, and variable
@@ -951,33 +1092,53 @@ def generate_fields(variables, scrollable_frame):
     return vars_dict
 
 categories = {
-    "General": ["src", "input_folder", "metadata_type", "custom_regex", "experiment", "channels", "magnification"],
-    "Nucleus": ["nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
-    "Cell": ["cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "include_uninfected", "merge_edge_pathogen_cells", "adjust_cells"],
-    "Pathogen": ["pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim"],
+    "General": ["src", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims"],
+    "Paths":["grna", "barcodes"],
+    "Regression":["class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "remove_row_column_effect", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable", "gene_weights_csv"],
+    "Cellpose":["from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "circular", "invert", "diameter", "grayscale", "background", "Signal_to_noise", "resize", "target_height", "target_width"],
+    "Nucleus": ["nucleus_intensity_range", "nucleus_size_range", "nucleus_chann_dim", "nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
+    "Cell": ["cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "include_uninfected", "merge_edge_pathogen_cells", "adjust_cells"],
+    "Pathogen": ["pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim"],
     "Timelapse": ["fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-    "Plot": ["plot_filtration", "examples_to_plot", "normalize_plots", "normalize", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
+    "Plot": ["plot_control", "plot_nr", "plot_filtration", "examples_to_plot", "normalize_plots", "normalize", "cmap", "figuresize", "plot_cluster_grids", "img_zoom", "row_limit", "color_by", "plot_images", "smooth_lines", "plot_points", "plot_outlines", "black_background", "plot_by_cluster", "heatmap_feature","grouping","min_max","cmap","save_figure"],
     "Object Image": ["save_png", "dialate_pngs", "dialate_png_ratios", "png_size", "png_dims", "save_arrays", "normalize_by", "dialate_png_ratios", "crop_mode", "dialate_pngs", "normalize", "use_bounding_box"],
-    "Annotate Data": ["positive_control","negative_control", "location_column", "treatment_loc", "cells", "cell_loc", "pathogens", "pathogen_loc", "channel_of_interest", "measurement", "treatments", "representative_images", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
+    "Annotate Data": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","pathogen_types", "pathogen_plate_metadata", "treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "cells", "cell_loc", "pathogens", "pathogen_loc", "channel_of_interest", "measurement", "treatments", "representative_images", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
     "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
-    "Advanced": ["plot", "timelapse", "schedule", "test_size","exclude","n_repeats","top_features", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs", "train_mode","amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory","n_jobs","channels","augment"],
+    "Advanced": ["plate_dict", "target_intensity_min", "cells_per_well", "include_multinucleated", "include_multiinfected", "include_noninfected", "backgrounds", "plot", "timelapse", "schedule", "test_size","exclude","n_repeats","top_features", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs", "train_mode","amsgrad","use_checkpoint","gradient_accumulation","gradient_accumulation_steps","intermedeate_save","pin_memory","n_jobs","channels","augment"],
     "Clustering": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
     "Embedding": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
-    "Train DL Model": ["epochs", "loss_type", "optimizer_type","image_size","val_split","learning_rate","weight_decay","dropout_rate","init_weights", "train", "classes"],
+    "Train DL Model": ["epochs", "loss_type", "optimizer_type","image_size","val_split","learning_rate","weight_decay","dropout_rate", "init_weights", "train", "classes"],
     "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"],
-    "Test": ["test_mode", "test_images", "random_test", "test_nr"],
-    "Sequencing": ["upstream", "downstream", "barecode_length_1", "barecode_length_2", "chunk_size", "test"]
+    "Test": ["test_mode", "test_images", "random_test", "test_nr", "test"],
+    "Sequencing": ["upstream", "downstream", "barecode_length_1", "barecode_length_2", "chunk_size"]
 }
 
 descriptions = {
-    'mask': "This module allows you to set default settings for preprocessing and generating masks.",
-    'measure': "This module allows you to set default settings for measuring and cropping images.",
-    'classify': "This module allows you to set default settings for training and testing classification models.",
-    'sequencing': "This module allows you to set default settings for analyzing sequencing reads.",
-    'umap': "This module allows you to set default settings for UMAP image analysis."
+    'mask': "Generate Cellpose masks for Cells, Nuclei, and Pathogens. This module uses: preprocess_generate_masks from spacr.core.\n\nKey Features:\n- Automated Mask Generation: Automatically generate accurate masks for various cellular components using Cellpose, a robust deep learning model for cell segmentation.\n- Versatility: Capable of handling different types of biological samples, including cells, nuclei, and pathogens.\n- Integration: Directly integrates with other modules, providing the foundational masks required for subsequent analysis.",
+    
+    'measure': "Capture Measurements from Cells, Nuclei, Pathogens, and Cytoplasm objects. Generate single object PNG images for one or several objects. (Requires masks from the Mask module). This module uses: measure_crop from spacr.measure.\n\nKey Features:\n- Comprehensive Measurement Capture: Obtain detailed measurements for various cellular components, including area, perimeter, intensity, and more.\n- Image Generation: Create high-resolution PNG images of individual objects, facilitating further analysis and visualization.\n- Mask Dependency: Requires accurate masks generated by the Mask module to ensure precise measurements.",
+    
+    'classify': "Train and Test any Torch Computer vision model. (Requires PNG images from the Measure module). This module uses: train_test_model from spacr.deep_spacr.\n\nKey Features:\n- Deep Learning Integration: Train and evaluate state-of-the-art Torch models for various classification tasks.\n- Flexible Training: Supports a wide range of Torch models, allowing customization based on specific research needs.\n- Data Requirement: Requires PNG images generated by the Measure module for training and testing.",
+    
+    'sequencing': "Find Barcodes and gRNA sequences in FASTQ files. (Requires paired-end FASTQ files, R1 and R2). This module uses: analyze_reads from spacr.sequencing.\n\nKey Features:\n- Barcode and gRNA Identification: Efficiently detect and extract barcode and gRNA sequences from raw sequencing data.\n- Paired-End Support: Specifically designed to handle paired-end FASTQ files, ensuring accurate sequence alignment and analysis.\n- High Throughput: Capable of processing large sequencing datasets quickly and accurately.",
+    
+    'umap': "Generate UMAP or tSNE embeddings and represent points as single cell images. (Requires measurements.db and PNG images from the Measure module). This module uses: generate_image_umap from spacr.core.\n\nKey Features:\n- Dimensionality Reduction: Employ UMAP or tSNE algorithms to reduce high-dimensional data into two dimensions for visualization.\n- Single Cell Representation: Visualize embedding points as single cell images, providing an intuitive understanding of data clusters.\n- Data Integration: Requires measurements and images generated by the Measure module, ensuring comprehensive data representation.",
+    
+    'train_cellpose': "Train custom Cellpose models for your specific dataset. This module uses: train_cellpose_model from spacr.core.\n\nKey Features:\n- Custom Model Training: Train Cellpose models on your dataset to improve segmentation accuracy.\n- Data Adaptation: Tailor the model to handle specific types of biological samples more effectively.\n- Advanced Training Options: Supports various training parameters and configurations for optimized performance.",
+    
+    'ml_analyze': "Perform machine learning analysis on your data. This module uses: ml_analysis_tools from spacr.ml.\n\nKey Features:\n- Comprehensive Analysis: Utilize a suite of machine learning tools for data analysis.\n- Customizable Workflows: Configure and run different ML algorithms based on your research requirements.\n- Integration: Works seamlessly with other modules to analyze data produced from various steps.",
+    
+    'cellpose_masks': "Generate masks using Cellpose for all images in your dataset. This module uses: generate_masks from spacr.cellpose.\n\nKey Features:\n- Batch Processing: Generate masks for large sets of images efficiently.\n- Robust Segmentation: Leverage Cellpose's capabilities for accurate segmentation across diverse samples.\n- Automation: Automate the mask generation process for streamlined workflows.",
+    
+    'cellpose_all': "Run Cellpose on all images in your dataset and obtain masks and measurements. This module uses: cellpose_analysis from spacr.cellpose.\n\nKey Features:\n- End-to-End Analysis: Perform both segmentation and measurement extraction in a single step.\n- Efficiency: Process entire datasets with minimal manual intervention.\n- Comprehensive Output: Obtain detailed masks and corresponding measurements for further analysis.",
+    
+    'map_barcodes': "Map barcodes to your data for identification and tracking. This module uses: barcode_mapping_tools from spacr.sequencing.\n\nKey Features:\n- Barcode Integration: Efficiently map and integrate barcode information into your dataset.\n- Tracking: Enable tracking and identification of samples using barcodes.\n- Compatibility: Works with sequencing data to ensure accurate mapping and analysis.",
+    
+    'regression': "Perform regression analysis on your data. This module uses: regression_tools from spacr.analysis.\n\nKey Features:\n- Statistical Analysis: Conduct various types of regression analysis to identify relationships within your data.\n- Flexible Options: Supports multiple regression models and configurations.\n- Data Insight: Gain deeper insights into your dataset through advanced regression techniques.",
+    
+    'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. This module uses: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
 }
 
-
 def set_annotate_default_settings(settings):
     settings.setdefault('src', 'path')
     settings.setdefault('image_type', 'cell_png')

{spacr-0.1.76.dist-info → spacr-0.1.81.dist-info}/METADATA

@@ -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.dist-info → spacr-0.1.81.dist-info}/RECORD

@@ -14,17 +14,17 @@ spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
 spacr/chris.py,sha256=YlBjSgeZaY8HPy6jkrT_ISAnCMAKVfvCxF0I9eAZLFM,2418
 spacr/classify_app.py,sha256=Zi15ryc1ocYitRF4kyxlC27XxGyzfSPdvj2d6ZrSh7E,8446
 spacr/cli.py,sha256=507jfOOEV8BoL4eeUcblvH-iiDHdBrEVJLu1ghAAPSc,1800
-spacr/core.py,sha256=vDSqxiFUdQ0sCn5QRlFWYqR7CQCDaMGTD-xDOnikOfE,160176
+spacr/core.py,sha256=bm1cApGVTE218Ds3FqqWD5TsF5FF8kclHwPlvdOolzc,160216
 spacr/deep_spacr.py,sha256=ASBsN4JpHp_3S-91JUsB34IWTjTGPYI7jKV2qZnUR5M,37005
 spacr/foldseek.py,sha256=YIP1d4Ci6CeA9jSyiv-HTDbNmAmcSM9Y_DaOs7wYzLY,33546
 spacr/get_alfafold_structures.py,sha256=ehx_MQgb12k3hFecP6cYVlm5TLO8iWjgevy8ESyS3cw,3544
 spacr/graph_learning.py,sha256=1tR-ZxvXE3dBz1Saw7BeVFcrsUFu9OlUZeZVifih9eo,13070
-spacr/gui.py,sha256=9psWiXMna1ebi-I55H0vQ3lad_923fhq_LB13lMSEg4,6893
+spacr/gui.py,sha256=OPIMDVVYyAKO3zJIrWkP_YIc9-SwQsVR2S7ynXu1wkQ,8901
 spacr/gui_2.py,sha256=ZAI5quQYbhQJ40vK0NCqU_UMSPLkpfeQpomBWUSM0fc,6946
 spacr/gui_annotate.py,sha256=ugBksLGOHdtOLlEuRyyc59TrkYKu3rDf8JxEgiBSVao,6536
 spacr/gui_classify_app.py,sha256=Zi15ryc1ocYitRF4kyxlC27XxGyzfSPdvj2d6ZrSh7E,8446
-spacr/gui_core.py,sha256=VkcYV8gE8Bc1fKcuZSJ1plS8agS_386ZxjqudRMLhG0,27912
-spacr/gui_elements.py,sha256=fgRaG7THe95jyaIaqJqe05syQ9apo9ZIwkRR2u9vMnY,72544
+spacr/gui_core.py,sha256=PmElJrKHtEGYKpGTGgryxxvUvOHMh-wUmhvuHnyI13w,31833
+spacr/gui_elements.py,sha256=b0GJCHyrgJFeqB_IdjkXqMbXeC1reiLyiQ6-MTf_UuQ,73305
 spacr/gui_make_masks_app.py,sha256=tl4M4Q2WQgrrwjRBJVevxJxpNowqzPhWkdCOm2UfRbw,45053
 spacr/gui_make_masks_app_v2.py,sha256=X3izTBXdCZDlkVe-fbG-jmCQtcAbmK0OIivjyWaLhug,30576
 spacr/gui_mask_app.py,sha256=mhTl_XzXLFl8Tx3WYEMpdYB_qw9u5JJa0EdkvlcIzAE,10706
@@ -33,17 +33,17 @@ spacr/gui_run.py,sha256=0x85MJqFtREuWuNeIRLB8hFeibKGszfN14POQQWzPDQ,1998
 spacr/gui_sim_app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spacr/gui_utils.py,sha256=W0blyZ6JTCBzlkZwXqJpg_uUv41vvqbKvJGCigCeWG8,13890
 spacr/gui_wrappers.py,sha256=-E1SFOmtp7_nfg9QzajI7GJcAcaMug92Pjw7pS1YzjY,4656
-spacr/io.py,sha256=IoERqSwoxJrInYl-E0WfwFOEDZXFdJofk5DmpbyLGWM,112077
+spacr/io.py,sha256=f7cVn48wNUEj6Teky4p3ojoivAdMUmPll2s0MzJkKD0,112068
 spacr/logger.py,sha256=7Zqr3TuuOQLWT32gYr2q1qvv7x0a2JhLANmZcnBXAW8,670
 spacr/make_masks_app.py,sha256=iGaTwhowoe2JMOSOf8bJwQZTooRhLQx7KO0ewnAmqDY,45138
 spacr/make_masks_app_v2.py,sha256=X3izTBXdCZDlkVe-fbG-jmCQtcAbmK0OIivjyWaLhug,30576
 spacr/mask_app.py,sha256=mhTl_XzXLFl8Tx3WYEMpdYB_qw9u5JJa0EdkvlcIzAE,10706
-spacr/measure.py,sha256=e36NR8raCkvKHZXvTJgPDwObsmsegvc1dAiCqD3oljk,55751
+spacr/measure.py,sha256=RzcD8rsUaOZUYB-zcbaUZcJbrwT0IIW5G7qvb__SO-E,55616
 spacr/measure_app.py,sha256=_C1-XFL5HSquUEEbM_NcxdvHx-socPFCx85MBG4d6xo,10598
 spacr/old_code.py,sha256=jw67DAGoLBd7mWofVzRJSEmCI1Qrff26zIo65SEkV00,13817
 spacr/plot.py,sha256=DYJEoK1kz2ih6ZGvKiA3xTqeIeKQNhuQKwgrscopFxA,69101
 spacr/sequencing.py,sha256=fHZRnoMSxmhMdadkei3lUeBdckqFyptWdQyWsDW3aaU,83304
-spacr/settings.py,sha256=PQ-VJSTlBMxfQuz35MiipoGmBjq56jqepViUvOjov0k,48668
+spacr/settings.py,sha256=VkRJHdzDtfGn_F8sJ5rfK80blZhpy21djxLfQcnlhGA,65665
 spacr/sim.py,sha256=FveaVgBi3eypO2oVB5Dx-v0CC1Ny7UPfXkJiiRRodAk,71212
 spacr/sim_app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 spacr/timelapse.py,sha256=KMYCgHzf9LTZe-lWl5mvH2EjbKRE6OhpwdY13wEumGc,39504
@@ -52,9 +52,9 @@ spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model,sha256=z8BbHWZPRnE9D_BHO0fBREE85c1vkltDs-incs2ytXQ,26566572
 spacr/models/cp/toxo_plaque_cyto_e25000_X1120_Y1120.CP_model_settings.csv,sha256=fBAGuL_B8ERVdVizO3BHozTDSbZUh1yFzsYK3wkQN68,420
 spacr/models/cp/toxo_pv_lumen.CP_model,sha256=2y_CindYhmTvVwBH39SNILF3rI3x9SsRn6qrMxHy3l0,26562451
-spacr-0.1.76.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.1.76.dist-info/METADATA,sha256=SLaAcTSAOj_pyCLUshGwpwD0rt_XLRTE9p08sVbTalo,5050
-spacr-0.1.76.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
-spacr-0.1.76.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.1.76.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.1.76.dist-info/RECORD,,
+spacr-0.1.81.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.1.81.dist-info/METADATA,sha256=E8m8oiUydIogb-0PipHqaIe-wden3HvcAcxSqkpqH9g,5050
+spacr-0.1.81.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+spacr-0.1.81.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.1.81.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.1.81.dist-info/RECORD,,