spacr 0.4.60__py3-none-any.whl → 0.9.0__py3-none-any.whl

spacr/__init__.py

@@ -21,12 +21,11 @@ from . import app_measure
 from . import app_classify
 from . import app_sequencing
 from . import app_umap
-from . import mediar
 from . import submodules
 from . import openai
 from . import ml
 from . import toxo
-from . import cellpose
+from . import spacr_cellpose
 from . import sp_stats
 from . import logger
 
@@ -52,12 +51,11 @@ __all__ = [
     "app_classify",
     "app_sequencing",
     "app_umap",
-    "mediar",
     "submodules",
     "openai",
     "ml",
     "toxo",
-    "cellpose",
+    "spacr_cellpose",
     "sp_stats",
     "logger"
 ]

spacr/__main__.py

@@ -1,6 +1,6 @@
 """
-Copyright © 2024 Something
+Copyright © 2025 Something
 """
 
-if __name__ == "__main__":
-    main()
+#if __name__ == "__main__":
+#    main()

spacr/core.py

@@ -98,15 +98,12 @@ def preprocess_generate_masks(settings):
             files_to_process = 3
             files_processed = 0
             if settings['masks']:
-                mask_src = os.path.join(src, 'norm_channel_stack')
+                mask_src = os.path.join(src, 'masks')
                 if settings['cell_channel'] != None:
                     time_ls=[]
                     if check_mask_folder(src, 'cell_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'cell')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'cell')
+                        generate_cellpose_masks(mask_src, settings, 'cell')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -117,10 +114,7 @@ def preprocess_generate_masks(settings):
                     time_ls=[]
                     if check_mask_folder(src, 'nucleus_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'nucleus')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'nucleus')
+                        generate_cellpose_masks(mask_src, settings, 'nucleus')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -131,10 +125,7 @@ def preprocess_generate_masks(settings):
                     time_ls=[]
                     if check_mask_folder(src, 'pathogen_mask_stack'):
                         start = time.time()
-                        if settings['segmentation_mode'] == 'cellpose':
-                            generate_cellpose_masks(mask_src, settings, 'pathogen')
-                        elif settings['segmentation_mode'] == 'mediar':
-                            generate_mediar_masks(mask_src, settings, 'pathogen')
+                        generate_cellpose_masks(mask_src, settings, 'pathogen')
                         stop = time.time()
                         duration = (stop - start)
                         time_ls.append(duration)
@@ -167,7 +158,6 @@ def preprocess_generate_masks(settings):
                 
                 if settings['plot']:
                     if not settings['timelapse']:
-
                         if settings['test_mode'] == True:
                             settings['examples_to_plot'] = len(os.path.join(src,'merged'))
 
@@ -387,7 +377,13 @@ def generate_cellpose_masks(src, settings, object_type):
                                                          timelapse_remove_transient=timelapse_remove_transient,
                                                          radius=radius,
                                                          n_jobs=n_jobs)
-                    if timelapse_mode == 'trackpy':
+                    
+                    if timelapse_mode == 'trackpy' or timelapse_mode == 'iou':
+                        if timelapse_mode == 'iou':
+                            track_by_iou = True
+                        else:
+                            track_by_iou = False
+                        
                         mask_stack = _trackpy_track_cells(src=src,
                                                           name=name,
                                                           batch_filenames=batch_filenames,
@@ -398,7 +394,8 @@ def generate_cellpose_masks(src, settings, object_type):
                                                           timelapse_remove_transient=timelapse_remove_transient,
                                                           plot=settings['plot'],
                                                           save=settings['save'],
-                                                          mode=timelapse_mode)
+                                                          mode=timelapse_mode,
+                                                          track_by_iou=track_by_iou)
                 else:
                     mask_stack = _masks_to_masks_stack(masks)
             else:
@@ -820,97 +817,6 @@ def reducer_hyperparameter_search(settings={}, reduction_params=None, dbscan_par
 
     return
 
-def generate_mediar_masks(src, settings, object_type):
-    """
-    Generates masks using the MEDIARPredictor.
-    
-    :param src: Source folder containing images or npz files.
-    :param settings: Dictionary of settings for generating masks.
-    :param object_type: Type of object to detect (e.g., 'cell', 'nucleus', etc.).
-    """
-    from .mediar import MEDIARPredictor
-    from .io import _create_database, _save_object_counts_to_database
-    from .plot import plot_masks
-    from .settings import set_default_settings_preprocess_generate_masks
-    from .utils import prepare_batch_for_segmentation
-
-    # Clear CUDA cache and check if CUDA is available
-    gc.collect()
-    if not torch.cuda.is_available():
-        print(f'Torch CUDA is not available, using CPU')
-
-    settings['src'] = src
-
-    # Preprocess settings
-    settings = set_default_settings_preprocess_generate_masks(settings)
-
-    if settings['verbose']:
-        settings_df = pd.DataFrame(list(settings.items()), columns=['setting_key', 'setting_value'])
-        settings_df['setting_value'] = settings_df['setting_value'].apply(str)
-        display(settings_df)
-
-    figuresize = 10
-    timelapse = settings['timelapse']
-    batch_size = settings['batch_size']
-
-    # Get object settings and initialize MEDIARPredictor
-    mediar_predictor = MEDIARPredictor(input_path=None, output_path=None, normalize=settings['normalize'], use_tta=False)
-
-    # Paths to input npz files
-    paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-
-    # Initialize a database for saving measurements
-    count_loc = os.path.join(os.path.dirname(src), 'measurements', 'measurements.db')
-    os.makedirs(os.path.dirname(src) + '/measurements', exist_ok=True)
-    _create_database(count_loc)
-
-    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), f'{object_type}_mask_stack')
-        os.makedirs(output_folder, exist_ok=True)
-
-        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)
-                if os.path.exists(output_path):
-                    print(f"File {filename} already exists. Skipping...")
-                    continue
-
-        # Process each batch of images in the stack
-        for i in range(0, stack.shape[0], batch_size):
-            batch = stack[i: i + batch_size]
-            batch_filenames = filenames[i: i + batch_size]
-
-            # Prepare batch for MEDIARPredictor (optional)
-            batch = prepare_batch_for_segmentation(batch)
-
-            # Predict masks using MEDIARPredictor
-            predicted_masks = mediar_predictor.predict_batch(batch)
-
-            # Save predicted masks
-            for j, mask in enumerate(predicted_masks):
-                output_filename = os.path.join(output_folder, batch_filenames[j])
-                mask = mask.astype(np.uint16)
-                np.save(output_filename, mask)
-
-            # Optional: Plot the masks
-            if settings['plot']:
-                for idx, mask in enumerate(predicted_masks):
-                    plot_masks(batch[idx], mask, cmap='inferno', figuresize=figuresize)
-
-            # Save object counts to database
-            _save_object_counts_to_database(predicted_masks, object_type, batch_filenames, count_loc)
-
-        # Clear CUDA cache after each file
-        gc.collect()
-        torch.cuda.empty_cache()
-
-    print("Mask generation completed.")
-
 def generate_screen_graphs(settings):
     """
     Generate screen graphs for different measurements in a given source directory.

spacr/gui.py

@@ -48,7 +48,6 @@ class MainApp(tk.Tk):
         }
 
         self.additional_gui_apps = {
-            "Convert": (lambda frame: initiate_root(self, 'convert'), "Convert images to Grayscale TIFs."),
             "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."),

spacr/gui_core.py

@@ -872,7 +872,7 @@ def check_src_folders_files(settings, settings_type, q):
                 pictures_continue = _folder_has_images(path)
                 folder_chan_continue = _has_folder(path, "1")
                 folder_stack_continue = _has_folder(path, "stack")
-                folder_npz_continue = _has_folder(path, "norm_channel_stack")
+                folder_npz_continue = _has_folder(path, "masks")
             
                 if not pictures_continue:
                     if not any([folder_chan_continue, folder_stack_continue, folder_npz_continue]):
@@ -883,7 +883,7 @@ def check_src_folders_files(settings, settings_type, q):
                             q.put(f"Error: Missing stack folder in folder: {path}")
                             
                         if not folder_npz_continue:
-                            q.put(f"Error: Missing norm_channel_stack folder in folder: {path}")
+                            q.put(f"Error: Missing masks folder in folder: {path}")
                         else:
                             q.put(f"Error: No images in folder: {path}")
                 

spacr/gui_utils.py

@@ -376,25 +376,14 @@ def convert_settings_dict_for_gui(settings):
         'channel_dims': ('combo', chan_list, '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),
         'cov_type': ('combo', ['HC0', 'HC1', 'HC2', 'HC3', None], None),
-        #'cell_mask_dim': ('combo', chans_v3, None),
-        #'cell_chann_dim': ('combo', chans_v3, None),
-        #'nucleus_mask_dim': ('combo', chans_v3, None),
-        #'nucleus_chann_dim': ('combo', chans_v3, None),
-        #'pathogen_mask_dim': ('combo', chans_v3, None),
-        #'pathogen_chann_dim': ('combo', chans_v3, None),
         'crop_mode': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']"], "['cell']"),
-         #'magnification': ('combo', [20, 40, 60], 20),
-        #'nucleus_channel': ('combo', chans_v3, None),
-        #'cell_channel': ('combo', chans_v3, None),
-        #'channel_of_interest': ('combo', chans_v3, None),
-        #'pathogen_channel': ('combo', chans_v3, None),
-        'timelapse_mode': ('combo', ['trackpy', 'btrack'], 'trackpy'),
+        'timelapse_mode': ('combo', ['trackpy', 'iou', 'btrack'], 'trackpy'),
         'train_mode': ('combo', ['erm', 'irm'], 'erm'),
         'clustering': ('combo', ['dbscan', 'kmean'], 'dbscan'),
         'reduction_method': ('combo', ['umap', 'tsne'], 'umap'),
         'model_name': ('combo', ['cyto', 'cyto_2', 'cyto_3', 'nuclei'], 'cyto'),
         'regression_type': ('combo', ['ols','gls','wls','rlm','glm','mixed','quantile','logit','probit','poisson','lasso','ridge'], 'ols'),
-        'timelapse_objects': ('combo', ['cell', 'nucleus', 'pathogen', 'cytoplasm', None], None),
+        'timelapse_objects': ('combo', ["['cell']", "['nucleus']", "['pathogen']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']", None], None),
         'model_type': ('combo', torchvision_models, 'resnet50'),
         'optimizer_type': ('combo', ['adamw', 'adam'], 'adamw'),
         'schedule': ('combo', ['reduce_lr_on_plateau', 'step_lr'], 'reduce_lr_on_plateau'),
@@ -470,7 +459,7 @@ def function_gui_wrapper(function=None, settings={}, q=None, fig_queue=None, imp
 def run_function_gui(settings_type, settings, q, fig_queue, stop_requested):
     
     from .core import generate_image_umap, preprocess_generate_masks
-    from .cellpose import identify_masks_finetune, check_cellpose_models, compare_cellpose_masks
+    from .spacr_cellpose import identify_masks_finetune, check_cellpose_models, compare_cellpose_masks
     from .submodules import analyze_recruitment
     from .ml import generate_ml_scores, perform_regression
     from .submodules import train_cellpose, analyze_plaques
@@ -939,8 +928,10 @@ def convert_to_number(value):
     
     """
     Converts a string value to an integer if possible, otherwise converts to a float.
+
     Args:
         value (str): The string representation of the number.
+
     Returns:
         int or float: The converted number.
     """