spacr 0.1.63__tar.gz → 0.1.75__tar.gz

{spacr-0.1.63/spacr.egg-info → spacr-0.1.75}/PKG-INFO

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

{spacr-0.1.63 → spacr-0.1.75}/setup.py

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

spacr-0.1.75/spacr/app_annotate.py

@@ -0,0 +1,53 @@
+import tkinter as tk
+from .gui import MainApp
+
+def initiate_annotation_app(parent_frame):
+    from .gui_utils import generate_annotate_fields, annotate_app
+    # Set up the settings window
+    settings_window = tk.Toplevel(parent_frame)
+    settings_window.title("Annotation Settings")
+    settings_window.configure(bg='black')  # Set the background color to black
+    
+    # Use the existing function to create the settings UI
+    settings_frame = tk.Frame(settings_window, bg='black')  # Set the background color to black
+    settings_frame.pack(fill=tk.BOTH, expand=True)
+    vars_dict = generate_annotate_fields(settings_frame)
+    
+    def start_annotation_app():
+        settings = {key: data['entry'].get() for key, data in vars_dict.items()}
+        settings['channels'] = settings['channels'].split(',')
+        settings['img_size'] = list(map(int, settings['img_size'].split(',')))  # Convert string to list of integers
+        settings['percentiles'] = list(map(int, settings['percentiles'].split(',')))  # Convert string to list of integers
+        settings['normalize'] = settings['normalize'].lower() == 'true'
+        settings['rows'] = int(settings['rows'])
+        settings['columns'] = int(settings['columns'])
+
+        try:
+            settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
+            settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])
+        except:
+            settings['measurement']  = None
+            settings['threshold'] = None
+
+        settings['db'] = settings.get('db', 'default.db')
+
+        # Convert empty strings to None
+        for key, value in settings.items():
+            if isinstance(value, list):
+                settings[key] = [v if v != '' else None for v in value]
+            elif value == '':
+                settings[key] = None
+
+        settings_window.destroy()
+        annotate_app(parent_frame, settings)
+    
+    #start_button = spacrButton(settings_window, text="Start Annotation", command=lambda: start_annotation_app, font=('Helvetica', 12))
+    start_button = tk.Button(settings_window, text="Start Annotation", command=start_annotation_app)
+    start_button.pack(pady=10)
+
+def start_annotate_app():
+    app = MainApp(default_app="Annotate")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_annotate_app()

spacr-0.1.75/spacr/app_make_masks.py

@@ -0,0 +1,51 @@
+import tkinter as tk
+from tkinter import ttk
+from .gui import MainApp
+
+def initiate_make_mask_app(parent_frame):
+    from .gui_elements import modify_masks
+    # Set up the settings window
+    settings_window = tk.Toplevel(parent_frame)
+    settings_window.title("Make Masks Settings")
+    settings_window.configure(bg='black')  # Set the background color to black
+    
+    # Use the existing function to create the settings UI
+    settings_frame = tk.Frame(settings_window, bg='black')  # Set the background color to black
+    settings_frame.pack(fill=tk.BOTH, expand=True)
+    
+    vars_dict = {
+        'folder_path': ttk.Entry(settings_frame),
+        'scale_factor': ttk.Entry(settings_frame)
+    }
+
+    # Arrange input fields and labels
+    row = 0
+    for name, entry in vars_dict.items():
+        ttk.Label(settings_frame, text=f"{name.replace('_', ' ').capitalize()}:",
+                  background="black", foreground="white").grid(row=row, column=0)
+        entry.grid(row=row, column=1)
+        row += 1
+
+    # Function to be called when "Run" button is clicked
+    def start_make_mask_app():
+        folder_path = vars_dict['folder_path'].get()
+        try:
+            scale_factor = float(vars_dict['scale_factor'].get())
+        except ValueError:
+            scale_factor = None  # Handle invalid input gracefully
+
+        # Convert empty strings to None
+        folder_path = folder_path if folder_path != '' else None
+
+        settings_window.destroy()
+        modify_masks(parent_frame, folder_path, scale_factor)
+    
+    run_button = tk.Button(settings_window, text="Start Make Masks", command=start_make_mask_app, bg='black', fg='white')
+    run_button.pack(pady=10)
+
+def start_make_mask_app():
+    app = MainApp(default_app="Make Masks")
+    app.mainloop()
+
+if __name__ == "__main__":
+    start_make_mask_app()

{spacr-0.1.63 → spacr-0.1.75}/spacr/core.py

@@ -971,7 +971,7 @@ def generate_dataset(src, file_metadata=None, experiment='TSG101_screen', sample
     shutil.rmtree(temp_dir)
     print(f"\nSaved {total_images} images to {tar_name}")
 
-def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', num_workers=10, threshold=0.5, verbose=False):
+def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=224, batch_size=64, normalize=True, preload='images', n_job=10, threshold=0.5, verbose=False):
     
     from .io import TarImageDataset
     from .utils import process_vision_results
@@ -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, num_workers=num_workers, pin_memory=True)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job, 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]  
@@ -1034,7 +1034,7 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
     torch.cuda.memory.empty_cache()
     return df
 
-def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, num_workers=10):
+def apply_model(src, model_path, image_size=224, batch_size=64, normalize=True, n_job=10):
     
     from .io import NoClassDataset
     
@@ -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, num_workers=num_workers)
+    data_loader = DataLoader(dataset, batch_size=batch_size, shuffle=True, n_job=n_job)
     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'
@@ -1302,7 +1302,7 @@ def generate_training_dataset(src, mode='annotation', annotation_column='test',
     
     return
 
-def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], num_workers=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
+def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_size=32, classes=['nc','pc'], n_job=None, validation_split=0.0, max_show=2, pin_memory=False, normalize=False, channels=[1, 2, 3], augment=False, verbose=False):
     
     """
     Generate data loaders for training and validation/test datasets.
@@ -1314,7 +1314,7 @@ def generate_loaders(src, train_mode='erm', mode='train', image_size=224, batch_
     - image_size (int): The size of the input images.
     - batch_size (int): The batch size for the data loaders.
     - classes (list): The list of classes to consider.
-    - num_workers (int): The number of worker threads for data loading.
+    - n_job (int): The number of worker threads for data loading.
     - validation_split (float): The fraction of data to use for validation when train_mode is 'erm'.
     - max_show (int): The maximum number of images to show when verbose is True.
     - pin_memory (bool): Whether to pin memory for faster data transfer.
@@ -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, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+            val_loaders = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
         else:
-            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+            train_loaders = DataLoader(data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job 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, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
-                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(train_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
+                val_loader = DataLoader(val_dataset, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job 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, num_workers=num_workers if num_workers is not None else 0, pin_memory=pin_memory)
+                train_loader = DataLoader(plate_data, batch_size=batch_size, shuffle=shuffle, n_job=n_job if n_job is not None else 0, pin_memory=pin_memory)
                 train_loaders.append(train_loader)
                 val_loaders.append(None)
     
@@ -2078,11 +2078,11 @@ def identify_masks(src, object_type, model_name, batch_size, channels, diameter,
                             else:
                                 radius = 100
 
-                            workers = os.cpu_count()-2
-                            if workers < 1:
-                                workers = 1
+                            n_job = os.cpu_count()-2
+                            if n_job < 1:
+                                n_job = 1
 
-                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, workers=workers)
+                            mask_stack = _btrack_track_cells(src, name, batch_filenames, object_type, plot, save, masks_3D=masks, mode=timelapse_mode, timelapse_remove_transient=timelapse_remove_transient, radius=radius, n_job=n_job)
                         if timelapse_mode == 'trackpy':
                             mask_stack = _trackpy_track_cells(src, name, batch_filenames, object_type, masks, timelapse_displacement, timelapse_memory, timelapse_remove_transient, plot, save, timelapse_mode)
                             
@@ -2303,9 +2303,9 @@ def generate_cellpose_masks(src, settings, object_type):
                         else:
                             radius = 100
 
-                        workers = os.cpu_count()-2
-                        if workers < 1:
-                            workers = 1
+                        n_job = os.cpu_count()-2
+                        if n_job < 1:
+                            n_job = 1
 
                         mask_stack = _btrack_track_cells(src=src,
                                                          name=name,
@@ -2317,7 +2317,7 @@ def generate_cellpose_masks(src, settings, object_type):
                                                          mode=timelapse_mode,
                                                          timelapse_remove_transient=timelapse_remove_transient,
                                                          radius=radius,
-                                                         workers=workers)
+                                                         n_job=n_job)
                     if timelapse_mode == 'trackpy':
                         mask_stack = _trackpy_track_cells(src=src,
                                                           name=name,
@@ -2551,7 +2551,7 @@ def compare_cellpose_masks(src, verbose=False, processes=None, save=True):
         common_files.intersection_update(os.listdir(d))
     common_files = list(common_files)
 
-    # Create a pool of workers
+    # Create a pool of n_job
     with Pool(processes=processes) as pool:
         args = [(src, filename, dirs, conditions) for filename in common_files]
         results = pool.map(compare_mask, args)

{spacr-0.1.63 → spacr-0.1.75}/spacr/deep_spacr.py

@@ -230,7 +230,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                     image_size=settings['image_size'],
                                                     batch_size=settings['batch_size'], 
                                                     classes=settings['classes'], 
-                                                    num_workers=settings['num_workers'],
+                                                    n_job=settings['n_job'],
                                                     validation_split=settings['val_split'],
                                                     pin_memory=settings['pin_memory'],
                                                     normalize=settings['normalize'],
@@ -255,7 +255,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                             optimizer_type = settings['optimizer_type'], 
                             use_checkpoint = settings['use_checkpoint'], 
                             dropout_rate = settings['dropout_rate'], 
-                            num_workers = settings['num_workers'], 
+                            n_job = settings['n_job'], 
                             val_loaders = val, 
                             test_loaders = None, 
                             intermedeate_save = settings['intermedeate_save'],
@@ -276,7 +276,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
                                                      image_size=settings['image_size'],
                                                      batch_size=settings['batch_size'], 
                                                      classes=settings['classes'], 
-                                                     num_workers=settings['num_workers'],
+                                                     n_job=settings['n_job'],
                                                      validation_split=0.0,
                                                      pin_memory=settings['pin_memory'],
                                                      normalize=settings['normalize'],
@@ -315,7 +315,7 @@ def train_test_model(src, settings, custom_model=False, custom_model_path=None):
     torch.cuda.memory.empty_cache()
     gc.collect()
     
-def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, num_workers=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
+def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='erm', epochs=100, learning_rate=0.0001, weight_decay=0.05, amsgrad=False, optimizer_type='adamw', use_checkpoint=False, dropout_rate=0, n_job=20, val_loaders=None, test_loaders=None, init_weights='imagenet', intermedeate_save=None, chan_dict=None, schedule = None, loss_type='binary_cross_entropy_with_logits', gradient_accumulation=False, gradient_accumulation_steps=4, channels=['r','g','b']):
     """
     Trains a model using the specified parameters.
 
@@ -332,7 +332,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         optimizer_type (str, optional): The type of optimizer to use. Defaults to 'adamw'.
         use_checkpoint (bool, optional): Whether to use checkpointing during training. Defaults to False.
         dropout_rate (float, optional): The dropout rate for the model. Defaults to 0.
-        num_workers (int, optional): The number of workers for data loading. Defaults to 20.
+        n_job (int, optional): The number of n_job for data loading. Defaults to 20.
         val_loaders (list, optional): A list of validation data loaders. Defaults to None.
         test_loaders (list, optional): A list of test data loaders. Defaults to None.
         init_weights (str, optional): The initialization weights for the model. Defaults to 'imagenet'.
@@ -357,7 +357,7 @@ def train_model(dst, model_type, train_loaders, train_loader_names, train_mode='
         
     use_cuda = torch.cuda.is_available()
     device = torch.device("cuda" if use_cuda else "cpu")
-    kwargs = {'num_workers': num_workers, 'pin_memory': True} if use_cuda else {}
+    kwargs = {'n_job': n_job, 'pin_memory': True} if use_cuda else {}
     
     for idx, (images, labels, filenames) in enumerate(train_loaders):
         batch, chans, height, width = images.shape

{spacr-0.1.63 → spacr-0.1.75}/spacr/gui.py

@@ -5,8 +5,6 @@ import os, requests
 from multiprocessing import set_start_method
 from .gui_elements import spacrButton, create_menu_bar, set_dark_style
 from .gui_core import initiate_root
-from .app_annotate import initiate_annotation_app_root
-from .app_make_masks import initiate_mask_app_root
 
 class MainApp(tk.Tk):
     def __init__(self, default_app=None):
@@ -22,8 +20,8 @@ class MainApp(tk.Tk):
         self.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": (initiate_annotation_app_root, "Annotation single object images on a grid. Annotations are saved to database."),
-            "Make Masks": (initiate_mask_app_root, "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
+            "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"),
             "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.")
@@ -32,21 +30,8 @@ class MainApp(tk.Tk):
         self.selected_app = tk.StringVar()
         self.create_widgets()
 
-
-        if default_app == "Mask":
+        if default_app in self.gui_apps:
             self.load_app(default_app, self.gui_apps[default_app][0])
-        elif default_app == "Measure":
-            self.load_app(default_app, self.gui_apps[default_app][1])
-        elif default_app == "Annotate":
-            self.load_app(default_app, self.gui_apps[default_app][2])
-        elif default_app == "Make Masks":
-            self.load_app(default_app, self.gui_apps[default_app][3])
-        elif default_app == "Classify":
-            self.load_app(default_app, self.gui_apps[default_app][4])
-        elif default_app == "Sequencing":
-            self.load_app(default_app, self.gui_apps[default_app][5])
-        elif default_app == "Umap":
-            self.load_app(default_app, self.gui_apps[default_app][6])
 
     def create_widgets(self):
         # Create the menu bar
@@ -88,7 +73,6 @@ class MainApp(tk.Tk):
 
             # Create custom button with text
             button = spacrButton(buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), font=('Helvetica', 12))
-            #button = ttk.Button(buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), style='Custom.TButton')
             button.grid(row=i, column=0, pady=10, padx=10, sticky="w")
 
             description_label = tk.Label(buttons_frame, text=app_desc, bg="black", fg="white", wraplength=800, justify="left", font=('Helvetica', 12))
@@ -161,4 +145,4 @@ def gui_app():
 
 if __name__ == "__main__":
     set_start_method('spawn', force=True)
-    gui_app()
+    gui_app()