spacr 0.9.4__py3-none-any.whl → 0.9.7__py3-none-any.whl

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/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/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/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/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/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

spacr/utils.py

@@ -42,6 +42,7 @@ from torchvision.utils import make_grid
 import seaborn as sns
 import matplotlib.pyplot as plt
 from matplotlib.offsetbox import OffsetImage, AnnotationBbox
+import matplotlib as mpl
 
 from scipy import stats
 import scipy.ndimage as ndi
@@ -69,6 +70,24 @@ from spacr import __file__ as spacr_path
 import umap.umap_ as umap
 #import umap
 
+def _generate_mask_random_cmap(mask):
+    """
+    Generate a random colormap based on the unique labels in the given mask.
+
+    Parameters:
+    mask (ndarray): The mask array containing unique labels.
+
+    Returns:
+    ListedColormap: A random colormap generated based on the unique labels in the mask.
+    """
+    unique_labels = np.unique(mask)
+    num_objects = len(unique_labels[unique_labels != 0])
+    random_colors = np.random.rand(num_objects+1, 4)
+    random_colors[:, 3] = 1
+    random_colors[0, :] = [0, 0, 0, 1]
+    random_cmap = mpl.colors.ListedColormap(random_colors)
+    return random_cmap
+
 def filepaths_to_database(img_paths, settings, source_folder, crop_mode):
 
     png_df = pd.DataFrame(img_paths, columns=['png_path'])
@@ -1265,6 +1284,34 @@ def _pivot_counts_table(db_path):
     conn.close()
     
 def _get_cellpose_channels(src, nucleus_channel, pathogen_channel, cell_channel):
+    cell_mask_path = os.path.join(src, 'masks', 'cell_mask_stack')
+    nucleus_mask_path = os.path.join(src, 'masks', 'nucleus_mask_stack')
+    pathogen_mask_path = os.path.join(src, 'masks', 'pathogen_mask_stack')
+
+    if any(os.path.exists(p) for p in [cell_mask_path, nucleus_mask_path, pathogen_mask_path]):
+        if any(c is None for c in [nucleus_channel, pathogen_channel, cell_channel]):
+            print('Warning: Cellpose masks already exist. Unexpected behaviour if any channel is None while masks exist.')
+
+    cellpose_channels = {}
+
+    # Nucleus: always duplicated single channel
+    if nucleus_channel is not None:
+        cellpose_channels['nucleus'] = [nucleus_channel, nucleus_channel]
+
+    # Pathogen: always duplicated single channel
+    if pathogen_channel is not None:
+        cellpose_channels['pathogen'] = [pathogen_channel, pathogen_channel]
+
+    # Cell: prefer nucleus as second if available
+    if cell_channel is not None:
+        if nucleus_channel is not None:
+            cellpose_channels['cell'] = [nucleus_channel, cell_channel]
+        else:
+            cellpose_channels['cell'] = [cell_channel, cell_channel]
+
+    return cellpose_channels
+    
+def _get_cellpose_channels_v1(src, nucleus_channel, pathogen_channel, cell_channel):
 
     cell_mask_path = os.path.join(src, 'masks', 'cell_mask_stack')
     nucleus_mask_path = os.path.join(src, 'masks', 'nucleus_mask_stack')
@@ -3150,6 +3197,58 @@ def _run_test_mode(src, regex, timelapse=False, test_images=10, random_test=True
     return test_folder_path
 
 def _choose_model(model_name, device, object_type='cell', restore_type=None, object_settings={}):
+    if object_type == 'pathogen':
+        if model_name == 'toxo_pv_lumen':
+            diameter = object_settings['diameter']
+            current_dir = os.path.dirname(__file__)
+            model_path = os.path.join(current_dir, 'models', 'cp', 'toxo_pv_lumen.CP_model')
+            print(model_path)
+            model = cp_models.CellposeModel(
+                gpu=torch.cuda.is_available(),
+                model_type=None,
+                pretrained_model=model_path,
+                diam_mean=diameter,
+                device=device
+            )
+            print('Using Toxoplasma PV lumen model to generate pathogen masks')
+            return model
+
+    restore_list = ['denoise', 'deblur', 'upsample', None]
+    if restore_type not in restore_list:
+        print(f"Invalid restore type. Choose from {restore_list}, defaulting to None")
+        restore_type = None
+
+    if restore_type is None:
+        if model_name == 'sam':
+            model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), device=device, pretrained_model='cpsam',)
+            return model
+        if model_name in ['cyto', 'cyto2', 'cyto3', 'nuclei']:
+            model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), model_type=model_name, device=device)
+            return model
+    else:
+        if object_type == 'nucleus':
+            restore = f'{restore_type}_nuclei'
+            model = denoise.CellposeDenoiseModel(
+                gpu=torch.cuda.is_available(),
+                model_type="nuclei",
+                restore_type=restore,
+                chan2_restore=False,
+                device=device
+            )
+            return model
+        else:
+            restore = f'{restore_type}_cyto3'
+            chan2_restore = (model_name == 'cyto2')
+            model = denoise.CellposeDenoiseModel(
+                gpu=torch.cuda.is_available(),
+                model_type="cyto3",
+                restore_type=restore,
+                chan2_restore=chan2_restore,
+                device=device
+            )
+            return model
+
+def _choose_model_v1(model_name, device, object_type='cell', restore_type=None, object_settings={}):
     
     if object_type == 'pathogen':
         if model_name == 'toxo_pv_lumen':
@@ -3168,16 +3267,16 @@ def _choose_model(model_name, device, object_type='cell', restore_type=None, obj
 
     if restore_type == None:
         if model_name in ['cyto', 'cyto2', 'cyto3', 'nuclei']:
-            model = cp_models.Cellpose(gpu=torch.cuda.is_available(), model_type=model_name, device=device)
+            model = cp_models.CellposeModel(gpu=torch.cuda.is_available(), model_type=model_name, device=device)
             return model
     else:
         if object_type == 'nucleus':
-            restore = f'{type}_nuclei'
+            restore = f'{restore_type}_nuclei'
             model = denoise.CellposeDenoiseModel(gpu=torch.cuda.is_available(), model_type="nuclei",restore_type=restore, chan2_restore=False, device=device)
             return model
 
         else:
-            restore = f'{type}_cyto3'
+            restore = f'{restore_type}_cyto3'
             if model_name =='cyto2':
                 chan2_restore = True
             if model_name =='cyto':

{spacr-0.9.4.dist-info → spacr-0.9.7.dist-info}/METADATA

@@ -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.dist-info → spacr-0.9.7.dist-info}/RECORD

@@ -8,28 +8,28 @@ spacr/app_measure.py,sha256=_K7APYIeOKpV6e_LcqabBjvEi7mfq9Fch8175x1x0k8,162
 spacr/app_sequencing.py,sha256=DjG26jy4cpddnV8WOOAIiExtOe9MleVMY4MFa5uTo5w,157
 spacr/app_umap.py,sha256=ZWAmf_OsIKbYvolYuWPMYhdlVe-n2CADoJulAizMiEo,153
 spacr/chat_bot.py,sha256=n3Fhqg3qofVXHmh3H9sUcmfYy9MmgRnr48663MVdY9E,1244
-spacr/core.py,sha256=w4E3Pg-ZnA8BOK0iUMTjiNO0GeR5YCEs8fUTbESzqjY,47392
+spacr/core.py,sha256=SDsJsgarbMHDw2i4OOMCKtMtVx9t1tjsGCVs6iHPj7s,46638
 spacr/deep_spacr.py,sha256=055tIo3WP3elGFiIuSZaLURgu2XyUDxAdbw5ezASEqM,54526
 spacr/gui.py,sha256=NhMh96KoArrSAaJBV6PhDQpIC1cQpxgb6SclhRbYG8s,8122
-spacr/gui_core.py,sha256=RtpdB8S8yF9WARRsUjrZ1szZi4ZMfG7R_W34BTBEGYo,52729
+spacr/gui_core.py,sha256=pXTswrqPMTb2mgF_mvnCzBgmXEaf9w7wDnSD6uMA67w,56228
 spacr/gui_elements.py,sha256=OTU7aeLrPiMUTnyCT-J7ygng3beI9tdA0MmypOavEkw,156123
 spacr/gui_utils.py,sha256=F6KfNY3OqNkvfkOP1rxwBha5IOdLVyBgqZYPw3xPLes,42293
-spacr/io.py,sha256=P6k3BYsy8VM0p7ficy2Ae4xTPb6tZM4xq47pY57-GBk,157933
+spacr/io.py,sha256=g6vybQeGLdTXrAqEjM6X1aoB6lyZVUq6pTI0ASppX4g,159257
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
 spacr/measure.py,sha256=nYvrfVfCIqD1AUk4QBE2jtpeSFtLdfUcnkhkqf9G4xQ,60877
 spacr/mediar.py,sha256=p0F515eFbm6_rePSnChsgqrgH-H5Sr_3zWrghtOnAUg,14863
 spacr/ml.py,sha256=XCRZeX7UkbMctQICIoskeWVx8CCmmCoHNauUOAkfFq0,91692
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=Y1ON8Bu-FsZZZasXIK7nvnOohFzucCvFhyPE2bDGz1A,167340
+spacr/plot.py,sha256=76E1CZpsmNeNtbnkXJtgcVOesq4voL7XkaUnD74RDMk,169418
 spacr/sequencing.py,sha256=EY12RdW5QRKpHDRQCw1QoAlxCq8FK2v6WoVa5uuDBXQ,26745
-spacr/settings.py,sha256=YpGfMzNgHGpqamfZ0wVoVG64UOb0rW9lfxCc9W4g7Ss,87683
+spacr/settings.py,sha256=38MClzEv-eP4Kfo_UJ_jlIzj0Vos3TY5-scPlBpolYI,88520
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
 spacr/sp_stats.py,sha256=C93Xe5fphQOKthw4Tmj8pHx-Nb1houIL-YYVIfmnQPg,9535
-spacr/spacr_cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
+spacr/spacr_cellpose.py,sha256=AvnyD2qoj-lUqhICeTpfhyk9T2hCjZrpBXn2iKh1EYE,16785
 spacr/submodules.py,sha256=Z2i4kv_rWdxqoXsOKCF7BaSXtvaCZB69Ow8_FQBnZsY,83093
 spacr/timelapse.py,sha256=-5ZupTsCCpbenIQ2zsUmnwXh45B82fO-gPrSXOxu2s8,42980
 spacr/toxo.py,sha256=GoNfgyH-NJx3WOzNQPgzODir7Jp65fs7UM46XpzcrUo,26056
-spacr/utils.py,sha256=cw5zM6zpFWWUZQKwtYvXc_rNfBMW2ldbnlw8s6f6bFQ,234397
+spacr/utils.py,sha256=PulmDqENBFYKgN2fjcVSB39B_9CwwGDiBi9FOI55zQs,238470
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/data/lopit.csv,sha256=ERI5f9W8RdJGiSx_khoaylD374f8kmvLia1xjhD_mII,4421709
 spacr/resources/data/toxoplasma_metadata.csv,sha256=9TXx0VlClDHAxQmaLhoklE8NuETduXaGHZjhR_6lZfs,2969409
@@ -103,9 +103,9 @@ spacr/resources/icons/umap.png,sha256=dOLF3DeLYy9k0nkUybiZMe1wzHQwLJFRmgccppw-8b
 spacr/resources/images/plate1_E01_T0001F001L01A01Z01C02.tif,sha256=Tl0ZUfZ_AYAbu0up_nO0tPRtF1BxXhWQ3T3pURBCCRo,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A02Z01C01.tif,sha256=m8N-V71rA1TT4dFlENNg8s0Q0YEXXs8slIn7yObmZJQ,7958528
 spacr/resources/images/plate1_E01_T0001F001L01A03Z01C03.tif,sha256=Pbhk7xn-KUP6RSIhJsxQcrHFImBm3GEpLkzx7WOc-5M,7958528
-spacr-0.9.4.dist-info/LICENSE,sha256=t0Pov6pnK8thLteoF4xZGmdCwe5mhNwl3OXxLYTGD9U,1081
-spacr-0.9.4.dist-info/METADATA,sha256=rEwXv8HSYOVMSYZpzjNXFds9XEIlk0y85AsxsZbGbGc,10324
-spacr-0.9.4.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-spacr-0.9.4.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.9.4.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.9.4.dist-info/RECORD,,
+spacr-0.9.7.dist-info/LICENSE,sha256=t0Pov6pnK8thLteoF4xZGmdCwe5mhNwl3OXxLYTGD9U,1081
+spacr-0.9.7.dist-info/METADATA,sha256=qvWrnXZ6_xNlVmfV-z3aCfoL406UiqnI1o4hn55NR64,10356
+spacr-0.9.7.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+spacr-0.9.7.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.9.7.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.9.7.dist-info/RECORD,,