spacr 0.2.4__tar.gz → 0.2.5__tar.gz

{spacr-0.2.4/spacr.egg-info → spacr-0.2.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.2.4
+Version: 0.2.5
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -39,6 +39,10 @@ Requires-Dist: ttf_opensans>=2020.10.30
 Requires-Dist: customtkinter<6.0,>=5.2.2
 Requires-Dist: biopython<2.0,>=1.80
 Requires-Dist: lxml<6.0,>=5.1.0
+Requires-Dist: psutil<6.0,>=5.9.8
+Requires-Dist: gputil<2.0,>=1.4.0
+Requires-Dist: gpustat<2.0,>=1.1.1
+Requires-Dist: pyautogui<1.0,>=0.9.54
 Requires-Dist: huggingface-hub<0.25,>=0.24.0
 Provides-Extra: dev
 Requires-Dist: pytest<3.11,>=3.9; extra == "dev"

{spacr-0.2.4 → spacr-0.2.5}/setup.py

@@ -45,12 +45,16 @@ dependencies = [
     'customtkinter>=5.2.2,<6.0', 
     'biopython>=1.80,<2.0',
     'lxml>=5.1.0,<6.0',
+    'psutil>=5.9.8, <6.0',
+    'gputil>=1.4.0, <2.0', 
+    'gpustat>=1.1.1,<2.0',
+    'pyautogui>=0.9.54,<1.0',
     'huggingface-hub>=0.24.0,<0.25'
 ]
 
 setup(
     name="spacr",
-    version="0.2.4",
+    version="0.2.5",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",
@@ -58,7 +62,7 @@ setup(
     url="https://github.com/EinarOlafsson/spacr",
     packages=find_packages(exclude=["tests.*", "tests"]),
     include_package_data=True,
-    package_data={'spacr': ['resources/models/cp/*', 'resources/icons/*'],},
+    package_data={'spacr': ['resources/models/cp/*', 'resources/icons/*', 'resources/font/**/*'],},
     install_requires=dependencies,
     entry_points={
         'console_scripts': [

{spacr-0.2.4 → spacr-0.2.5}/spacr/core.py

@@ -39,6 +39,10 @@ matplotlib.use('Agg')
 
 from .logger import log_function_call
 
+import warnings
+warnings.filterwarnings("ignore", message="3D stack used, but stitch_threshold=0 and do_3D=False, so masks are made per plane only")
+
+
 def analyze_plaques(folder):
     summary_data = []
     details_data = []
@@ -80,7 +84,6 @@ def analyze_plaques(folder):
     
     print(f"Analysis completed and saved to database '{db_name}'.")
 
-
 def train_cellpose(settings):
     
     from .io import _load_normalized_images_and_labels, _load_images_and_labels
@@ -1032,10 +1035,6 @@ def apply_model_to_tar(tar_path, model_path, file_type='cell_png', image_size=22
             files_to_process = len(data_loader)
             print_progress(files_processed, files_to_process, n_jobs=n_jobs, time_ls=time_ls, batch_size=batch_size, operation_type="Tar dataset")
 
-
-
-
-
     data = {'path':filenames_list, 'pred':prediction_pos_probs}
     df = pd.DataFrame(data, index=None)
     df = process_vision_results(df, threshold)
@@ -1695,9 +1694,9 @@ def analyze_recruitment(src, metadata_settings={}, advanced_settings={}):
 def preprocess_generate_masks(src, settings={}):
 
     from .io import preprocess_img_data, _load_and_concatenate_arrays
-    from .plot import plot_merged, plot_arrays
-    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks
-    from .settings import set_default_settings_preprocess_generate_masks, set_default_plot_merge_settings
+    from .plot import plot_image_mask_overlay, plot_arrays
+    from .utils import _pivot_counts_table, check_mask_folder, adjust_cell_masks, print_progress
+    from .settings import set_default_settings_preprocess_generate_masks
     
     settings = set_default_settings_preprocess_generate_masks(src, settings)
     settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
@@ -1730,20 +1729,43 @@ def preprocess_generate_masks(src, settings={}):
 
     if settings['preprocess']:
         settings, src = preprocess_img_data(settings)
-        
+
+    files_to_process = 3
     if settings['masks']:
         mask_src = os.path.join(src, 'norm_channel_stack')
         if settings['cell_channel'] != None:
+            start = time.time()
             if check_mask_folder(src, 'cell_mask_stack'):
                 generate_cellpose_masks(mask_src, settings, 'cell')
+                stop = time.time()
+                duration = (stop - start)
+                time_ls.append(duration)
+                files_processed += 1
+                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type=f'cell_mask_gen')
             
         if settings['nucleus_channel'] != None:
+            start = time.time()
             if check_mask_folder(src, 'nucleus_mask_stack'):
                 generate_cellpose_masks(mask_src, settings, 'nucleus')
+                stop = time.time()
+                duration = (stop - start)
+                time_ls.append(duration)
+                files_processed += 1
+                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type=f'nucleus_mask_gen')
             
         if settings['pathogen_channel'] != None:
+            start = time.time()
             if check_mask_folder(src, 'pathogen_mask_stack'):
+                stop = time.time()
+                duration = (stop - start)
+                time_ls.append(duration)
+                files_processed += 1
                 generate_cellpose_masks(mask_src, settings, 'pathogen')
+                print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type=f'pathogen_mask_gen')
+
+        #if settings['organelle'] != None:
+        #    if check_mask_folder(src, 'organelle_mask_stack'):
+        #        generate_cellpose_masks(mask_src, settings, 'organelle')
 
         if settings['adjust_cells']:
             if settings['pathogen_channel'] != None and settings['cell_channel'] != None and settings['nucleus_channel'] != None:
@@ -1752,12 +1774,8 @@ def preprocess_generate_masks(src, settings={}):
                 cell_folder = os.path.join(mask_src, 'cell_mask_stack')
                 nuclei_folder = os.path.join(mask_src, 'nucleus_mask_stack')
                 parasite_folder = os.path.join(mask_src, 'pathogen_mask_stack')
-                #image_folder = os.path.join(src, 'stack')
+                #organelle_folder = os.path.join(mask_src, 'organelle_mask_stack')
 
-                #process_masks(cell_folder, image_folder, settings['cell_channel'], settings['batch_size'], n_clusters=2, plot=settings['plot'])
-                #process_masks(nuclei_folder, image_folder, settings['nucleus_channel'], settings['batch_size'], n_clusters=2, plot=settings['plot'])
-                #process_masks(parasite_folder, image_folder, settings['pathogen_channel'], settings['batch_size'], n_clusters=2, plot=settings['plot'])
-                
                 adjust_cell_masks(parasite_folder, cell_folder, nuclei_folder, overlap_threshold=5, perimeter_threshold=30)
                 stop = time.time()
                 adjust_time = (stop-start)/60
@@ -1771,38 +1789,28 @@ def preprocess_generate_masks(src, settings={}):
         
         if settings['plot']:
             if not settings['timelapse']:
-                plot_dims = len(settings['channels'])
-                overlay_channels = [2,1,0]
-                cell_mask_dim = nucleus_mask_dim = pathogen_mask_dim = None
-                plot_counter = plot_dims
-
-                if settings['cell_channel'] is not None:
-                    cell_mask_dim = plot_counter
-                    plot_counter += 1
-
-                if settings['nucleus_channel'] is not None:
-                    nucleus_mask_dim = plot_counter
-                    plot_counter += 1
-
-                if settings['pathogen_channel'] is not None:
-                    pathogen_mask_dim = plot_counter
-                    
-                overlay_channels = [settings['nucleus_channel'], settings['pathogen_channel'], settings['cell_channel']]
-                overlay_channels = [element for element in overlay_channels if element is not None]
-
-                plot_settings = set_default_plot_merge_settings()
-                plot_settings['channel_dims'] = settings['channels']
-                plot_settings['cell_mask_dim'] = cell_mask_dim
-                plot_settings['nucleus_mask_dim'] = nucleus_mask_dim
-                plot_settings['pathogen_mask_dim'] = pathogen_mask_dim
-                plot_settings['overlay_chans'] = overlay_channels
-                plot_settings['nr'] = settings['examples_to_plot']
 
                 if settings['test_mode'] == True:
-                    plot_settings['nr'] = len(os.path.join(src,'merged'))
+                    settings['examples_to_plot'] = len(os.path.join(src,'merged'))
 
                 try:
-                    fig = plot_merged(src=os.path.join(src,'merged'), settings=plot_settings)
+                    merged_src = os.path.join(src,'merged')
+                    files = os.listdir(merged_src)
+                    random.shuffle(files)
+                    time_ls = []
+                    
+                    for i, file in enumerate(files):
+                        start = time.time()
+                        if i+1 <= settings['examples_to_plot']:
+                            file_path = os.path.join(merged_src, file)
+                            plot_image_mask_overlay(file_path, settings['channels'], settings['cell_channel'], settings['nucleus_channel'], settings['pathogen_channel'], figuresize=10, normalize=True, thickness=3, save_pdf=True)
+                            stop = time.time()
+                            duration = stop-start
+                            time_ls.append(duration)
+                            files_processed = i+1
+                            files_to_process = settings['examples_to_plot']
+                            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="Plot mask outlines")
+                            print("Successfully completed run")
                 except Exception as e:
                     print(f'Failed to plot image mask overly. Error: {e}')
             else:
@@ -2010,7 +2018,7 @@ def generate_cellpose_masks(src, settings, object_type):
     
     if object_type == 'pathogen' and not settings['pathogen_model'] is None:
         model_name = settings['pathogen_model']
-
+    
     model = _choose_model(model_name, device, object_type=object_type, restore_type=None, object_settings=object_settings)
 
     chans = [2, 1] if model_name == 'cyto2' else [0,0] if model_name == 'nucleus' else [2,0] if model_name == 'cyto' else [2, 0] if model_name == 'cyto3' else [2, 0]
@@ -2022,16 +2030,18 @@ def generate_cellpose_masks(src, settings, object_type):
     
     average_sizes = []
     time_ls = []
+    
     for file_index, path in enumerate(paths):
         name = os.path.basename(path)
         name, ext = os.path.splitext(name)
         output_folder = os.path.join(os.path.dirname(path), object_type+'_mask_stack')
         os.makedirs(output_folder, exist_ok=True)
         overall_average_size = 0
+        
         with np.load(path) as data:
             stack = data['data']
             filenames = data['filenames']
-
+            
             for i, filename in enumerate(filenames):
                 output_path = os.path.join(output_folder, filename)
                 
@@ -2057,11 +2067,8 @@ def generate_cellpose_masks(src, settings, object_type):
                         batch_size = len(stack)
                         print(f'Cut batch at indecies: {timelapse_frame_limits}, New batch_size: {batch_size} ')
         
-        files_processed = 0
         for i in range(0, stack.shape[0], batch_size):
             mask_stack = []
-            start = time.time()
-
             if stack.shape[3] == 1:
                 batch = stack[i: i+batch_size, :, :, [0,0]].astype(stack.dtype)
             else:
@@ -2072,7 +2079,6 @@ def generate_cellpose_masks(src, settings, object_type):
             if not settings['plot']:
                 batch, batch_filenames = _check_masks(batch, batch_filenames, output_folder)
             if batch.size == 0:
-                print(f'Processing {file_index}/{len(paths)}: Images/npz {batch.shape[0]}')
                 continue
             
             batch = prepare_batch_for_cellpose(batch)
@@ -2083,16 +2089,6 @@ def generate_cellpose_masks(src, settings, object_type):
                 save_path = os.path.join(movie_path, f'timelapse_{object_type}_{name}.mp4')
                 _npz_to_movie(batch, batch_filenames, save_path, fps=2)
             
-            if settings['verbose']:
-                print(f'Processing {file_index}/{len(paths)}: Images/npz {batch.shape[0]}')
-
-            #cellpose_normalize_dict = {'lowhigh':[0.0,1.0], #pass in normalization values for 0.0 and 1.0 as list [low, high] if None all other keys ignored
-            #                           'sharpen':object_settings['diameter']/4, #recommended to be 1/4-1/8 diameter of cells in pixels
-            #                           'normalize':True, #(if False, all following parameters ignored)
-            #                           'percentile':[2,98], #[perc_low, perc_high]
-            #                           'tile_norm':224, #normalize by tile set to e.g. 100 for normailize window to be 100 px
-            #                           'norm3D':True} #compute normalization across entire z-stack rather than plane-by-plane in stitching mode.
-            
             output = model.eval(x=batch,
                                 batch_size=cellpose_batch_size,
                                 normalize=False,
@@ -2202,16 +2198,8 @@ def generate_cellpose_masks(src, settings, object_type):
 
             average_sizes.append(average_obj_size) 
             overall_average_size = np.mean(average_sizes) if len(average_sizes) > 0 else 0
+            print(f'object_size:{object_type}: {overall_average_size:.3f} px2')
 
-            stop = time.time()
-            duration = (stop - start)
-            time_ls.append(duration)
-            files_processed += len(batch_filenames)
-            #files_processed = (file_index+1)*(batch_size+1)
-            files_to_process = (len(paths))*(batch_size)
-            print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=batch_size, operation_type=f'{object_type}_mask_gen')
-            print(f'object_size:{object_type}): {overall_average_size:.3f} px2')
-        
         if not timelapse:
             if settings['plot']:
                 plot_masks(batch, mask_stack, flows, figuresize=figuresize, cmap='inferno', nr=batch_size)
@@ -2222,6 +2210,7 @@ def generate_cellpose_masks(src, settings, object_type):
                 np.save(output_filename, mask)
             mask_stack = []
             batch_filenames = []
+
         gc.collect()
     torch.cuda.empty_cache()
     return

{spacr-0.2.4 → spacr-0.2.5}/spacr/gui.py

@@ -15,30 +15,29 @@ class MainApp(tk.Tk):
         self.title("SpaCr GUI Collection")
         self.configure(bg='#333333')  # Set window background to dark gray
 
-        # Initialize style and apply dark style to the main window
         style = ttk.Style()
         self.color_settings = set_dark_style(style, parent_frame=self)
-        self.main_buttons = {}  # Initialize main_buttons dictionary here
-        self.additional_buttons = {}  # Initialize additional_buttons dictionary here
+        self.main_buttons = {}
+        self.additional_buttons = {}
 
         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"),
-            "Classify": (lambda frame: initiate_root(frame, 'classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images."),
+            "Mask": (lambda frame: initiate_root(self, 'mask'), "Generate cellpose masks for cells, nuclei and pathogen images."),
+            "Measure": (lambda frame: initiate_root(self, 'measure'), "Measure single object intensity and morphological feature. Crop and save single object image"),
+            "Annotate": (lambda frame: initiate_root(self, 'annotate'), "Annotation single object images on a grid. Annotations are saved to database."),
+            "Make Masks": (lambda frame: initiate_root(self, 'make_masks'), "Adjust pre-existing Cellpose models to your specific dataset for improved performance"),
+            "Classify": (lambda frame: initiate_root(self, 'classify'), "Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object 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.")
+            "Sequencing": (lambda frame: initiate_root(self, 'sequencing'), "Analyze sequencing data."),
+            "Umap": (lambda frame: initiate_root(self, 'umap'), "Generate UMAP embeddings with datapoints represented as images."),
+            "Train Cellpose": (lambda frame: initiate_root(self, 'train_cellpose'), "Train custom Cellpose models."),
+            "ML Analyze": (lambda frame: initiate_root(self, 'ml_analyze'), "Machine learning analysis of data."),
+            "Cellpose Masks": (lambda frame: initiate_root(self, 'cellpose_masks'), "Generate Cellpose masks."),
+            "Cellpose All": (lambda frame: initiate_root(self, 'cellpose_all'), "Run Cellpose on all images."),
+            "Map Barcodes": (lambda frame: initiate_root(self, 'map_barcodes'), "Map barcodes to data."),
+            "Regression": (lambda frame: initiate_root(self, 'regression'), "Perform regression analysis."),
+            "Recruitment": (lambda frame: initiate_root(self, 'recruitment'), "Analyze recruitment data.")
         }
 
         self.selected_app = tk.StringVar()
@@ -50,32 +49,25 @@ class MainApp(tk.Tk):
             self.load_app(default_app, self.additional_gui_apps[default_app][0])
 
     def create_widgets(self):
-        # Create the menu bar
         create_menu_bar(self)
 
-        # Create a canvas to hold the selected app and other elements
         self.canvas = tk.Canvas(self, highlightthickness=0)
         self.canvas.grid(row=0, column=0, sticky="nsew")
         self.grid_rowconfigure(0, weight=1)
         self.grid_columnconfigure(0, weight=1)
 
-        # Create a frame inside the canvas to hold the main content
         self.content_frame = tk.Frame(self.canvas)
         self.content_frame.grid(row=0, column=0, sticky="nsew")
 
-        # Center the content frame within the canvas
         self.canvas.create_window((self.winfo_screenwidth() // 2, self.winfo_screenheight() // 2), window=self.content_frame, anchor="center")
 
-        # Apply dark style to canvas and content_frame
         set_dark_style(ttk.Style(), containers=[self.canvas, self.content_frame])
 
-        # 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):
         self.clear_frame(self.content_frame)
 
-        # Create frames for the grids
         main_buttons_frame = tk.Frame(self.content_frame)
         main_buttons_frame.pack(pady=10)
         set_dark_style(ttk.Style(), containers=[main_buttons_frame])
@@ -84,41 +76,33 @@ class MainApp(tk.Tk):
         additional_buttons_frame.pack(pady=10)
         set_dark_style(ttk.Style(), containers=[additional_buttons_frame])
 
-        # Create a frame for the description below the icon grids
         description_frame = tk.Frame(self.content_frame, height=70)
         description_frame.pack(fill=tk.X, pady=10)
-        description_frame.pack_propagate(False)  # Prevent the frame from resizing based on its content
+        description_frame.pack_propagate(False)
         set_dark_style(ttk.Style(), containers=[description_frame])
 
-        # Use a Label widget to display descriptions
         self.description_label = tk.Label(description_frame, text="", wraplength=800, justify="center", font=('Helvetica', 12), fg=self.color_settings['fg_color'], bg=self.color_settings['bg_color'])
         self.description_label.pack(fill=tk.BOTH, pady=10)
 
-        # Load the logo image and place it in the main apps row
         logo_button = spacrButton(main_buttons_frame, text="SpaCr", command=lambda: self.load_app("logo_spacr", initiate_root), icon_name="logo_spacr", size=100, show_text=False)
         logo_button.grid(row=0, column=0, padx=5, pady=5)
         self.main_buttons[logo_button] = "SpaCr provides a flexible toolset to extract single-cell images and measurements from high-content cell painting experiments, train deep-learning models to classify cellular/subcellular phenotypes, simulate, and analyze pooled CRISPR-Cas9 imaging screens.."
 
-        # Create icon buttons for the main apps
         for i, (app_name, app_data) in enumerate(self.main_gui_apps.items()):
             app_func, app_desc = app_data
             button = spacrButton(main_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=100, show_text=False)
             button.grid(row=0, column=i + 1, padx=5, pady=5)
             self.main_buttons[button] = app_desc
 
-        # Create icon buttons for the additional apps
         for i, (app_name, app_data) in enumerate(self.additional_gui_apps.items()):
             app_func, app_desc = app_data
             button = spacrButton(additional_buttons_frame, text=app_name, command=lambda app_name=app_name, app_func=app_func: self.load_app(app_name, app_func), icon_name=app_name.lower(), size=75, show_text=False)
             button.grid(row=0, column=i, padx=5, pady=5)
             self.additional_buttons[button] = app_desc
 
-        # Update description initially
         self.update_description()
-        #
 
     def update_description(self):
-        # Check all buttons and update description if any has the active color
         for button, desc in {**self.main_buttons, **self.additional_buttons}.items():
             if button.canvas.itemcget(button.button_bg, "fill") == self.color_settings['active_color']:
                 self.show_description(desc)
@@ -128,18 +112,16 @@ class MainApp(tk.Tk):
     def show_description(self, description):
         if self.description_label.winfo_exists():
             self.description_label.config(text=description)
-            self.description_label.update_idletasks()  # Ensure the label updates immediately
+            self.description_label.update_idletasks()
 
     def clear_description(self):
         if self.description_label.winfo_exists():
             self.description_label.config(text="")
-            self.description_label.update_idletasks()  # Ensure the label updates immediately
+            self.description_label.update_idletasks()
 
     def load_app(self, app_name, app_func):
-        # Clear the current content frame
         self.clear_frame(self.canvas)
 
-        # Initialize the selected app
         app_frame = tk.Frame(self.canvas)
         app_frame.pack(fill=tk.BOTH, expand=True)
         set_dark_style(ttk.Style(), containers=[app_frame])
@@ -155,4 +137,4 @@ def gui_app():
 
 if __name__ == "__main__":
     set_start_method('spawn', force=True)
-    gui_app()
+    gui_app()