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

spacr/settings.py

@@ -95,14 +95,12 @@ def set_default_settings_preprocess_generate_masks(settings={}):
 
     # Misc settings
     settings.setdefault('all_to_mip', False)
-    settings.setdefault('pick_slice', False)
-    settings.setdefault('skip_mode', '01')
     settings.setdefault('upscale', False)
     settings.setdefault('upscale_factor', 2.0)
     settings.setdefault('adjust_cells', False)
     return settings
 
-def set_default_settings_preprocess_img_data(settings):
+def set_default_settings_preprocess_img_data_v1(settings):
 
     metadata_type = settings.setdefault('metadata_type', 'cellvoyager')
     custom_regex = settings.setdefault('custom_regex', None)
@@ -127,6 +125,27 @@ def set_default_settings_preprocess_img_data(settings):
 
     return settings, metadata_type, custom_regex, nr, plot, batch_size, timelapse, lower_percentile, randomize, all_to_mip, pick_slice, skip_mode, cmap, figuresize, normalize, save_dtype, test_mode, test_images, random_test
 
+def set_default_settings_preprocess_img_data(settings):
+
+    settings.setdefault('metadata_type', 'cellvoyager')
+    settings.setdefault('custom_regex', None)
+    settings.setdefault('nr', 1)
+    settings.setdefault('plot', True)
+    settings.setdefault('batch_size', 50)
+    settings.setdefault('timelapse', False)
+    settings.setdefault('lower_percentile', 2)
+    settings.setdefault('randomize', True)
+    settings.setdefault('all_to_mip', False)
+    settings.setdefault('cmap', 'inferno')
+    settings.setdefault('figuresize', 10)
+    settings.setdefault('normalize', True)
+    settings.setdefault('save_dtype', 'uint16')
+    settings.setdefault('test_mode', False)
+    settings.setdefault('test_images', 10)
+    settings.setdefault('random_test', True)
+    settings.setdefault('fps', 2)
+    return settings
+
 def _get_object_settings(object_type, settings):
 
     from .utils import _get_diam
@@ -278,7 +297,7 @@ def get_measure_crop_settings(settings={}):
 
     # Timelapsed settings
     settings.setdefault('timelapse', False)
-    settings.setdefault('timelapse_objects', 'cell')
+    settings.setdefault('timelapse_objects', ['cell'])
 
     # Operational settings
     settings.setdefault('plot',False)
@@ -715,7 +734,7 @@ expected_types = {
     #"timelapse_frame_limits": (list, type(None)),  # This can be a list of lists
     "timelapse_remove_transient": bool,
     "timelapse_mode": str,
-    "timelapse_objects": list,
+    "timelapse_objects": (list, type(None)),
     "fps": int,
     "remove_background": bool,
     "lower_percentile": (int, float),
@@ -1005,7 +1024,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", "pick_slice", "skip_mode", "upscale", "upscale_factor", "consolidate"]
+             "Beta": ["all_to_mip", "upscale", "upscale_factor", "consolidate"]
              }
 
 
@@ -1033,7 +1052,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", "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"]:
                 if value is None:
                     parsed_value = None
                 else:
@@ -1274,7 +1293,6 @@ def generate_fields(variables, scrollable_frame):
         "pc": "(str) - Positive control identifier.",
         "pc_loc": "(str) - Location of the positive control in the images.",
         "percentiles": "(list) - Percentiles to use for normalizing the images.",
-        "pick_slice": "(bool) - Whether to pick a single slice from the z-stack images. If False, the maximum intensity projection will be used.",
         "pin_memory": "(bool) - Whether to pin memory for the data loader.",
         "plate": "(str) - Plate identifier for the experiment.",
         "plate_dict": "(dict) - Dictionary of plate metadata.",

spacr/submodules.py

@@ -28,10 +28,7 @@ from skimage.measure import regionprops, label as sklabel
 import matplotlib.pyplot as plt
 from natsort import natsorted
 
-import torch
 from torch.utils.data import Dataset
-from spacr.settings import get_train_cellpose_default_settings
-from spacr.utils import save_settings, invert_image
 
 class CellposeLazyDataset(Dataset):
     def __init__(self, image_files, label_files, settings, randomize=True, augment=False):
@@ -91,8 +88,8 @@ class CellposeLazyDataset(Dataset):
 
 def train_cellpose(settings):
     
-    from spacr.settings import get_train_cellpose_default_settings
-    from spacr.utils import save_settings
+    from .settings import get_train_cellpose_default_settings
+    from .utils import save_settings
     
     settings = get_train_cellpose_default_settings(settings)
     img_src = os.path.join(settings['src'], 'train', 'images')
@@ -161,11 +158,11 @@ def train_cellpose(settings):
     
 def test_cellpose_model(settings):
     
-    from spacr.utils import save_settings, print_progress
+    from .utils import save_settings, print_progress
     from .settings import get_default_test_cellpose_model_settings
     
     def plot_cellpose_resilts(i, j, results_dir, img, lbl, pred, flow):
-        from spacr. plot import generate_mask_random_cmap
+        from . plot import generate_mask_random_cmap
         fig, axs = plt.subplots(1, 5, figsize=(16, 4), gridspec_kw={'wspace': 0.1, 'hspace': 0.1})
         cmap_lbl = generate_mask_random_cmap(lbl)
         cmap_pred = generate_mask_random_cmap(pred)
@@ -348,7 +345,7 @@ def test_cellpose_model(settings):
 def apply_cellpose_model(settings):
     
     from .settings import get_default_apply_cellpose_model_settings
-    from spacr.utils import save_settings, print_progress
+    from .utils import save_settings, print_progress
     
     def plot_cellpose_result(i, j, results_dir, img, pred, flow):
         
@@ -466,7 +463,7 @@ def apply_cellpose_model(settings):
         print("Saved object count and average area to summary.csv")
 
 def plot_cellpose_batch(images, labels):
-    from spacr.plot import generate_mask_random_cmap
+    from .plot import generate_mask_random_cmap
 
     cmap_lbl = generate_mask_random_cmap(labels)
     batch_size = len(images)
@@ -481,8 +478,8 @@ def plot_cellpose_batch(images, labels):
     plt.show()
 
 def analyze_percent_positive(settings):
-    from spacr.io import _read_and_merge_data
-    from spacr.utils import save_settings
+    from .io import _read_and_merge_data
+    from .utils import save_settings
     from .settings import default_settings_analyze_percent_positive
     
     settings = default_settings_analyze_percent_positive(settings)
@@ -681,7 +678,7 @@ def analyze_recruitment(settings):
 
 def analyze_plaques(settings):
 
-    from .cellpose import identify_masks_finetune
+    from .spacr_cellpose import identify_masks_finetune
     from .settings import get_analyze_plaque_settings
     from .utils import save_settings, download_models
     from spacr import __file__ as spacr_path
@@ -1020,7 +1017,7 @@ def interperate_vision_model(settings={}):
             else:
                 return None
 
-        from spacr.plot import spacrGraph
+        from .plot import spacrGraph
 
         df[name] = df['feature'].apply(lambda x: find_feature_class(x, feature_groups))
 

spacr/timelapse.py

@@ -7,9 +7,9 @@ from IPython.display import display
 from IPython.display import Image as ipyimage
 import trackpy as tp
 from btrack import datasets as btrack_datasets
-from skimage.measure import regionprops
+from skimage.measure import regionprops, regionprops_table
 from scipy.signal import find_peaks
-from scipy.optimize import curve_fit
+from scipy.optimize import curve_fit, linear_sum_assignment
 from scipy.integrate import trapz
 import matplotlib.pyplot as plt
 
@@ -255,7 +255,7 @@ def _relabel_masks_based_on_tracks(masks, tracks, mode='btrack'):
 
     return relabeled_masks
 
-def _prepare_for_tracking(mask_array):
+def _prepare_for_tracking_v1(mask_array):
     """
     Prepare the mask array for object tracking.
 
@@ -286,6 +286,87 @@ def _prepare_for_tracking(mask_array):
             })
     return pd.DataFrame(frames)
 
+def _prepare_for_tracking(mask_array):
+    frames = []
+    for t, frame in enumerate(mask_array):
+        props = regionprops_table(
+            frame,
+            properties=('label', 'centroid-0', 'centroid-1', 'area',
+                        'bbox-0', 'bbox-1', 'bbox-2', 'bbox-3',
+                        'eccentricity')
+        )
+        df = pd.DataFrame(props)
+        df = df.rename(columns={
+            'centroid-0': 'y', 'centroid-1': 'x', 'area': 'mass',
+            'label': 'original_label'
+        })
+        df['frame'] = t
+        frames.append(df[['frame','y','x','mass','original_label',
+                          'bbox-0','bbox-1','bbox-2','bbox-3','eccentricity']])
+    return pd.concat(frames, ignore_index=True)
+
+
+def _track_by_iou(masks, iou_threshold=0.1):
+    """
+    Build a track table by linking masks frame→frame via IoU.
+    Returns a DataFrame with columns [frame, original_label, track_id].
+    """
+    n_frames = masks.shape[0]
+    # 1) initialize: every label in frame 0 starts its own track
+    labels0 = np.unique(masks[0])[1:]
+    next_track = 1
+    track_map = {}  # (frame,label) -> track_id
+    for L in labels0:
+        track_map[(0, L)] = next_track
+        next_track += 1
+
+    # 2) iterate through frames
+    for t in range(1, n_frames):
+        prev, curr = masks[t-1], masks[t]
+        matches = link_by_iou(prev, curr, iou_threshold=iou_threshold)
+        used_curr = set()
+        # a) assign matched labels to existing tracks
+        for L_prev, L_curr in matches:
+            tid = track_map[(t-1, L_prev)]
+            track_map[(t, L_curr)] = tid
+            used_curr.add(L_curr)
+        # b) any label in curr not matched → new track
+        for L in np.unique(curr)[1:]:
+            if L not in used_curr:
+                track_map[(t, L)] = next_track
+                next_track += 1
+
+    # 3) flatten into DataFrame
+    records = []
+    for (frame, label), tid in track_map.items():
+        records.append({'frame': frame, 'original_label': label, 'track_id': tid})
+    return pd.DataFrame(records)
+
+def link_by_iou(mask_prev, mask_next, iou_threshold=0.1):
+    # Get labels
+    labels_prev = np.unique(mask_prev)[1:]
+    labels_next = np.unique(mask_next)[1:]
+    # Precompute masks as boolean
+    bool_prev = {L: mask_prev==L for L in labels_prev}
+    bool_next = {L: mask_next==L for L in labels_next}
+    # Cost matrix = 1 - IoU
+    cost = np.ones((len(labels_prev), len(labels_next)), dtype=float)
+    for i, L1 in enumerate(labels_prev):
+        m1 = bool_prev[L1]
+        for j, L2 in enumerate(labels_next):
+            m2 = bool_next[L2]
+            inter = np.logical_and(m1, m2).sum()
+            union = np.logical_or(m1, m2).sum()
+            if union > 0:
+                cost[i, j] = 1 - inter/union
+    # Solve assignment
+    row_ind, col_ind = linear_sum_assignment(cost)
+    matches = []
+    for i, j in zip(row_ind, col_ind):
+        if cost[i,j] <= 1 - iou_threshold:
+            matches.append((labels_prev[i], labels_next[j]))
+    return matches
+
 def _find_optimal_search_range(features, initial_search_range=500, increment=10, max_attempts=49, memory=3):
     """
     Find the optimal search range for linking features.
@@ -336,7 +417,94 @@ def _remove_objects_from_first_frame(masks, percentage=10):
             masks[0][first_frame == label] = 0
         return masks
 
-def _facilitate_trackin_with_adaptive_removal(masks, search_range=500, max_attempts=100, memory=3):
+def _track_by_iou(masks, iou_threshold=0.1):
+    """
+    Build a track table by linking masks frame→frame via IoU.
+    Returns a DataFrame with columns [frame, original_label, track_id].
+    """
+    n_frames = masks.shape[0]
+    # 1) initialize: every label in frame 0 starts its own track
+    labels0 = np.unique(masks[0])[1:]
+    next_track = 1
+    track_map = {}  # (frame,label) -> track_id
+    for L in labels0:
+        track_map[(0, L)] = next_track
+        next_track += 1
+
+    # 2) iterate through frames
+    for t in range(1, n_frames):
+        prev, curr = masks[t-1], masks[t]
+        matches = link_by_iou(prev, curr, iou_threshold=iou_threshold)
+        used_curr = set()
+        # a) assign matched labels to existing tracks
+        for L_prev, L_curr in matches:
+            tid = track_map[(t-1, L_prev)]
+            track_map[(t, L_curr)] = tid
+            used_curr.add(L_curr)
+        # b) any label in curr not matched → new track
+        for L in np.unique(curr)[1:]:
+            if L not in used_curr:
+                track_map[(t, L)] = next_track
+                next_track += 1
+
+    # 3) flatten into DataFrame
+    records = []
+    for (frame, label), tid in track_map.items():
+        records.append({'frame': frame, 'original_label': label, 'track_id': tid})
+    return pd.DataFrame(records)
+
+
+def _facilitate_trackin_with_adaptive_removal(masks, search_range=None, max_attempts=5, memory=3, min_mass=50, track_by_iou=False):
+    """
+    Facilitates object tracking with deterministic initial filtering and
+    trackpy’s constant-velocity prediction.
+
+    Args:
+        masks (np.ndarray): integer‐labeled masks (frames × H × W).
+        search_range (int|None): max displacement; if None, auto‐computed.
+        max_attempts (int): how many times to retry with smaller search_range.
+        memory (int): trackpy memory parameter.
+        min_mass (float): drop any object in frame 0 with area < min_mass.
+
+    Returns:
+        masks, features_df, tracks_df
+
+    Raises:
+        RuntimeError if linking fails after max_attempts.
+    """
+    # 1) initial features & filter frame 0 by area
+    features = _prepare_for_tracking(masks)
+    f0 = features[features['frame'] == 0]
+    valid = f0.loc[f0['mass'] >= min_mass, 'original_label'].unique()
+    masks[0] = np.where(np.isin(masks[0], valid), masks[0], 0)
+
+    # 2) recompute features on filtered masks
+    features = _prepare_for_tracking(masks)
+
+    # 3) default search_range = 2×sqrt(99th‑pct area)
+    if search_range is None:
+        a99 = f0['mass'].quantile(0.99)
+        search_range = max(1, int(2 * np.sqrt(a99)))
+
+    # 4) attempt linking, shrinking search_range on failure
+    for attempt in range(1, max_attempts + 1):
+        try:
+            if track_by_iou:
+                tracks_df = _track_by_iou(masks, iou_threshold=0.1)
+            else:
+                tracks_df = tp.link_df(features,search_range=search_range, memory=memory, predict=True)
+                print(f"Linked on attempt {attempt} with search_range={search_range}")
+            return masks, features, tracks_df
+
+        except Exception as e:
+            search_range = max(1, int(search_range * 0.8))
+            print(f"Attempt {attempt} failed ({e}); reducing search_range to {search_range}")
+
+    raise RuntimeError(
+        f"Failed to track after {max_attempts} attempts; last search_range={search_range}"
+    )
+
+def _facilitate_trackin_with_adaptive_removal_v1(masks, search_range=500, max_attempts=100, memory=3):
     """
     Facilitates object tracking with adaptive removal.
 

spacr/utils.py

@@ -1,5 +1,4 @@
 import os, re, sqlite3, torch, torchvision, random, string, shutil, cv2, tarfile, glob, psutil, platform, gzip, subprocess, time, requests, ast, traceback
-
 import numpy as np
 import pandas as pd
 from cellpose import models as cp_models
@@ -554,7 +553,7 @@ def _get_cellpose_batch_size():
     except Exception as e:
         return 8
 
-def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager', pick_slice=False, skip_mode='01'):
+def _extract_filename_metadata(filenames, src, regular_expression, metadata_type='cellvoyager'):
     
     images_by_key = defaultdict(list)
 
@@ -568,33 +567,38 @@ def _extract_filename_metadata(filenames, src, regular_expression, metadata_type
                     plate = os.path.basename(src)
 
                 well = match.group('wellID')
-                field = match.group('fieldID')
-                channel = match.group('chanID')
-                mode = None
-
                 if well[0].isdigit():
                     well = str(_safe_int_convert(well))
+                
+                field = match.group('fieldID')
                 if field[0].isdigit():
                     field = str(_safe_int_convert(field))
+                    
+                channel = match.group('chanID')
                 if channel[0].isdigit():
                     channel = str(_safe_int_convert(channel))
-
+                    
+                if 'timeID' in match.groupdict():
+                    timeID = match.group('timeID')
+                    if timeID[0].isdigit():
+                        timeID = str(_safe_int_convert(timeID))
+                else:
+                    timeID = None
+                        
+                if 'sliceID' in match.groupdict():
+                    sliceID = match.group('sliceID')
+                    if sliceID[0].isdigit():
+                        sliceID = str(_safe_int_convert(sliceID))
+                else:
+                    sliceID = None
+                    
                 if metadata_type =='cq1':
                     orig_wellID = wellID
                     wellID = _convert_cq1_well_id(wellID)
                     print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
 
-                if pick_slice:
-                    try:
-                        mode = match.group('AID')
-                    except IndexError:
-                        sliceid = '00'
-
-                    if mode == skip_mode:
-                        continue
-                        
-                key = (plate, well, field, channel, mode)
-                file_path = os.path.join(src, filename)  # Store the full path
+                key = (plate, well, field, channel, timeID, sliceID)
+                file_path = os.path.join(src, filename)
                 images_by_key[key].append(file_path)
                 
             except IndexError:
@@ -3279,15 +3283,6 @@ class SaliencyMapGenerator:
         return fig
     
     def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
-        """
-        Normalize each channel of the image to the given percentiles.
-        Args:
-            img: Input image as numpy array with shape (H, W, C)
-            lower_percentile: Lower percentile for normalization (default 2)
-            upper_percentile: Upper percentile for normalization (default 98)
-        Returns:
-            img: Normalized image
-        """
         img_normalized = np.zeros_like(img)
 
         for c in range(img.shape[2]):  # Iterate over each channel
@@ -3297,7 +3292,6 @@ class SaliencyMapGenerator:
 
         return img_normalized
 
-
 class GradCAMGenerator:
     def __init__(self, model, target_layer, cam_type='gradcam'):
         self.model = model
@@ -3402,15 +3396,6 @@ class GradCAMGenerator:
         return fig
     
     def percentile_normalize(self, img, lower_percentile=2, upper_percentile=98):
-        """
-        Normalize each channel of the image to the given percentiles.
-        Args:
-            img: Input image as numpy array with shape (H, W, C)
-            lower_percentile: Lower percentile for normalization (default 2)
-            upper_percentile: Upper percentile for normalization (default 98)
-        Returns:
-            img: Normalized image
-        """
         img_normalized = np.zeros_like(img)
 
         for c in range(img.shape[2]):  # Iterate over each channel
@@ -4698,10 +4683,10 @@ def get_ml_results_paths(src, model_type='xgboost', channel_of_interest=1):
     elif isinstance(channel_of_interest, int):
         feature_string = f"channel_{channel_of_interest}"
 
-    elif channel_of_interest is 'morphology':
+    elif channel_of_interest == 'morphology':
         feature_string = 'morphology'
 
-    elif channel_of_interest is None:
+    elif channel_of_interest == None:
         feature_string = 'all_features'
     else:
         raise ValueError(f"Unsupported channel_of_interest: {channel_of_interest}. Supported values are 'int', 'list', 'None', or 'morphology'.")
@@ -5115,9 +5100,9 @@ def correct_metadata_column_names(df):
 
 def control_filelist(folder, mode='columnID', values=['01','02']):
     files = os.listdir(folder)
-    if mode is 'columnID':
+    if mode == 'columnID':
         filtered_files = [file for file in files if file.split('_')[1][1:] in values]
-    if mode is 'rowID':
+    if mode == 'rowID':
         filtered_files = [file for file in files if file.split('_')[1][:1] in values]
     return filtered_files
     

{spacr-0.4.60.dist-info → spacr-0.5.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.4.60
+Version: 0.5.0
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -41,6 +41,8 @@ Requires-Dist: pillow<11.0,>=10.2.0
 Requires-Dist: tifffile>=2023.4.12
 Requires-Dist: nd2reader<4.0,>=3.3.0
 Requires-Dist: czifile
+Requires-Dist: pylibCZIrw<6.0,>=5.0.0
+Requires-Dist: aicspylibczi
 Requires-Dist: readlif
 Requires-Dist: imageio<3.0,>=2.34.0
 Requires-Dist: pingouin<1.0,>=0.5.5
@@ -79,7 +81,7 @@ Provides-Extra: headless
 Requires-Dist: opencv-python-headless; extra == "headless"
 
 .. |Documentation Status| image:: https://readthedocs.org/projects/spacr/badge/?version=latest
-   :target: https://spacr.readthedocs.io/en/latest/?badge=latest
+   :target: https://einarolafsson.github.io/spacr
 .. |PyPI version| image:: https://badge.fury.io/py/spacr.svg
    :target: https://badge.fury.io/py/spacr
 .. |Python version| image:: https://img.shields.io/pypi/pyversions/spacr