spacr 0.9.4__tar.gz → 0.9.7__tar.gz

{spacr-0.9.4/spacr.egg-info → spacr-0.9.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.9.4
+Version: 0.9.7
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -14,6 +14,7 @@ Requires-Dist: numpy<2.0,>=1.26.4
 Requires-Dist: pandas<3.0,>=2.2.1
 Requires-Dist: scipy<2.0,>=1.12.0
 Requires-Dist: cellpose<5.0,>=4.0
+Requires-Dist: segment-anything
 Requires-Dist: scikit-image<1.0,>=0.22.0
 Requires-Dist: scikit-learn<2.0,>=1.4.1
 Requires-Dist: scikit-posthocs<0.20,>=0.10.0

{spacr-0.9.4 → spacr-0.9.7}/setup.py

@@ -10,6 +10,7 @@ dependencies = [
     'pandas>=2.2.1,<3.0',
     'scipy>=1.12.0,<2.0',
     'cellpose>=4.0,<5.0', # changed max to 5 from 4 3.0.6
+    'segment-anything',
     'scikit-image>=0.22.0,<1.0',
     'scikit-learn>=1.4.1,<2.0',
     'scikit-posthocs>=0.10.0, <0.20',
@@ -71,7 +72,7 @@ dependencies = [
     'huggingface-hub>=0.24.0,<0.25'
 ]
 
-VERSION = "0.9.4"
+VERSION = "0.9.7"
 
 setup(
     name="spacr",

{spacr-0.9.4 → spacr-0.9.7}/spacr/core.py

@@ -196,11 +196,12 @@ def preprocess_generate_masks(settings):
 
 def generate_cellpose_masks(src, settings, object_type):
     
-    from .utils import _masks_to_masks_stack, _filter_cp_masks, _get_cellpose_batch_size, _get_cellpose_channels, _choose_model, mask_object_count, all_elements_match, prepare_batch_for_segmentation
+    from .utils import _masks_to_masks_stack, _filter_cp_masks, _get_cellpose_batch_size, _get_cellpose_channels, _choose_model, all_elements_match, prepare_batch_for_segmentation
     from .io import _create_database, _save_object_counts_to_database, _check_masks, _get_avg_object_size
     from .timelapse import _npz_to_movie, _btrack_track_cells, _trackpy_track_cells
-    from .plot import plot_masks
+    from .plot import plot_cellpose4_output
     from .settings import set_default_settings_preprocess_generate_masks, _get_object_settings
+    from .spacr_cellpose import parse_cellpose4_output
     
     gc.collect()
     if not torch.cuda.is_available():
@@ -239,9 +240,12 @@ def generate_cellpose_masks(src, settings, object_type):
     cellpose_channels = _get_cellpose_channels(src, settings['nucleus_channel'], settings['pathogen_channel'], settings['cell_channel'])
     if settings['verbose']:
         print(cellpose_channels)
-
+        
+    if object_type not in cellpose_channels:
+        raise ValueError(f"Error: No channels were specified for object_type '{object_type}'. Check your settings.")
     channels = cellpose_channels[object_type]
-    cellpose_batch_size = _get_cellpose_batch_size()
+
+    #cellpose_batch_size = _get_cellpose_batch_size()
     device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
     
     if object_type == 'pathogen' and not settings['pathogen_model'] is None:
@@ -249,7 +253,8 @@ def generate_cellpose_masks(src, settings, object_type):
     
     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]
+    #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]
+    
     paths = [os.path.join(src, file) for file in os.listdir(src) if file.endswith('.npz')]    
     
     count_loc = os.path.dirname(src)+'/measurements/measurements.db'
@@ -257,6 +262,7 @@ def generate_cellpose_masks(src, settings, object_type):
     _create_database(count_loc)
     
     average_sizes = []
+    average_count = []
     time_ls = []
     
     for file_index, path in enumerate(paths):
@@ -310,49 +316,30 @@ def generate_cellpose_masks(src, settings, object_type):
                 continue
             
             batch = prepare_batch_for_segmentation(batch)
-            
-            
-            #if settings['denoise']:
-            #    if object_type == 'cell':
-            #        model_type = "denoise_cyto3"
-            #    elif object_type == 'nucleus':
-            #        model_type = "denoise_nucleus"
-            #    else:
-            #        raise ValueError(f"No denoise model for object_type: {object_type}")
-            #    dn = denoise.DenoiseModel(model_type=model_type, gpu=device)
-            #    batch = dn.eval(imgs=batch, channels=chans, diameter=object_settings['diameter'])
+            batch_list = [batch[i] for i in range(batch.shape[0])]
 
             if timelapse:
                 movie_path = os.path.join(os.path.dirname(src), 'movies')
                 os.makedirs(movie_path, exist_ok=True)
                 save_path = os.path.join(movie_path, f'timelapse_{object_type}_{name}.mp4')
                 _npz_to_movie(batch, batch_filenames, save_path, fps=2)
-            
-            output = model.eval(x=batch,
-                                batch_size=cellpose_batch_size,
+                        
+            output = model.eval(x=batch_list,
+                                batch_size=batch_size,
                                 normalize=False,
-                                channels=chans,
-                                channel_axis=3,
+                                channel_axis=-1,
+                                channels=channels,
                                 diameter=object_settings['diameter'],
                                 flow_threshold=flow_threshold,
                                 cellprob_threshold=cellprob_threshold,
                                 rescale=None,
                                 resample=object_settings['resample'])
-            
-            if len(output) == 4:
-                masks, flows, _, _ = output
-            elif len(output) == 3:
-                masks, flows, _ = output
-            else:
-                raise ValueError(f"Unexpected number of return values from model.eval(). Expected 3 or 4, got {len(output)}")
+                        
+            masks, flows, _, _, _ = parse_cellpose4_output(output)
 
             if timelapse:
                 if settings['plot']:
-                    for idx, (mask, flow, image) in enumerate(zip(masks, flows[0], batch)):
-                        if idx == 0:
-                            num_objects = mask_object_count(mask)
-                            print(f'Number of objects: {num_objects}')
-                            plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+                    plot_cellpose4_output(batch_list, masks, flows, cmap='inferno', figuresize=figuresize, nr=1, print_object_number=True)
 
                 _save_object_counts_to_database(masks, object_type, batch_filenames, count_loc, added_string='_timelapse')
                 if object_type in timelapse_objects:
@@ -431,24 +418,23 @@ def generate_cellpose_masks(src, settings, object_type):
                     mask_stack = _masks_to_masks_stack(masks)
 
                     if settings['plot']:
-                        for idx, (mask, flow, image) in enumerate(zip(masks, flows[0], batch)):
-                            if idx == 0:
-                                num_objects = mask_object_count(mask)
-                                print(f'Number of objects, : {num_objects}')
-                                plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+                        plot_cellpose4_output(batch_list, masks, flows, cmap='inferno', figuresize=figuresize, nr=1, print_object_number=True)
         
             if not np.any(mask_stack):
-                average_obj_size = 0
+                avg_num_objects_per_image, average_obj_size = 0, 0
             else:
-                average_obj_size = _get_avg_object_size(mask_stack)
-
+                avg_num_objects_per_image, average_obj_size = _get_avg_object_size(mask_stack)
+            
+            average_count.append(avg_num_objects_per_image)
             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')
+            overall_average_count = np.mean(average_count) if len(average_count) > 0 else 0
+            print(f'Found {overall_average_count} {object_type}/FOV. average size: {overall_average_size:.3f} px2')
 
         if not timelapse:
             if settings['plot']:
-                plot_masks(batch, mask_stack, flows, figuresize=figuresize, cmap='inferno', nr=batch_size)
+                plot_cellpose4_output(batch_list, masks, flows, cmap='inferno', figuresize=figuresize, nr=batch_size)
+                
         if settings['save']:
             for mask_index, mask in enumerate(mask_stack):
                 output_filename = os.path.join(output_folder, batch_filenames[mask_index])

{spacr-0.9.4 → spacr-0.9.7}/spacr/gui_core.py

@@ -103,6 +103,11 @@ def display_figure(fig):
     new_canvas = FigureCanvasTkAgg(fig, master=canvas_widget.master)
     new_canvas.draw()
     new_canvas.get_tk_widget().grid(row=0, column=0, sticky="nsew")
+    
+    # Store existing text labels on each axis for zoom visibility control (new feature)
+    for ax in fig.get_axes():
+        texts = ax.texts
+        ax._label_annotations = texts
 
     # Update the global canvas and canvas_widget references
     canvas = new_canvas
@@ -169,14 +174,100 @@ def display_figure(fig):
         else:
             #flash_feedback("right")
             show_next_figure()
+            
+    def zoom(event):
+        # Define zoom factors
+        zoom_in_factor = 1 / 1.2
+        zoom_out_factor = 1.2
+
+        if event.num == 4 or (hasattr(event, 'delta') and event.delta > 0):
+            factor = zoom_in_factor
+        elif event.num == 5 or (hasattr(event, 'delta') and event.delta < 0):
+            factor = zoom_out_factor
+        else:
+            return
+
+        for ax in canvas.figure.get_axes():
+            # Convert canvas pixel (event.x, event.y) to axis data coordinates
+            # EVEN IF the mouse is over a different axis, we use the same pixel to data mapping for each
+            inv = ax.transData.inverted()
+            try:
+                data_x, data_y = inv.transform((event.x, event.y))
+            except ValueError:
+                continue  # e.g. axis has no data
+
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+
+            # Zoom around (data_x, data_y) in *that axis's* data space
+            new_xlim = [data_x - (data_x - xlim[0]) * factor,
+                        data_x + (xlim[1] - data_x) * factor]
+            new_ylim = [data_y - (data_y - ylim[0]) * factor,
+                        data_y + (ylim[1] - data_y) * factor]
+
+            ax.set_xlim(new_xlim)
+            ax.set_ylim(new_ylim)
+
+            # Clip text labels
+            for label in ax.texts:
+                label.set_clip_on(True)
+
+            # Update label visibility
+            if hasattr(ax, '_label_annotations'):
+                for label in ax._label_annotations:
+                    x, y = label.get_position()
+                    is_visible = (new_xlim[0] <= x <= new_xlim[1]) and (new_ylim[0] <= y <= new_ylim[1])
+                    label.set_visible(is_visible)
+
+        canvas.draw_idle()
 
-    def zoom_test(event):
-        if event.num == 4:  # Scroll up
-            print("zoom in")
-        elif event.num == 5: # Scroll down
-            print("zoom out")
+    def zoom_v2(event):
+        # Define zoom factors
+        zoom_in_factor = 1 / 1.2
+        zoom_out_factor = 1.2
+
+        if event.num == 4 or (hasattr(event, 'delta') and event.delta > 0):
+            factor = zoom_in_factor
+        elif event.num == 5 or (hasattr(event, 'delta') and event.delta < 0):
+            factor = zoom_out_factor
+        else:
+            return
+
+        for ax in canvas.figure.get_axes():
+            # Translate mouse position to figure coordinates
+            mouse_x, mouse_y = event.x, event.y
+            inv = ax.transData.inverted()
+            data_x, data_y = inv.transform((mouse_x, mouse_y))
+
+            xlim = ax.get_xlim()
+            ylim = ax.get_ylim()
+
+            # Compute new limits centered on the mouse data position
+            new_width = (xlim[1] - xlim[0]) * factor
+            new_height = (ylim[1] - ylim[0]) * factor
+
+            new_xlim = [data_x - (data_x - xlim[0]) * factor,
+                        data_x + (xlim[1] - data_x) * factor]
+            new_ylim = [data_y - (data_y - ylim[0]) * factor,
+                        data_y + (ylim[1] - data_y) * factor]
+
+            ax.set_xlim(new_xlim)
+            ax.set_ylim(new_ylim)
+
+            # Clip all text labels to the axes area
+            for label in ax.texts:
+                label.set_clip_on(True)
+
+            # Update label visibility based on new limits
+            if hasattr(ax, '_label_annotations'):
+                for label in ax._label_annotations:
+                    x, y = label.get_position()
+                    is_visible = (new_xlim[0] <= x <= new_xlim[1]) and (new_ylim[0] <= y <= new_ylim[1])
+                    label.set_visible(is_visible)
+
+        canvas.draw_idle()
         
-    def zoom(event):
+    def zoom_v1(event):
         # Fixed zoom factors (adjust these if you want faster or slower zoom)
         zoom_in_factor = 0.9   # When zooming in, ranges shrink by 10%
         zoom_out_factor = 1.1  # When zooming out, ranges increase by 10%

{spacr-0.9.4 → spacr-0.9.7}/spacr/io.py

@@ -1699,6 +1699,50 @@ def _check_masks(batch, batch_filenames, output_folder):
     return np.array(filtered_batch), filtered_filenames
 
 def _get_avg_object_size(masks):
+    """
+    Calculate:
+    - average number of objects per image
+    - average object size over all objects
+
+    Parameters:
+    masks (list): A list of 2D or 3D masks with labeled objects.
+
+    Returns:
+    tuple:
+        avg_num_objects_per_image (float)
+        avg_object_size (float)
+    """
+    per_image_counts = []
+    all_areas = []
+
+    for idx, mask in enumerate(masks):
+        if mask.ndim in [2, 3] and np.any(mask):
+            props = measure.regionprops(mask)
+            areas = [prop.area for prop in props]
+            per_image_counts.append(len(areas))
+            all_areas.extend(areas)
+        else:
+            per_image_counts.append(0)
+            if not np.any(mask):
+                print(f"Warning: Mask {idx} is empty.")
+            elif mask.ndim not in [2, 3]:
+                print(f"Warning: Mask {idx} has invalid dimension: {mask.ndim}")
+
+    # Average number of objects per image
+    if per_image_counts:
+        avg_num_objects_per_image = sum(per_image_counts) / len(per_image_counts)
+    else:
+        avg_num_objects_per_image = 0
+
+    # Average object size over all objects
+    if all_areas:
+        avg_object_size = sum(all_areas) / len(all_areas)
+    else:
+        avg_object_size = 0
+
+    return avg_num_objects_per_image, avg_object_size
+
+def _get_avg_object_size_v1(masks):
     """
     Calculate the average size of objects in a list of masks.
 

{spacr-0.9.4 → spacr-0.9.7}/spacr/plot.py

@@ -34,7 +34,6 @@ from collections import defaultdict
 from matplotlib.gridspec import GridSpec
 from matplotlib_venn import venn2
 
-#filter_dict={'cell':[(0,100000), (0, 65000)],'nucleus':[(3000,100000), (1500, 65000)],'pathogen':[(500,100000), (0, 65000)]}
 def plot_image_mask_overlay(
     file,
     channels,
@@ -367,6 +366,54 @@ def plot_image_mask_overlay(
 
     return fig
 
+def plot_cellpose4_output(batch, masks, flows, cmap='inferno', figuresize=10, nr=1, print_object_number=True):
+    """
+    Plot the masks and flows for a given batch of images.
+
+    Args:
+        batch (numpy.ndarray): The batch of images.
+        masks (list or numpy.ndarray): The masks corresponding to the images.
+        flows (list or numpy.ndarray): The flows corresponding to the images.
+        cmap (str, optional): The colormap to use for displaying the images. Defaults to 'inferno'.
+        figuresize (int, optional): The size of the figure. Defaults to 20.
+        nr (int, optional): The maximum number of images to plot. Defaults to 1.
+        file_type (str, optional): The file type of the flows. Defaults to '.npz'.
+        print_object_number (bool, optional): Whether to print the object number on the mask. Defaults to True.
+
+    Returns:
+        None
+    """
+    
+    from .utils import _generate_mask_random_cmap, mask_object_count
+    
+    font = figuresize/2
+    index = 0
+    
+    for image, mask, flow in zip(batch, masks, flows):
+        #if print_object_number:
+        #    num_objects = mask_object_count(mask)
+        #    print(f'Number of objects: {num_objects}')
+        random_cmap = _generate_mask_random_cmap(mask)
+        
+        if index < nr:
+            index += 1
+            chans = image.shape[-1]
+            fig, ax = plt.subplots(1, image.shape[-1] + 2, figsize=(4 * figuresize, figuresize))
+            for v in range(0, image.shape[-1]):
+                ax[v].imshow(image[..., v], cmap=cmap, interpolation='nearest')
+                ax[v].set_title('Image - Channel'+str(v))
+            ax[chans].imshow(mask, cmap=random_cmap, interpolation='nearest')
+            ax[chans].set_title('Mask')
+            if print_object_number:
+                unique_objects = np.unique(mask)[1:]
+                for obj in unique_objects:
+                    cy, cx = ndi.center_of_mass(mask == obj)
+                    ax[chans].text(cx, cy, str(obj), color='white', fontsize=font, ha='center', va='center')
+            ax[chans+1].imshow(flow, cmap='viridis', interpolation='nearest')
+            ax[chans+1].set_title('Flow')
+            plt.show()
+    return
+
 def plot_masks(batch, masks, flows, cmap='inferno', figuresize=10, nr=1, file_type='.npz', print_object_number=True):
     """
     Plot the masks and flows for a given batch of images.

{spacr-0.9.4 → spacr-0.9.7}/spacr/settings.py

@@ -64,9 +64,9 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('nucleus_background', 100)
     settings.setdefault('nucleus_Signal_to_noise', 10)
     settings.setdefault('nucleus_CP_prob', 0)
-    settings.setdefault('nucleus_FT', 100)
-    settings.setdefault('cell_FT', 100)
-    settings.setdefault('pathogen_FT', 100)
+    settings.setdefault('nucleus_FT', 1.0)
+    settings.setdefault('cell_FT', 1.0)
+    settings.setdefault('pathogen_FT', 1.0)
     
     # Plot settings
     settings.setdefault('plot', False)
@@ -97,6 +97,10 @@ def set_default_settings_preprocess_generate_masks(settings={}):
     settings.setdefault('upscale', False)
     settings.setdefault('upscale_factor', 2.0)
     settings.setdefault('adjust_cells', False)
+    settings.setdefault('use_sam_cell', False)
+    settings.setdefault('use_sam_nucleus', False)
+    settings.setdefault('use_sam_pathogen', False)
+    
     return settings
 
 def set_default_plot_data_from_db(settings):
@@ -173,6 +177,8 @@ def _get_object_settings(object_type, settings):
                 object_settings['maximum_size'] = (object_settings['diameter']**2)*10
             else:
                 print(f'Cell diameter must be an integer or float, got {settings["cell_diamiter"]}')
+        if settings['use_sam_cell']:
+            object_settings['model_name'] = 'sam'
 
     elif object_type == 'nucleus':
         object_settings['model_name'] = 'nuclei'
@@ -187,6 +193,8 @@ def _get_object_settings(object_type, settings):
                 object_settings['maximum_size'] = (object_settings['diameter']**2)*10
             else:
                 print(f'Nucleus diameter must be an integer or float, got {settings["nucleus_diamiter"]}')
+        if settings['use_sam_nucleus']:
+            object_settings['model_name'] = 'sam'
 
     elif object_type == 'pathogen':
         object_settings['model_name'] = 'cyto'
@@ -203,10 +211,13 @@ def _get_object_settings(object_type, settings):
                 object_settings['maximum_size'] = (object_settings['diameter']**2)*10
             else:
                 print(f'Pathogen diameter must be an integer or float, got {settings["pathogen_diamiter"]}')
+                
+        if settings['use_sam_pathogen']:
+            object_settings['model_name'] = 'sam'
         
     else:
         print(f'Object type: {object_type} not supported. Supported object types are : cell, nucleus and pathogen')
-
+        
     if settings['verbose']:
         print(object_settings)
         
@@ -712,7 +723,7 @@ expected_types = {
     "nucleus_background": int,
     "nucleus_Signal_to_noise": float,
     "nucleus_CP_prob": float,
-    "nucleus_FT": float,
+    "nucleus_FT": (int, float),
     "cell_channel": (int, type(None)),
     "cell_background": (int, float),
     "cell_Signal_to_noise": (int, float),
@@ -1003,11 +1014,14 @@ expected_types = {
     "nucleus_diamiter":int,
     "pathogen_diamiter":int,
     "consolidate":bool,
+    'use_sam_cell':bool,
+    'use_sam_nucleus':bool,
+    'use_sam_pathogen':bool,
     "distance_gaussian_sigma": (int, type(None))
 }
 
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv", "metadata_files", "score_data","count_data"],
-             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel", "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "delete_intermediate", "uninfected", ],
+             "General": ["cell_mask_dim", "cytoplasm", "cell_chann_dim", "cell_channel", "nucleus_chann_dim", "nucleus_channel", "nucleus_mask_dim", "pathogen_mask_dim", "pathogen_chann_dim", "pathogen_channel",  "test_mode", "plot", "metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "delete_intermediate", "uninfected", ],
              "Cellpose":["denoise","fill_in","from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "invert", "diameter", "grayscale", "Signal_to_noise", "resize", "target_height", "target_width"],
              "Cell": ["cell_diamiter","cell_intensity_range", "cell_size_range", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cytoplasm_min_size", "adjust_cells", "cells", "cell_loc"],
              "Nucleus": ["nucleus_diamiter","nucleus_intensity_range", "nucleus_size_range", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_loc"],
@@ -1025,7 +1039,7 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Plot": ["split_axis_lims", "x_lim","log_x","log_y", "plot_control", "plot_nr", "examples_to_plot", "normalize_plots", "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"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
              "Advanced": ["merge_edge_pathogen_cells", "test_images", "random_test", "test_nr", "test", "test_split", "normalize", "target_unique_count","threshold_multiplier", "threshold_method", "min_n","shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "background", "backgrounds", "schedule", "test_size","exclude","n_repeats","top_features", "model_type_ml", "model_type","minimum_cell_count","n_estimators","preprocess", "remove_background", "normalize", "lower_percentile", "merge_pathogens", "batch_size", "filter", "save", "masks", "verbose", "randomize", "n_jobs"],
-             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate", "distance_gaussian_sigma"]
+             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate", "distance_gaussian_sigma","use_sam_pathogen","use_sam_nucleus", "use_sam_cell"]
              }
 
 
@@ -1415,6 +1429,9 @@ def generate_fields(variables, scrollable_frame):
         "overlay": "(bool) - Overlay activation maps on the images.",
         "shuffle": "(bool) - Shuffle the dataset bufore generating the activation maps",
         "correlation": "(bool) - Calculate correlation between image channels and activation maps. Data is saved to .db.",
+        "use_sam_cell": "(bool) - Whether to use SAM for cell segmentation.",
+        "use_sam_nucleus": "(bool) - Whether to use SAM for nucleus segmentation.",
+        "use_sam_pathogen": "(bool) - Whether to use SAM for pathogen segmentation.",
         "normalize_input": "(bool) - Normalize the input images before passing them to the model.",
         "normalize_plots": "(bool) - Normalize images before plotting.",
     }

{spacr-0.9.4 → spacr-0.9.7}/spacr/spacr_cellpose.py

@@ -7,6 +7,65 @@ from multiprocessing import Pool
 from skimage.transform import resize as resizescikit
 from scipy.ndimage import binary_fill_holes
 
+def parse_cellpose4_output(output):
+    """
+    General parser for Cellpose eval output.
+    Handles:
+    - batched format (list of 4 arrays)
+    - per-image list of flows
+    Returns:
+        masks, flows0, flows1, flows2, flows3
+    """
+
+    masks = output[0]
+    flows = output[1]
+
+    if not isinstance(flows, (list, tuple)):
+        raise ValueError(f"Unrecognized Cellpose flows type: {type(flows)}")
+
+    # Determine number of images
+    try:
+        num_images = len(masks)
+    except TypeError:
+        raise ValueError(f"Cannot determine number of images in masks (type={type(masks)})")
+
+    # Case A: batched format (4 arrays stacked over batch)
+    if len(flows) == 4 and all(isinstance(f, np.ndarray) for f in flows):
+        flow0_array, flow1_array, flow2_array, flow3_array = flows
+
+        flows0 = [flow0_array[i] for i in range(num_images)]
+        flows1 = [flow1_array[:, i] for i in range(num_images)]
+        flows2 = [flow2_array[i] for i in range(num_images)]
+        flows3 = [flow3_array[i] for i in range(num_images)]
+
+        return masks, flows0, flows1, flows2, flows3
+
+    # Case B: per-image format
+    elif len(flows) == num_images:
+        flows0, flows1, flows2, flows3 = [], [], [], []
+
+        for item in flows:
+            if isinstance(item, (list, tuple)):
+                n = len(item)
+                f0 = item[0] if n > 0 else None
+                f1 = item[1] if n > 1 else None
+                f2 = item[2] if n > 2 else None
+                f3 = item[3] if n > 3 else None
+            elif isinstance(item, np.ndarray):
+                f0, f1, f2, f3 = item, None, None, None
+            else:
+                f0 = f1 = f2 = f3 = None
+
+            flows0.append(f0)
+            flows1.append(f1)
+            flows2.append(f2)
+            flows3.append(f3)
+
+        return masks, flows0, flows1, flows2, flows3
+
+    # Unrecognized structure
+    raise ValueError(f"Unrecognized Cellpose flows format: type={type(flows)}, len={len(flows) if hasattr(flows,'__len__') else 'unknown'}")
+
 def identify_masks_finetune(settings):
     
     from .plot import print_mask_and_flows