spacr 0.0.18__py3-none-any.whl → 0.0.20__py3-none-any.whl

spacr/utils.py

@@ -1,6 +1,8 @@
 import os, re, sqlite3, gc, torch, torchvision, time, random, string, shutil, cv2, tarfile, glob
 
 import numpy as np
+from cellpose import models as cp_models
+from cellpose import denoise
 from skimage import morphology
 from skimage.measure import label, regionprops_table, regionprops
 import skimage.measure as measure
@@ -18,6 +20,8 @@ from functools import reduce
 from IPython.display import display, clear_output
 from multiprocessing import Pool, cpu_count
 from skimage.transform import resize as resizescikit
+from skimage.morphology import dilation, square
+from skimage.measure import find_contours
 import torch.nn as nn
 import torch.nn.functional as F
 #from torchsummary import summary
@@ -29,6 +33,7 @@ from skimage.segmentation import clear_border
 import seaborn as sns
 import matplotlib.pyplot as plt
 import scipy.ndimage as ndi
+from scipy.spatial import distance
 from scipy.stats import fisher_exact
 from scipy.ndimage import binary_erosion, binary_dilation
 from skimage.exposure import rescale_intensity
@@ -36,6 +41,7 @@ from sklearn.metrics import auc, precision_recall_curve
 from sklearn.model_selection import train_test_split
 from sklearn.linear_model import Lasso, Ridge
 from sklearn.preprocessing import OneHotEncoder
+from sklearn.cluster import KMeans
 from torchvision.models.resnet import ResNet18_Weights, ResNet34_Weights, ResNet50_Weights, ResNet101_Weights, ResNet152_Weights
 
 from .logger import log_function_call
@@ -45,6 +51,53 @@ from .logger import log_function_call
 #from .plot import _plot_images_on_grid, plot_masks, _plot_histograms_and_stats, plot_resize, _plot_plates, _reg_v_plot, plot_masks
 #from .core import identify_masks
 
+
+def _gen_rgb_image(image, cahnnels):
+    rgb_image = np.take(image, cahnnels, axis=-1)
+    rgb_image = rgb_image.astype(float)
+    rgb_image -= rgb_image.min()
+    rgb_image /= rgb_image.max()
+    return rgb_image
+
+def _outline_and_overlay(image, rgb_image, mask_dims, outline_colors, outline_thickness):
+    from concurrent.futures import ThreadPoolExecutor
+    import cv2
+
+    outlines = []
+    overlayed_image = rgb_image.copy()
+
+    def process_dim(mask_dim):
+        mask = np.take(image, mask_dim, axis=-1)
+        outline = np.zeros_like(mask, dtype=np.uint8)  # Use uint8 for contour detection efficiency
+
+        # Find and draw contours
+        for j in np.unique(mask)[1:]:
+            contours = find_contours(mask == j, 0.5)
+            # Convert contours for OpenCV format and draw directly to optimize
+            cv_contours = [np.flip(contour.astype(int), axis=1) for contour in contours]
+            cv2.drawContours(outline, cv_contours, -1, color=int(j), thickness=outline_thickness)
+
+        return dilation(outline, square(outline_thickness))
+
+    # Parallel processing
+    with ThreadPoolExecutor() as executor:
+        outlines = list(executor.map(process_dim, mask_dims))
+
+    # Overlay outlines onto the RGB image in a batch/vectorized manner if possible
+    for i, outline in enumerate(outlines):
+        # This part may need to be adapted to your specific use case and available functions
+        # The goal is to overlay each outline with its respective color more efficiently
+        color = outline_colors[i % len(outline_colors)]
+        for j in np.unique(outline)[1:]:
+            mask = outline == j
+            overlayed_image[mask] = color  # Direct assignment with broadcasting
+
+    # Remove mask_dims from image
+    channels_to_keep = [i for i in range(image.shape[-1]) if i not in mask_dims]
+    image = np.take(image, channels_to_keep, axis=-1)
+
+    return overlayed_image, outlines, image
+
 def _convert_cq1_well_id(well_id):
     """
     Converts a well ID to the CQ1 well format.
@@ -114,7 +167,7 @@ def _extract_filename_metadata(filenames, src, images_by_key, regular_expression
                 if metadata_type =='cq1':
                     orig_wellID = wellID
                     wellID = _convert_cq1_well_id(wellID)
-                    clear_output(wait=True)
+                    #clear_output(wait=True)
                     print(f'Converted Well ID: {orig_wellID} to {wellID}', end='\r', flush=True)
 
                 if pick_slice:
@@ -673,9 +726,6 @@ def _crop_center(img, cell_mask, new_width, new_height, normalize=(2,98)):
     img = img[start_y:end_y, start_x:end_x, :]
     return img
     
-    
-
-    
 def _masks_to_masks_stack(masks):
     """
     Convert a list of masks into a stack of masks.
@@ -692,53 +742,50 @@ def _masks_to_masks_stack(masks):
     return mask_stack
     
 def _get_diam(mag, obj):
-    if obj == 'cell':
-        if mag == 20:
-            scale = 6
-        if mag == 40:
-            scale = 4.5
-        if mag == 60:
-            scale = 3
-    elif obj == 'nucleus':
-        if mag == 20:
-            scale = 3
-        if mag == 40:
-            scale = 2
-        if mag == 60:
-            scale = 1.5
-    elif obj == 'pathogen':
-        if mag == 20:
-            scale = 1.5
-        if mag == 40:
-            scale = 1
-        if mag == 60:
-            scale = 1.25
-    elif obj == 'pathogen_nucleus':
-        if mag == 20:
-            scale = 0.25
-        if mag == 40:
-            scale = 0.2
-        if mag == 60:
-            scale = 0.2
+
+    if mag == 20:
+        if obj == 'cell':
+            diamiter = 120
+        elif obj == 'nucleus':
+            diamiter = 60
+        elif obj == 'pathogen':
+            diamiter = 30
+        else:
+            raise ValueError("Invalid magnification: Use 20, 40 or 60")
+
+    elif mag == 40:
+        if obj == 'cell':
+            diamiter = 160
+        elif obj == 'nucleus':
+            diamiter = 80
+        elif obj == 'pathogen':
+            diamiter = 40
+        else:
+            raise ValueError("Invalid magnification: Use 20, 40 or 60")
+
+    elif mag == 60:
+        if obj == 'cell':
+            diamiter = 200
+        if obj == 'nucleus':
+            diamiter = 90
+        if obj == 'pathogen':
+            diamiter = 75
+        else:
+            raise ValueError("Invalid magnification: Use 20, 40 or 60")
     else:
-        raise ValueError("Invalid object type")
-    diamiter = mag*scale
+        raise ValueError("Invalid magnification: Use 20, 40 or 60")
+    
     return diamiter
 
 def _get_object_settings(object_type, settings):
-    
     object_settings = {}
-    object_settings['refine_masks'] = False
-    object_settings['filter_size'] = False
-    object_settings['filter_dimm'] = False
-    print(object_type)
+
     object_settings['diameter'] = _get_diam(settings['magnification'], obj=object_type)
-    object_settings['remove_border_objects'] = False
-    object_settings['minimum_size'] = (object_settings['diameter']**2)/10
-    object_settings['maximum_size'] = object_settings['minimum_size']*50
+    object_settings['minimum_size'] = (object_settings['diameter']**2)/5
+    object_settings['maximum_size'] = (object_settings['diameter']**2)*3
     object_settings['merge'] = False
-    object_settings['net_avg'] = True
     object_settings['resample'] = True
+    object_settings['remove_border_objects'] = False
     object_settings['model_name'] = 'cyto'
     
     if object_type == 'cell':
@@ -746,20 +793,27 @@ def _get_object_settings(object_type, settings):
             object_settings['model_name'] = 'cyto'
         else:
             object_settings['model_name'] = 'cyto2'
-        
+        object_settings['filter_size'] = True
+        object_settings['filter_intensity'] = True
+        object_settings['restore_type'] = settings.get('cell_restore_type', None)
+
     elif object_type == 'nucleus':
         object_settings['model_name'] = 'nuclei'
+        object_settings['filter_size'] = True
+        object_settings['filter_intensity'] = True
+        object_settings['restore_type'] = settings.get('nucleus_restore_type', None)
 
     elif object_type == 'pathogen':
-        object_settings['model_name'] = 'cyto3'
-
-    elif object_type == 'pathogen_nucleus':
-        object_settings['filter_size'] = True
         object_settings['model_name'] = 'cyto'
+        object_settings['filter_size'] = True
+        object_settings['filter_intensity'] = True
+        object_settings['restore_type'] = settings.get('pathogen_restore_type', None)
         
     else:
         print(f'Object type: {object_type} not supported. Supported object types are : cell, nucleus and pathogen')
-        print(f'using settings: {object_settings}')
+
+    if settings['verbose']:
+        print(object_settings)
         
     return object_settings
     
@@ -786,6 +840,7 @@ def _pivot_counts_table(db_path):
         return df
 
     def _pivot_dataframe(df):
+
         """
         Pivot the DataFrame.
 
@@ -812,44 +867,17 @@ def _pivot_counts_table(db_path):
     pivoted_df.to_sql('pivoted_counts', conn, if_exists='replace', index=False)
     conn.close()
     
-def _get_cellpose_channels_v1(mask_channels, nucleus_chann_dim, pathogen_chann_dim, cell_chann_dim):
-    cellpose_channels = {}
-    if nucleus_chann_dim in mask_channels:
-        cellpose_channels['nucleus'] = [0, mask_channels.index(nucleus_chann_dim)]
-    if pathogen_chann_dim in mask_channels:
-        cellpose_channels['pathogen'] = [0, mask_channels.index(pathogen_chann_dim)]
-    if cell_chann_dim in mask_channels:
-        cellpose_channels['cell'] = [0, mask_channels.index(cell_chann_dim)]
-    return cellpose_channels
+def _get_cellpose_channels(src, nucleus_channel, pathogen_channel, cell_channel):
 
-def _get_cellpose_channels_v1(cell_channel, nucleus_channel, pathogen_channel):
-    # Initialize a dictionary to hold the new indices for the specified channels
-    cellpose_channels = {}
+    cell_mask_path = os.path.join(src, 'norm_channel_stack', 'cell_mask_stack')
+    nucleus_mask_path = os.path.join(src, 'norm_channel_stack', 'nucleus_mask_stack')
+    pathogen_mask_path = os.path.join(src, 'norm_channel_stack', 'pathogen_mask_stack')
 
-    # Initialize a list to keep track of the channels in their new order
-    new_channel_order = []
-
-    # Add each channel to the new order list if it is not None
-    if cell_channel is not None:
-        new_channel_order.append(('cell', cell_channel))
-    if nucleus_channel is not None:
-        new_channel_order.append(('nucleus', nucleus_channel))
-    if pathogen_channel is not None:
-        new_channel_order.append(('pathogen', pathogen_channel))
-
-    # Sort the list based on the original channel indices to maintain the original order
-    new_channel_order.sort(key=lambda x: x[1])
-    print(new_channel_order)
-    # Assign new indices based on the sorted order
-    for new_index, (channel_name, _) in enumerate(new_channel_order):
-        cellpose_channels[channel_name] = [new_index, 0]
-        
-    if cell_channel is not None and nucleus_channel is not None:
-        cellpose_channels['cell'][1] = cellpose_channels['nucleus'][0]
-        
-    return cellpose_channels
 
-def _get_cellpose_channels(nucleus_channel, pathogen_channel, cell_channel):
+    if os.path.exists(cell_mask_path) or os.path.exists(nucleus_mask_path) or os.path.exists(pathogen_mask_path):
+        if nucleus_channel is None or nucleus_channel is None or nucleus_channel is None:
+            print('Warning: Cellpose masks already exist. Unexpected behaviour when setting any object dimention to None when the object masks have been created.')
+        
     cellpose_channels = {}
     if not nucleus_channel is None:
         cellpose_channels['nucleus'] = [0,0]
@@ -1027,9 +1055,6 @@ def _group_by_well(df):
     # Apply mean function to numeric columns and first to non-numeric
     df_grouped = df.groupby(['plate', 'row', 'col']).agg({**{col: np.mean for col in numeric_cols}, **{col: 'first' for col in non_numeric_cols}})
     return df_grouped
-    
-
-
 
 ###################################################
 #  Classify
@@ -2612,24 +2637,21 @@ def _filter_object(mask, min_value):
     mask[np.isin(mask, to_remove)] = 0
     return mask
 
-def _filter_cp_masks(masks, flows, filter_size, minimum_size, maximum_size, remove_border_objects, merge, filter_dimm, batch, moving_avg_q1, moving_avg_q3, moving_count, plot, figuresize):
+def _filter_cp_masks(masks, flows, filter_size, filter_intensity, minimum_size, maximum_size, remove_border_objects, merge, batch, plot, figuresize):
+    
     """
     Filter the masks based on various criteria such as size, border objects, merging, and intensity.
 
     Args:
         masks (list): List of masks.
         flows (list): List of flows.
-        refine_masks (bool): Flag indicating whether to refine masks.
         filter_size (bool): Flag indicating whether to filter based on size.
+        filter_intensity (bool): Flag indicating whether to filter based on intensity.
         minimum_size (int): Minimum size of objects to keep.
         maximum_size (int): Maximum size of objects to keep.
         remove_border_objects (bool): Flag indicating whether to remove border objects.
         merge (bool): Flag indicating whether to merge adjacent objects.
-        filter_dimm (bool): Flag indicating whether to filter based on intensity.
         batch (ndarray): Batch of images.
-        moving_avg_q1 (float): Moving average of the first quartile of object intensities.
-        moving_avg_q3 (float): Moving average of the third quartile of object intensities.
-        moving_count (int): Count of moving averages.
         plot (bool): Flag indicating whether to plot the masks.
         figuresize (tuple): Size of the figure.
 
@@ -2641,51 +2663,66 @@ def _filter_cp_masks(masks, flows, filter_size, minimum_size, maximum_size, remo
     
     mask_stack = []
     for idx, (mask, flow, image) in enumerate(zip(masks, flows[0], batch)):
+        
         if plot and idx == 0:
             num_objects = mask_object_count(mask)
             print(f'Number of objects before filtration: {num_objects}')
             plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
 
         if filter_size:
-            props = measure.regionprops_table(mask, properties=['label', 'area'])  # Measure properties of labeled image regions.
-            valid_labels = props['label'][np.logical_and(props['area'] > minimum_size, props['area'] < maximum_size)]  # Select labels of valid size.
-            masks[idx] = np.isin(mask, valid_labels) * mask  # Keep only valid objects.
+            props = measure.regionprops_table(mask, properties=['label', 'area'])
+            valid_labels = props['label'][np.logical_and(props['area'] > minimum_size, props['area'] < maximum_size)] 
+            mask = np.isin(mask, valid_labels) * mask
             if plot and idx == 0:
                 num_objects = mask_object_count(mask)
                 print(f'Number of objects after size filtration >{minimum_size} and <{maximum_size} : {num_objects}')
                 plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+
+        if filter_intensity:
+            intensity_image = image[:, :, 1]  
+            props = measure.regionprops_table(mask, intensity_image=intensity_image, properties=['label', 'mean_intensity'])
+            mean_intensities = np.array(props['mean_intensity']).reshape(-1, 1)
+
+            if mean_intensities.shape[0] >= 2:
+                kmeans = KMeans(n_clusters=2, random_state=0).fit(mean_intensities)
+                centroids = kmeans.cluster_centers_
+            
+                # Calculate the Euclidean distance between the two centroids
+                dist_between_centroids = distance.euclidean(centroids[0], centroids[1])
+                
+                # Set a threshold for the minimum distance to consider clusters distinct
+                distance_threshold = 0.25 
+                
+                if dist_between_centroids > distance_threshold:
+                    high_intensity_cluster = np.argmax(centroids)
+                    valid_labels = np.array(props['label'])[kmeans.labels_ == high_intensity_cluster]
+                    mask = np.isin(mask, valid_labels) * mask
+
+            if plot and idx == 0:
+                num_objects = mask_object_count(mask)
+                props_after = measure.regionprops_table(mask, intensity_image=intensity_image, properties=['label', 'mean_intensity'])
+                mean_intensities_after = np.mean(np.array(props_after['mean_intensity']))
+                average_intensity_before = np.mean(mean_intensities)
+                print(f'Number of objects after potential intensity clustering: {num_objects}. Mean intensity before:{average_intensity_before:.4f}. After:{mean_intensities_after:.4f}.')
+                plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+
+
         if remove_border_objects:
             mask = clear_border(mask)
             if plot and idx == 0:
                 num_objects = mask_object_count(mask)
                 print(f'Number of objects after removing border objects, : {num_objects}')
                 plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+        
         if merge:
             mask = merge_touching_objects(mask, threshold=0.25)
             if plot and idx == 0:
                 num_objects = mask_object_count(mask)
                 print(f'Number of objects after merging adjacent objects, : {num_objects}')
                 plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
-        if filter_dimm:
-            unique_labels = np.unique(mask)
-            if len(unique_labels) == 1 and unique_labels[0] == 0:
-                continue
-            object_intensities = [np.mean(batch[idx, :, :, 1][mask == label]) for label in unique_labels if label != 0]
-            object_q1s = [np.percentile(intensities, 25) for intensities in object_intensities if intensities.size > 0]
-            object_q3s = [np.percentile(intensities, 75) for intensities in object_intensities if intensities.size > 0]
-            if object_q1s:
-                object_q1_mean = np.mean(object_q1s)
-                object_q3_mean = np.mean(object_q3s)
-                moving_avg_q1 = (moving_avg_q1 * moving_count + object_q1_mean) / (moving_count + 1)
-                moving_avg_q3 = (moving_avg_q3 * moving_count + object_q3_mean) / (moving_count + 1)
-                moving_count += 1
-            mask = remove_intensity_objects(batch[idx, :, :, 1], mask, intensity_threshold=moving_avg_q1, mode='low')
-            mask = remove_intensity_objects(batch[idx, :, :, 1], mask, intensity_threshold=moving_avg_q3, mode='high')
-            if plot and idx == 0:
-                num_objects = mask_object_count(mask)
-                print(f'Objects after intensity filtration > {moving_avg_q1} and <{moving_avg_q3}: {num_objects}')
-                plot_masks(batch=image, masks=mask, flows=flow, cmap='inferno', figuresize=figuresize, nr=1, file_type='.npz', print_object_number=True)
+        
         mask_stack.append(mask)
+
     return mask_stack
     
 def _object_filter(df, object_type, size_range, intensity_range, mask_chans, mask_chan):
@@ -2721,6 +2758,70 @@ def _object_filter(df, object_type, size_range, intensity_range, mask_chans, mas
                 print(f'After {object_type} maximum mean intensity filter: {len(df)}')
     return df
 
-###################################################
-#  Classify
-###################################################
+def _run_test_mode(src, regex, timelapse=False):
+    if timelapse:
+        test_images = 1  # Use only 1 set for timelapse to ensure full sequence inclusion
+    else:
+        test_images = 10  # Use 10 sets for non-timelapse scenarios
+
+    test_folder_path = os.path.join(src, 'test')
+    os.makedirs(test_folder_path, exist_ok=True)
+    regular_expression = re.compile(regex)
+    
+    all_filenames = [filename for filename in os.listdir(src) if regular_expression.match(filename)]
+    print(f'Found {len(all_filenames)} files')
+    images_by_set = defaultdict(list)
+
+    for filename in all_filenames:
+        match = regular_expression.match(filename)
+        if match:
+            plate = match.group('plateID') if 'plateID' in match.groupdict() else os.path.basename(src)
+            well = match.group('wellID')
+            field = match.group('fieldID')
+            # For timelapse experiments, group images by plate, well, and field only
+            if timelapse:
+                set_identifier = (plate, well, field)
+            else:
+                # For non-timelapse, you might want to distinguish sets more granularly
+                # Here, assuming you're grouping by plate, well, and field for simplicity
+                set_identifier = (plate, well, field)
+            images_by_set[set_identifier].append(filename)
+    
+    # Prepare for random selection
+    set_identifiers = list(images_by_set.keys())
+    random.shuffle(set_identifiers)  # Randomize the order
+    
+    # Select a subset based on the test_images count
+    selected_sets = set_identifiers[:test_images]
+
+    # Print information about the number of sets used
+    print(f'Using {test_images} random image set(s) for test model')
+
+    # Copy files for selected sets to the test folder
+    for set_identifier in selected_sets:
+        for filename in images_by_set[set_identifier]:
+            shutil.copy(os.path.join(src, filename), test_folder_path)
+
+    return test_folder_path
+
+def _choose_model(model_name, device, object_type='cell', restore_type=None):
+    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 == None:
+        model = cp_models.Cellpose(gpu=True, model_type=model_name, device=device)
+    else:
+        if object_type == 'nucleus':
+            restore = f'{type}_nuclei'
+            model = denoise.CellposeDenoiseModel(gpu=True, model_type="nuclei",restore_type=restore, chan2_restore=False, device=device)
+        else:
+            restore = f'{type}_cyto3'
+            if model_name =='cyto2':
+                chan2_restore = True
+            if model_name =='cyto':
+                chan2_restore = False
+            model = denoise.CellposeDenoiseModel(gpu=True, model_type="cyto3",restore_type=restore, chan2_restore=chan2_restore, device=device)
+    
+    return model

{spacr-0.0.18.dist-info → spacr-0.0.20.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.0.18
+Version: 0.0.20
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson
@@ -9,29 +9,29 @@ Classifier: Programming Language :: Python :: 3
 Classifier: License :: OSI Approved :: MIT License
 Classifier: Operating System :: OS Independent
 License-File: LICENSE
-Requires-Dist: torch
-Requires-Dist: torchvision
-Requires-Dist: torch-geometric
-Requires-Dist: numpy
-Requires-Dist: pandas
-Requires-Dist: statsmodels
-Requires-Dist: scikit-image
-Requires-Dist: scikit-learn
-Requires-Dist: seaborn
-Requires-Dist: matplotlib
-Requires-Dist: pillow
-Requires-Dist: imageio
-Requires-Dist: scipy
-Requires-Dist: ipywidgets
-Requires-Dist: mahotas
-Requires-Dist: btrack
-Requires-Dist: trackpy
-Requires-Dist: cellpose
-Requires-Dist: IPython
-Requires-Dist: opencv-python-headless
-Requires-Dist: umap
-Requires-Dist: ttkthemes
-Requires-Dist: lxml
+Requires-Dist: torch >=2.2.1
+Requires-Dist: torchvision >=0.17.1
+Requires-Dist: torch-geometric >=2.5.1
+Requires-Dist: numpy >=1.26.4
+Requires-Dist: pandas >=2.2.1
+Requires-Dist: statsmodels >=0.14.1
+Requires-Dist: scikit-image >=0.22.0
+Requires-Dist: scikit-learn >=1.4.1
+Requires-Dist: seaborn >=0.13.2
+Requires-Dist: matplotlib >=3.8.3
+Requires-Dist: pillow >=10.2.0
+Requires-Dist: imageio >=2.34.0
+Requires-Dist: scipy >=1.12.0
+Requires-Dist: ipywidgets >=8.1.2
+Requires-Dist: mahotas >=1.4.13
+Requires-Dist: btrack >=0.6.5
+Requires-Dist: trackpy >=0.6.2
+Requires-Dist: cellpose >=3.0.6
+Requires-Dist: IPython >=8.18.1
+Requires-Dist: opencv-python-headless >=4.9.0.80
+Requires-Dist: umap >=0.1.1
+Requires-Dist: ttkthemes >=3.2.2
+Requires-Dist: lxml >=5.1.0
 Provides-Extra: dev
 Requires-Dist: pytest >=3.9 ; extra == 'dev'
 Provides-Extra: full
@@ -68,16 +68,18 @@ Spatial phenotype analysis of crisp screens (SpaCr). A collection of functions f
 
 - **Crop Images:** Objects (e.g. cells) can be saved as PNGs from the object area or bounding box area of each object. Object paths are saved in an sql database that can be annotated and used to train CNNs/Transformer models for classefication tasks.
 
-- **Train CNNs or Transformers:** Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images. Train Torch models with IRM/ERM, checkpointing, 
+- **Train CNNs or Transformers:** Train Torch Convolutional Neural Networks (CNNs) or Transformers to classify single object images. Train Torch models with IRM/ERM, checkpointing.
 
 - **Manual Annotation:** Supports manual annotation of single cell images and segmentation to refine training datasets for training CNNs/Transformers or cellpose, respectively.
 
 - **Finetune Cellpose Models:** Adjust pre-existing Cellpose models to your specific dataset for improved performance.
 
-- **Timelapse Data Support:** Includes support for analyzing timelapse data.
+- **Timelapse Data Support:** Track objects in timelapse image data.
 
 - **Simulations:** Simulate spatial phenotype screens.
 
+- **Misc:** Analyze Ca oscillation, recruitment, infection rate, plaque size/count.
+
 ## Installation
 
 spacr requires Tkinter for its graphical user interface features.

spacr-0.0.20.dist-info/RECORD

@@ -0,0 +1,31 @@
+spacr/__init__.py,sha256=mDi-Qu5r1vZnqIbUBV1JAoSq-mxmMEOmni1JSG2e4Wo,879
+spacr/__main__.py,sha256=_qRkhbFrH_cXr7AZs6KHL8Hh4VApqNdpNCtiKn2ePTo,285
+spacr/alpha.py,sha256=Q1vnqO0hvU1G7QP26amFwJY2RjZ68zIc3jYoqQSBMrw,462
+spacr/annotate_app.py,sha256=IPgZfS4TrSqbJr81P1FWUNOgCPPcS6EdQjUsXRwY-4E,19932
+spacr/cli.py,sha256=507jfOOEV8BoL4eeUcblvH-iiDHdBrEVJLu1ghAAPSc,1800
+spacr/core.py,sha256=VTk81S80PKq5pGeUEdduubjbsAyPWKDyRu11EWDO2ms,120307
+spacr/graph_learning.py,sha256=sD4eOC7Q16rr7WO20mCi_E16_LqioGUUgPamAHIIeNI,12568
+spacr/graph_learning_lap.py,sha256=MyNRLb63gsjBlui-ByZ0anHugYulL6M-OsGm8rnGBmE,3385
+spacr/gui_classify_app.py,sha256=-I06tVoA3U0jaAoTs32H1Y5ACMz6QBaEM1NEfg5w-9c,7965
+spacr/gui_mask_app.py,sha256=xpQ_kh-8lTb9xnyKNrZGtf9JnKqutBFu2-LdYzQShh0,8079
+spacr/gui_measure_app.py,sha256=9mAw3Tiuq61uKTzMVslr0MgD8m1Lv5PNI0K4-gQiuXE,8061
+spacr/gui_sim_app.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+spacr/gui_utils.py,sha256=dpbrsDVebjm8ZmkYYOmIZCbkQYyc6JyMIPA7C0r4Xxw,29631
+spacr/io.py,sha256=bCe40kli7jx7hKQyDNuZYCpZ44-Brj4TZVl9r02cFHo,102042
+spacr/logger.py,sha256=7Zqr3TuuOQLWT32gYr2q1qvv7x0a2JhLANmZcnBXAW8,670
+spacr/mask_app.py,sha256=B6-zYXVFg-cc58gLcz-Ry6LClO2jxLitL6B2ACb0HTw,39278
+spacr/measure.py,sha256=LvF6D-TydhXPwKkeAKuIvzHn14qVlqsn6h7ENnoKn5s,50795
+spacr/old_code.py,sha256=KxljHpKNsV5EfX9ifN2xJTnUeqAhyabZyfDWd5THOOc,11226
+spacr/plot.py,sha256=qSM0NzVQYqMYioRc_BPCkUipLRZH7_GaHKGpLXGL8oI,55040
+spacr/sim.py,sha256=tl40lgTMeeJSyBq_c-Rn54C9Ri0FJ2zLkLLLPLSjz3o,51534
+spacr/timelapse.py,sha256=wAEMv7oPyusLph3RPmF4F6UGmLfMZmrupYfsuaeJ9vI,34003
+spacr/train.py,sha256=r77zLvLFMzx6MJxXG3JjynD8qTWYM9pNgrChEXYQhtY,25631
+spacr/umap.py,sha256=4QSrQ16Og-Ijq-SwguMQT2f20UWz1LE5HQeSLmzSl8c,29370
+spacr/utils.py,sha256=kEQxucklUdogxjOSQxKdA1R_NU5qYj6dJPiQKIB8un4,120992
+spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
+spacr-0.0.20.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.0.20.dist-info/METADATA,sha256=S8bOdo2ZqIj-ScjQRBxQnBQNXXFV-HKfidMs7MRIsIc,4381
+spacr-0.0.20.dist-info/WHEEL,sha256=GJ7t_kWBFywbagK5eo9IoUwLW6oyOeTKmQ-9iHFVNxQ,92
+spacr-0.0.20.dist-info/entry_points.txt,sha256=5uyJaAxWCbjWYwP15InAKU1yFxTwyuvCGtIGceso1es,290
+spacr-0.0.20.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.0.20.dist-info/RECORD,,

{spacr-0.0.18.dist-info → spacr-0.0.20.dist-info}/WHEEL

@@ -1,5 +1,5 @@
 Wheel-Version: 1.0
-Generator: bdist_wheel (0.42.0)
+Generator: bdist_wheel (0.43.0)
 Root-Is-Purelib: true
 Tag: py3-none-any