spacr 0.9.25__py3-none-any.whl → 1.0.0__py3-none-any.whl

spacr/app_annotate.py

@@ -30,6 +30,10 @@ def initiate_annotation_app(parent_frame):
         settings['percentiles'] = list(map(convert_to_number, settings['percentiles'].split(','))) if settings['percentiles'] else [2, 98]
         settings['normalize'] = settings['normalize'].lower() == 'true'
         settings['normalize_channels'] = settings['normalize_channels'].split(',')
+        settings['outline'] = settings['outline'].split(',') if settings['outline'] else None
+        settings['outline_threshold_factor'] = float(settings['outline_threshold_factor']) if settings['outline_threshold_factor'] else 1.0
+        settings['outline_sigma'] = float(settings['outline_threshold_factor']) if settings['outline_threshold_factor'] else 1.0
+        
         try:
             settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
             settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])

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/gui_elements.py

@@ -10,18 +10,23 @@ import numpy as np
 import pandas as pd
 from PIL import Image, ImageOps, ImageTk, ImageDraw, ImageFont, ImageEnhance
 from concurrent.futures import ThreadPoolExecutor
-from skimage.exposure import rescale_intensity
 from IPython.display import display, HTML
 import imageio.v2 as imageio
 from collections import deque
+from skimage.filters import threshold_otsu
+from skimage.exposure import rescale_intensity
 from skimage.draw import polygon, line
 from skimage.transform import resize
-from scipy.ndimage import binary_fill_holes, label
+from skimage.morphology import dilation, disk
+from skimage.segmentation import find_boundaries
+from skimage.util import img_as_ubyte
+from scipy.ndimage import binary_fill_holes, label, gaussian_filter
 from tkinter import ttk, scrolledtext
 from sklearn.model_selection import train_test_split
 from xgboost import XGBClassifier
 from sklearn.metrics import classification_report, confusion_matrix
 
+
 fig = None
 
 def restart_gui_app(root):
@@ -2209,7 +2214,7 @@ class ModifyMaskApp:
         self.update_display()
 
 class AnnotateApp:
-    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None, normalize_channels=None):
+    def __init__(self, root, db_path, src, image_type=None, channels=None, image_size=200, annotation_column='annotate', normalize=False, percentiles=(1, 99), measurement=None, threshold=None, normalize_channels=None, outline=None, outline_threshold_factor=1, outline_sigma=1):
         self.root = root
         self.db_path = db_path
         self.src = src
@@ -2237,7 +2242,10 @@ class AnnotateApp:
         self.measurement = measurement
         self.threshold = threshold
         self.normalize_channels = normalize_channels
-        print('self.normalize_channels',self.normalize_channels)
+        self.outline = outline #([s.strip().lower() for s in outline.split(',') if s.strip()]if isinstance(outline, str) and outline else None)
+        self.outline_threshold_factor = outline_threshold_factor
+        self.outline_sigma = outline_sigma
+        
         style_out = set_dark_style(ttk.Style())
         self.font_loader = style_out['font_loader']
         self.font_size = style_out['font_size']
@@ -2337,7 +2345,12 @@ class AnnotateApp:
             'percentiles': ','.join(map(str, self.percentiles)),
             'measurement': ','.join(self.measurement) if self.measurement else '',
             'threshold': str(self.threshold) if self.threshold is not None else '',
-            'normalize_channels': ','.join(self.normalize_channels) if self.normalize_channels else ''
+            'normalize_channels': ','.join(self.normalize_channels) if self.normalize_channels else '',
+            'outline': ','.join(self.outline) if self.outline else '',
+            'outline_threshold_factor': str(self.outline_threshold_factor) if hasattr(self, 'outline_threshold_factor') else '1.0',
+            'outline_sigma': str(self.outline_sigma) if hasattr(self, 'outline_sigma') else '1.0',
+            'src': self.src,
+            'db_path': self.db_path,
         }
 
         for key, data in vars_dict.items():
@@ -2354,7 +2367,10 @@ class AnnotateApp:
             settings['percentiles'] = list(map(convert_to_number, settings['percentiles'].split(','))) if settings['percentiles'] else [1, 99]
             settings['normalize'] = settings['normalize'].lower() == 'true'
             settings['normalize_channels'] = settings['normalize_channels'].split(',') if settings['normalize_channels'] else None
-
+            settings['outline'] = settings['outline'].split(',') if settings['outline'] else None
+            settings['outline_threshold_factor'] = float(settings['outline_threshold_factor'].replace(',', '.')) if settings['outline_threshold_factor'] else 1.0
+            settings['outline_sigma'] = float(settings['outline_sigma'].replace(',', '.')) if settings['outline_sigma'] else 1.0
+            
             try:
                 settings['measurement'] = settings['measurement'].split(',') if settings['measurement'] else None
                 settings['threshold'] = None if settings['threshold'].lower() == 'none' else int(settings['threshold'])
@@ -2379,7 +2395,12 @@ class AnnotateApp:
                 'percentiles': settings.get('percentiles'),
                 'measurement': settings.get('measurement'),
                 'threshold': settings.get('threshold'),
-                'normalize_channels': settings.get('normalize_channels')
+                'normalize_channels': settings.get('normalize_channels'),
+                'outline': settings.get('outline'),
+                'outline_threshold_factor': settings.get('outline_threshold_factor'),
+                'outline_sigma': settings.get('outline_sigma'),
+                'src': self.src,
+                'db_path': self.db_path
             })
 
             settings_window.destroy()
@@ -2389,22 +2410,32 @@ class AnnotateApp:
         
     def update_settings(self, **kwargs):
         allowed_attributes = {
-            'image_type', 'channels', 'image_size', 'annotation_column',
-            'normalize', 'percentiles', 'measurement', 'threshold', 'normalize_channels'
+            'image_type', 'channels', 'image_size', 'annotation_column', 'src', 'db_path',
+            'normalize', 'percentiles', 'measurement', 'threshold', 'normalize_channels', 'outline', 'outline_threshold_factor', 'outline_sigma'
         }
 
         updated = False
-
+                
         for attr, value in kwargs.items():
             if attr in allowed_attributes and value is not None:
+                if attr == 'outline':
+                    if isinstance(value, str):
+                        value = [s.strip().lower() for s in value.split(',') if s.strip()]
+                elif attr == 'outline_threshold_factor':
+                    value = float(value)
+                elif attr == 'outline_sigma':
+                    value = float(value)
                 setattr(self, attr, value)
                 updated = True
 
+
         if 'image_size' in kwargs:
             if isinstance(self.image_size, list):
                 self.image_size = (int(self.image_size[0]), int(self.image_size[0]))
             elif isinstance(self.image_size, int):
                 self.image_size = (self.image_size, self.image_size)
+            elif isinstance(self.image_size, tuple) and len(self.image_size) == 2:
+                self.image_size = tuple(map(int, self.image_size))
             else:
                 raise ValueError("Invalid image size")
 
@@ -2599,9 +2630,47 @@ class AnnotateApp:
         img = self.normalize_image(img, self.normalize, self.percentiles, self.normalize_channels)
         img = img.convert('RGB')
         img = self.filter_channels(img)
+        
+        if self.outline:
+            img = self.outline_image(img, self.outline_sigma)
+        
         img = img.resize(self.image_size)
         return img, annotation
     
+    def outline_image(self, img, edge_sigma=1, edge_thickness=1):
+        """
+        For each selected channel, compute a continuous outline from the intensity landscape
+        using Otsu threshold scaled by a correction factor. Replace only that channel.
+        """
+        arr = np.asarray(img)
+        if arr.ndim != 3 or arr.shape[2] != 3:
+            return img  # not RGB
+
+        out_img = arr.copy()
+        channel_map = {'r': 0, 'g': 1, 'b': 2}
+        factor = getattr(self, 'outline_threshold_factor', 1.0)
+
+        for ch in self.outline:
+            if ch not in channel_map:
+                continue
+            idx = channel_map[ch]
+            channel_data = arr[:, :, idx]
+
+            try:
+                channel_data = gaussian_filter(channel_data, sigma=edge_sigma) 
+                otsu_thresh = threshold_otsu(channel_data)
+                corrected_thresh = min(255, otsu_thresh * factor)
+                fg_mask = channel_data > corrected_thresh
+            except Exception:
+                continue
+            
+            edge = find_boundaries(fg_mask, mode='inner')
+            thick_edge = dilation(edge, disk(edge_thickness))
+
+            out_img[:, :, idx] = (thick_edge * 255).astype(np.uint8)
+
+        return Image.fromarray(out_img)
+
     @staticmethod
     def normalize_image(img, normalize=False, percentiles=(1, 99), normalize_channels=None):
         """

spacr/gui_utils.py

@@ -252,7 +252,7 @@ def annotate(settings):
     app.load_images()
     root.mainloop()
 
-def generate_annotate_fields(frame):
+def generate_annotate_fields_v1(frame):
     from .settings import set_annotate_default_settings
     from .gui_elements import set_dark_style
 
@@ -281,6 +281,48 @@ def generate_annotate_fields(frame):
     
     return vars_dict
 
+def generate_annotate_fields(frame):
+    from .settings import set_annotate_default_settings
+    from .gui_elements import set_dark_style
+
+    style_out = set_dark_style(ttk.Style())
+    font_loader = style_out['font_loader']
+    font_size = style_out['font_size'] - 2
+
+    vars_dict = {}
+    settings = set_annotate_default_settings(settings={})
+    
+    for setting in settings:
+        vars_dict[setting] = {
+            'entry': ttk.Entry(frame),
+            'value': settings[setting]
+        }
+
+    # Arrange input fields and labels
+    for row, (name, data) in enumerate(vars_dict.items()):
+        tk.Label(
+            frame,
+            text=f"{name.replace('_', ' ').capitalize()}:",
+            bg=style_out['bg_color'],
+            fg=style_out['fg_color'],
+            font=font_loader.get_font(size=font_size)
+        ).grid(row=row, column=0)
+
+        value = data['value']
+        if isinstance(value, list):
+            string_value = ','.join(map(str, value))
+        elif isinstance(value, (int, float, bool)):
+            string_value = str(value)
+        elif value is None:
+            string_value = ''
+        else:
+            string_value = value
+
+        data['entry'].insert(0, string_value)
+        data['entry'].grid(row=row, column=1)
+
+    return vars_dict
+
 def run_annotate_app(vars_dict, parent_frame):
     settings = {key: data['entry'].get() for key, data in vars_dict.items()}
     settings['channels'] = settings['channels'].split(',')
@@ -349,7 +391,7 @@ def annotate_with_image_refs(settings, root, shutdown_callback):
     screen_height = root.winfo_screenheight()
     root.geometry(f"{screen_width}x{screen_height}")
 
-    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'], normalize_channels=settings['normalize_channels'])
+    app = AnnotateApp(root, db, src, image_type=settings['image_type'], channels=settings['channels'], image_size=settings['img_size'], annotation_column=settings['annotation_column'], normalize=settings['normalize'], percentiles=settings['percentiles'], measurement=settings['measurement'], threshold=settings['threshold'], normalize_channels=settings['normalize_channels'], outline=settings['outline'], outline_threshold_factor=settings['outline_threshold_factor'], outline_sigma=settings['outline_sigma'])
 
     # Set the canvas background to black
     root.configure(bg='black')

spacr/io.py

@@ -1587,7 +1587,7 @@ def preprocess_img_data(settings):
         print(f"Found {extension_counts[most_common_extension]} {most_common_extension} files")
     
     else:
-        print(f"Could not find any {valid_ext} files in {src} only found {extension_counts[0]}")
+        print(f"Could not find any {valid_ext} files in {src}")
         print(f"{files} in {src}")
         print(f"Please check the folder and try again")
         
@@ -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/measure.py

@@ -331,7 +331,7 @@ def _extended_regionprops_table(labels, image, intensity_props):
     df['frac_low10'] = frac_low10
     df['entropy_intensity'] = entropy_intensity
 
-    percentiles = [5, 10, 25, 50, 75, 85, 95]
+    percentiles = [5, 10, 25, 75, 85, 95]
     for p in percentiles:
         df[f'percentile_{p}'] = [
             np.percentile(region.intensity_image[region.image], p)
@@ -339,78 +339,6 @@ def _extended_regionprops_table(labels, image, intensity_props):
         ]
     return df
 
-def _extended_regionprops_table_v2(labels, image, intensity_props):
-    """
-    Calculate extended region properties table, adding integrated intensity,
-    skewness, kurtosis, std, and median intensity per region.
-    """
-    # regionprops_table gives you vectorized props, but not everything you want
-    props = regionprops_table(labels, image, properties=intensity_props)
-    df = pd.DataFrame(props)
-
-    # Compute extra features region-by-region
-    regions = regionprops(labels, intensity_image=image)
-    integrated_intensity = []
-    std_intensity = []
-    median_intensity = []
-    skew_intensity = []
-    kurtosis_intensity = []
-    for region in regions:
-        intens = region.intensity_image[region.image]
-        # Handle empty region edge-case (shouldn't happen)
-        if intens.size == 0:
-            integrated_intensity.append(np.nan)
-            std_intensity.append(np.nan)
-            median_intensity.append(np.nan)
-            skew_intensity.append(np.nan)
-            kurtosis_intensity.append(np.nan)
-        else:
-            integrated_intensity.append(np.sum(intens))
-            std_intensity.append(np.std(intens))
-            median_intensity.append(np.median(intens))
-            # Only valid for >2 pixels
-            skew_intensity.append(skew(intens) if intens.size > 2 else np.nan)
-            kurtosis_intensity.append(kurtosis(intens) if intens.size > 3 else np.nan)
-
-    df['integrated_intensity'] = integrated_intensity
-    df['std_intensity'] = std_intensity
-    df['median_intensity'] = median_intensity
-    df['skew_intensity'] = skew_intensity
-    df['kurtosis_intensity'] = kurtosis_intensity
-
-    # You can add other features here if desired
-
-    # Percentiles (your existing code—optional if you want to keep)
-    percentiles = [5, 10, 25, 50, 75, 85, 95]
-    for p in percentiles:
-        df[f'percentile_{p}'] = [
-            np.percentile(region.intensity_image[region.image], p)
-            for region in regions
-        ]
-    return df
-
-def _extended_regionprops_table_v1(labels, image, intensity_props):
-    """
-    Calculate extended region properties table.
-
-    Args:
-        labels (ndarray): Labeled image.
-        image (ndarray): Input image.
-        intensity_props (list): List of intensity properties to calculate.
-
-    Returns:
-        DataFrame: Extended region properties table.
-
-    """
-    regions = regionprops(labels, image)
-    props = regionprops_table(labels, image, properties=intensity_props)
-    percentiles = [5, 10, 25, 50, 75, 85, 95]
-    for p in percentiles:
-        props[f'percentile_{p}'] = [
-            np.percentile(region.intensity_image.flatten()[~np.isnan(region.intensity_image.flatten())], p)
-            for region in regions]
-    return pd.DataFrame(props)
-
 def _calculate_homogeneity(label, channel, distances=[2,4,8,16,32,64]):
         """
         Calculate the homogeneity values for each region in the label mask.
@@ -767,8 +695,11 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
             df.append(mask_intensity_df)
             
     if isinstance(settings['distance_gaussian_sigma'], int):
-        intensity_distance_df = _measure_intensity_distance(cell_mask, nucleus_mask, pathogen_mask, channel_arrays, settings)
-        cell_dfs.append(intensity_distance_df)
+        if settings['distance_gaussian_sigma'] != 0:
+            if settings['cell_mask_dim'] != None:
+                if settings['nucleus_mask_dim'] != None or settings['pathogen_mask_dim'] != None:
+                    intensity_distance_df = _measure_intensity_distance(cell_mask, nucleus_mask, pathogen_mask, channel_arrays, settings)
+                    cell_dfs.append(intensity_distance_df)
     
     if radial_dist:
         if np.max(nucleus_mask) != 0:

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.
@@ -1154,7 +1201,7 @@ def _plot_cropped_arrays(stack, filename, figuresize=10, cmap='inferno', thresho
         for channel in range(num_channels):
             plot_single_array(stack[:, :, channel], axs[channel], f'C. {channel}', plt.get_cmap(cmap))
         fig.tight_layout()    
-    print(f'{filename}')
+    #print(f'{filename}')
     return fig
     
 def _visualize_and_save_timelapse_stack_with_tracks(masks, tracks_df, save, src, name, plot, filenames, object_type, mode='btrack', interactive=False):

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)
         
@@ -314,7 +325,7 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('cytoplasm_min_size',0)
     settings.setdefault('merge_edge_pathogen_cells', True)
     
-    settings.setdefault('distance_gaussian_sigma', 1)
+    settings.setdefault('distance_gaussian_sigma', 10)
     
     if settings['test_mode']:
         settings['verbose'] = True
@@ -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,
-    "distance_gaussian_sigma":int
+    '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"]
              }
 
 
@@ -1053,7 +1067,7 @@ def check_settings(vars_dict, expected_types, q=None):
         expected_type = expected_types.get(key, str)
 
         try:
-            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "timelapse_objects", "class_metadata", "crop_mode"]:
+            if key in ["cell_plate_metadata", "timelapse_frame_limits", "png_size", "png_dims", "pathogen_plate_metadata", "treatment_plate_metadata", "timelapse_objects", "class_metadata", "crop_mode", "dialate_png_ratios"]:
                 if value is None:
                     parsed_value = None
                 else:
@@ -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.",
     }
@@ -1467,6 +1484,9 @@ def set_annotate_default_settings(settings):
     settings.setdefault('annotation_column', 'test')
     settings.setdefault('normalize', 'False')
     settings.setdefault('normalize_channels', "r,g,b")
+    settings.setdefault('outline', None)
+    settings.setdefault('outline_threshold_factor', 1)
+    settings.setdefault('outline_sigma', 1)
     settings.setdefault('percentiles', [2, 98])
     settings.setdefault('measurement', '') #'cytoplasm_channel_3_mean_intensity,pathogen_channel_3_mean_intensity')
     settings.setdefault('threshold', '') #'2')

spacr/sp_stats.py

@@ -7,7 +7,6 @@ from scipy.stats import chi2_contingency, fisher_exact
 import itertools
 from statsmodels.stats.multitest import multipletests
 
-
 def choose_p_adjust_method(num_groups, num_data_points):
     """
     Selects the most appropriate p-value adjustment method based on data characteristics.

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.25.dist-info → spacr-1.0.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.9.25
+Version: 1.0.0
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -13,7 +13,8 @@ License-File: LICENSE
 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 <4.0,>=3.0.6
+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
@@ -167,7 +168,10 @@ Data Availability
 
 - **Raw sequencing data** are available from NCBI BioProject `PRJNA1261935 <https://www.ncbi.nlm.nih.gov/bioproject/PRJNA1261935>`_ and SRA accessions: `SRR33531217 <https://www.ncbi.nlm.nih.gov/sra/SRR33531217>`_, `SRR33531218 <https://www.ncbi.nlm.nih.gov/sra/SRR33531218>`_, `SRR33531219 <https://www.ncbi.nlm.nih.gov/sra/SRR33531219>`_, `SRR33531220 <https://www.ncbi.nlm.nih.gov/sra/SRR33531220>`_
 
-- **Image data** is deposited at EBI BioStudies under accession: `S-BIAD2076 <https://www.ebi.ac.uk/biostudies/bioimages/studies/S-BIAD2076>`_
+- **Image data** is deposited at EBI BioStudies under accession: 
+  `S-BIAD2076 <https://www.ebi.ac.uk/biostudies/studies/S-BIAD2076>`_  
+  *(If the link redirects to the main BioStudies portal, copy and paste it directly into your browser.)*
+
 
 Example Notebooks
 -----------------
@@ -192,6 +196,13 @@ The following example Jupyter notebooks illustrate common workflows using spaCR.
 - `Finetune cellpose models <https://github.com/EinarOlafsson/spacr/blob/main/Notebooks/5_spacr_train_cellpose.ipynb>`_  
   *Finetune Cellpose models using your own annotated training data for improved segmentation accuracy.*
 
+Interactive Tutorial (under construction)
+-----------------------------------------
+
+Click below to explore the step-by-step GUI and Notebook tutorials for spaCR:
+
+`spaCR Tutorial Page <https://einarolafsson.github.io/spacr/tutorial/>`_
+
 License
 -------
 spaCR is distributed under the terms of the MIT License.

{spacr-0.9.25.dist-info → spacr-1.0.0.dist-info}/RECORD

@@ -1,6 +1,6 @@
 spacr/__init__.py,sha256=EoGInYks0M4foZElYNhksrQK6aEO1au7cncWexWNhRw,1376
 spacr/__main__.py,sha256=H4MjaMF9ohZL6xfl1kTxVn1Nt_vEhhZArENMMBv8f4E,77
-spacr/app_annotate.py,sha256=W9eLPa_LZIvXsXx_-0iDFEU938LBDvRy6prXo0qF4KQ,2533
+spacr/app_annotate.py,sha256=p0OyvgFycIug7RcLfejFmc4HWB7yQskCBxxy3Sdq_Y0,2905
 spacr/app_classify.py,sha256=urTP_wlZ58hSyM5a19slYlBxN0PdC-9-ga0hvq8CGWc,165
 spacr/app_make_masks.py,sha256=pqDhRpluiHZz-kPX2Zh_KbYe4TsU43qYBa_7f-rsjpw,1694
 spacr/app_mask.py,sha256=l-dBY8ftzCMdDe6-pXc2Nh_u-idNL9G7UOARiLJBtds,153
@@ -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_elements.py,sha256=5a3BOpctBPklsT1NungqS72h1Bg1FArUndE0OfvWD8Y,152646
-spacr/gui_utils.py,sha256=vv_uBOA0n-04KCCicYHhNt3sRbm0IPLM5r8QX5EkJ1Q,40867
-spacr/io.py,sha256=SYLhupKnOJJscNSGE4N67E32-ywhwrjRccIfZrL38Uk,157966
+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=g6vybQeGLdTXrAqEjM6X1aoB6lyZVUq6pTI0ASppX4g,159257
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
-spacr/measure.py,sha256=XmOCKriS-kuRy-EPhQ_z7CRNg6DukyTpwQCiuSPNd_c,63414
+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=M2w9ytR8iMFtsVPhmQ5tzIWTQDmbtCzs1-7hALUIQtg,167339
+spacr/plot.py,sha256=76E1CZpsmNeNtbnkXJtgcVOesq4voL7XkaUnD74RDMk,169418
 spacr/sequencing.py,sha256=EY12RdW5QRKpHDRQCw1QoAlxCq8FK2v6WoVa5uuDBXQ,26745
-spacr/settings.py,sha256=tEFKYqMYQoObrNuKL3XdinRebQxJcuA3Gn9wK44vqhs,87505
+spacr/settings.py,sha256=38MClzEv-eP4Kfo_UJ_jlIzj0Vos3TY5-scPlBpolYI,88520
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
-spacr/sp_stats.py,sha256=mbhwsyIqt5upsSD346qGjdCw7CFBa0tIS7zHU9e0jNI,9536
-spacr/spacr_cellpose.py,sha256=RBHMs2vwXcfkj0xqAULpALyzJYXddSRycgZSzmwI7v0,14755
+spacr/sp_stats.py,sha256=C93Xe5fphQOKthw4Tmj8pHx-Nb1houIL-YYVIfmnQPg,9535
+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.25.dist-info/LICENSE,sha256=t0Pov6pnK8thLteoF4xZGmdCwe5mhNwl3OXxLYTGD9U,1081
-spacr-0.9.25.dist-info/METADATA,sha256=x5pSFgTi8NS3rL8YvAERr4XRNhVJb1nAeK-lvxXBBHQ,9988
-spacr-0.9.25.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
-spacr-0.9.25.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.9.25.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.9.25.dist-info/RECORD,,
+spacr-1.0.0.dist-info/LICENSE,sha256=t0Pov6pnK8thLteoF4xZGmdCwe5mhNwl3OXxLYTGD9U,1081
+spacr-1.0.0.dist-info/METADATA,sha256=FAPU_0wMd3rz1-fbRo0TS568-_O7_NIWgx1jXPM4fuE,10356
+spacr-1.0.0.dist-info/WHEEL,sha256=R0nc6qTxuoLk7ShA2_Y-UWkN8ZdfDBG2B6Eqpz2WXbs,91
+spacr-1.0.0.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-1.0.0.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-1.0.0.dist-info/RECORD,,