spacr 0.5.0__py3-none-any.whl → 0.9.1__py3-none-any.whl

spacr/__init__.py

@@ -21,7 +21,6 @@ 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
@@ -52,7 +51,6 @@ __all__ = [
     "app_classify",
     "app_sequencing",
     "app_umap",
-    "mediar",
     "submodules",
     "openai",
     "ml",

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)
@@ -386,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,
@@ -397,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:
@@ -819,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_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}")
                 
@@ -1083,81 +1083,6 @@ def process_console_queue():
     # **Continue processing if no error was detected**
     after_id = console_output.after(uppdate_frequency, process_console_queue)
     parent_frame.after_tasks.append(after_id)
-    
-def process_console_queue_v2():
-    global q, console_output, parent_frame, progress_bar, process_console_queue
-
-    # Initialize function attribute if it doesn't exist
-    if not hasattr(process_console_queue, "completed_tasks"):
-        process_console_queue.completed_tasks = []
-    if not hasattr(process_console_queue, "current_maximum"):
-        process_console_queue.current_maximum = None
-
-    ansi_escape_pattern = re.compile(r'\x1B\[[0-?]*[ -/]*[@-~]')
-
-    while not q.empty():
-        message = q.get_nowait()
-        clean_message = ansi_escape_pattern.sub('', message)
-
-        # **Abort Execution if an Error Message is Detected**
-        if clean_message.startswith("Error:"):
-            console_output.insert(tk.END, clean_message + "\n", "error")
-            console_output.see(tk.END)
-            print("Run aborted due to error:", clean_message)  # Debug message
-            return  # **Exit immediately to stop further execution**
-
-        # Check if the message contains progress information
-        if clean_message.startswith("Progress:"):
-            try:
-                # Extract the progress information
-                match = re.search(r'Progress: (\d+)/(\d+), operation_type: ([\w\s]*),(.*)', clean_message)
-
-                if match:
-                    current_progress = int(match.group(1))
-                    total_progress = int(match.group(2))
-                    operation_type = match.group(3).strip()
-                    additional_info = match.group(4).strip()  # Capture everything after operation_type
-                    
-                    # Check if the maximum value has changed
-                    if process_console_queue.current_maximum != total_progress:
-                        process_console_queue.current_maximum = total_progress
-                        process_console_queue.completed_tasks = []
-
-                    # Add the task to the completed set
-                    process_console_queue.completed_tasks.append(current_progress)
-                    
-                    # Calculate the unique progress count
-                    unique_progress_count = len(np.unique(process_console_queue.completed_tasks))
-
-                    # Update the progress bar
-                    if progress_bar:
-                        progress_bar['maximum'] = total_progress
-                        progress_bar['value'] = unique_progress_count
-
-                    # Store operation type and additional info
-                    if operation_type:
-                        progress_bar.operation_type = operation_type
-                        progress_bar.additional_info = additional_info
-
-                    # Update the progress label
-                    if progress_bar.progress_label:
-                        progress_bar.update_label()
-
-                    # Clear completed tasks when progress is complete
-                    if unique_progress_count >= total_progress:
-                        process_console_queue.completed_tasks.clear()
-
-            except Exception as e:
-                print(f"Error parsing progress message: {e}")
-
-        else:
-            # Insert non-progress messages into the console
-            console_output.insert(tk.END, clean_message + "\n")
-            console_output.see(tk.END)
-
-    # **Continue processing if no error was detected**
-    after_id = console_output.after(uppdate_frequency, process_console_queue)
-    parent_frame.after_tasks.append(after_id)
 
 def main_thread_update_function(root, q, fig_queue, canvas_widget):
     global uppdate_frequency

spacr/gui_utils.py

@@ -376,26 +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']", "['cell', 'nucleus']", "['cell', 'pathogen']", "['nucleus', 'pathogen']", "['cell', 'nucleus', 'pathogen']", None], None),
-        #'timelapse_objects': ('combo', '[cell]', '[nucleus]', '[pathogen]', '[cytoplasm]', 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'),

spacr/io.py

@@ -1175,7 +1175,7 @@ def concatenate_and_normalize(src, channels, save_dtype=np.float32, settings={})
 
     paths = []
     time_ls = []
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     if settings['timelapse']:
@@ -1333,7 +1333,7 @@ def _normalize_stack(src, backgrounds=[100, 100, 100], remove_backgrounds=[False
         None
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
     time_ls = []
     
@@ -1418,7 +1418,7 @@ def _normalize_timelapse(src, lower_percentile=2, save_dtype=np.float32):
         save_dtype (numpy.dtype, optional): The data type to save the normalized stack. Defaults to np.float32.
     """
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]
-    output_fldr = os.path.join(os.path.dirname(src), 'norm_channel_stack')
+    output_fldr = os.path.join(os.path.dirname(src), 'masks')
     os.makedirs(output_fldr, exist_ok=True)
 
     for file_index, path in enumerate(paths):
@@ -1567,16 +1567,16 @@ def preprocess_img_data(settings):
     Returns:
         None
     """
-    
     src = settings['src']
-    delete_empty_subdirectories(src)
-    files = os.listdir(src)
     
+    if len(os.listdir(src)) < 100:
+        delete_empty_subdirectories(src)
+    
+    files = os.listdir(src)
     valid_ext = ['tif', 'tiff', 'png', 'jpg', 'jpeg', 'bmp', 'nd2', 'czi', 'lif']
     extensions = [file.split('.')[-1].lower() for file in files]
     # Filter only valid extensions
     valid_extensions = [ext for ext in extensions if ext in valid_ext]
-
     # Determine most common valid extension
     img_format = None
     if valid_extensions:
@@ -1595,10 +1595,10 @@ def preprocess_img_data(settings):
             print('Found existing stack folder.')
         if os.path.exists(os.path.join(src,'channel_stack')):
             print('Found existing channel_stack folder.')
-        if os.path.exists(os.path.join(src,'norm_channel_stack')):
-            print('Found existing norm_channel_stack folder. Skipping preprocessing')
+        if os.path.exists(os.path.join(src,'masks')):
+            print('Found existing masks folder. Skipping preprocessing')
             return settings, src
-        
+
     mask_channels = [settings['nucleus_channel'], settings['cell_channel'], settings['pathogen_channel']]
 
     settings = set_default_settings_preprocess_img_data(settings)
@@ -1606,16 +1606,16 @@ def preprocess_img_data(settings):
     regex = _get_regex(settings['metadata_type'], img_format, settings['custom_regex'])
     
     if settings['test_mode']:
-
         print(f"Running spacr in test mode")
         settings['plot'] = True
-        try:
-            os.rmdir(os.path.join(src, 'test'))
-            print(f"Deleted test directory: {os.path.join(src, 'test')}")
-        except OSError as e:
-            print(f"Error deleting test directory: {e}")
-            print(f"Delete manually before running test mode")
-            pass
+        if os.path.exists(os.path.join(src,'test')):
+            try:
+                os.rmdir(os.path.join(src, 'test'))
+                print(f"Deleted test directory: {os.path.join(src, 'test')}")
+            except OSError as e:
+                print(f"Error deleting test directory: {e}")
+                print(f"Delete manually before running test mode")
+                pass
 
         src = _run_test_mode(settings['src'], regex, settings['timelapse'], settings['test_images'], settings['random_test'])
         settings['src'] = src
@@ -1991,12 +1991,12 @@ def _load_and_concatenate_arrays(src, channels, cell_chann_dim, nucleus_chann_di
     """
     folder_paths = [os.path.join(src+'/stack')]
 
-    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'cell_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','cell_mask_stack')]
-    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'nucleus_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','nucleus_mask_stack')]
-    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'norm_channel_stack', 'pathogen_mask_stack')):
-        folder_paths = folder_paths + [os.path.join(src, 'norm_channel_stack','pathogen_mask_stack')]
+    if cell_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'cell_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','cell_mask_stack')]
+    if nucleus_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'nucleus_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','nucleus_mask_stack')]
+    if pathogen_chann_dim is not None or os.path.exists(os.path.join(src, 'masks', 'pathogen_mask_stack')):
+        folder_paths = folder_paths + [os.path.join(src, 'masks','pathogen_mask_stack')]
 
     output_folder = src+'/merged'
     reference_folder = folder_paths[0]
@@ -2870,7 +2870,6 @@ def generate_training_dataset(settings):
 
         return class_paths_ls
     
-    from .io import _read_and_merge_data, _read_db
     from .utils import get_paths_from_db, annotate_conditions, save_settings
     from .settings import set_generate_training_dataset_defaults
     

spacr/mediar.py

@@ -15,14 +15,18 @@ if not os.path.exists(init_file):
 # Add MEDIAR to sys.path
 sys.path.insert(0, mediar_path)
 
-try:
-    # Now import the dependencies from MEDIAR
-    from core.MEDIAR import Predictor, EnsemblePredictor
-    from train_tools.models import MEDIARFormer
-finally:
-    # Remove the temporary __init__.py file after the import
-    if os.path.exists(init_file):
-        os.remove(init_file)  # Remove the __init__.py file
+#try:
+#     Now import the dependencies from MEDIAR
+#    from core.MEDIAR import Predictor, EnsemblePredictor
+#    from train_tools.models import MEDIARFormer
+
+#    from train_tools.models import MEDIARFormer
+Predictor, EnsemblePredictor, MEDIARFormer = None, None, None
+
+#finally:
+#    # Remove the temporary __init__.py file after the import
+#    if os.path.exists(init_file):
+#        os.remove(init_file)  # Remove the __init__.py file
 
 def display_imgs_in_list(lists_of_imgs, cmaps=None):
     """