spacr 0.3.41__py3-none-any.whl → 0.3.43__py3-none-any.whl

spacr/cellpose.py

@@ -86,7 +86,6 @@ def identify_masks_finetune(settings):
         if normalize:
             images, _, image_names, _, orig_dims = _load_normalized_images_and_labels(image_files=image_files, label_files=None, channels=channels, percentiles=percentiles,  circular=circular, invert=invert, visualize=verbose, remove_background=remove_background, background=background, Signal_to_noise=Signal_to_noise, target_height=target_height, target_width=target_width)
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
-            #orig_dims = [(image.shape[0], image.shape[1]) for image in images]
         else:
             images, _, image_names, _ = _load_images_and_labels(image_files=image_files, label_files=None, circular=circular, invert=invert) 
             images = [np.squeeze(img) if img.shape[-1] == 1 else img for img in images]
@@ -126,7 +125,6 @@ def identify_masks_finetune(settings):
             print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls)
             print_progress(files_processed, files_to_process, n_jobs=1, time_ls=time_ls, batch_size=None, operation_type="")
             
-            
             if verbose:
                 if resize:
                     stack = resizescikit(stack, dims, preserve_range=True, anti_aliasing=False).astype(stack.dtype)

spacr/gui_core.py

@@ -384,8 +384,8 @@ def import_settings(settings_type='mask'):
     from .gui_utils import convert_settings_dict_for_gui, hide_all_settings
     from .settings import generate_fields, set_default_settings_preprocess_generate_masks, get_measure_crop_settings, set_default_train_test_model
     from .settings import set_default_generate_barecode_mapping, set_default_umap_image_settings, get_analyze_recruitment_default_settings
-    from .settings import get_default_generate_activation_map_settings
-    #activation
+    from .settings import get_default_generate_activation_map_settings, get_analyze_plaque_settings
+
     def read_settings_from_csv(csv_file_path):
         settings = {}
         with open(csv_file_path, newline='') as csvfile:
@@ -428,7 +428,7 @@ def import_settings(settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {}
     else:
@@ -443,7 +443,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     global vars_dict, scrollable_frame
     from .settings import get_identify_masks_finetune_default_settings, set_default_analyze_screen, set_default_settings_preprocess_generate_masks
     from .settings import get_measure_crop_settings, deep_spacr_defaults, set_default_generate_barecode_mapping, set_default_umap_image_settings
-    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings
+    from .settings import get_map_barcodes_default_settings, get_analyze_recruitment_default_settings, get_check_cellpose_models_default_settings, get_analyze_plaque_settings
     from .settings import generate_fields, get_perform_regression_default_settings, get_train_cellpose_default_settings, get_default_generate_activation_map_settings
     from .gui_utils import convert_settings_dict_for_gui
     from .gui_elements import set_element_size
@@ -490,7 +490,7 @@ def setup_settings_panel(vertical_container, settings_type='mask'):
     elif settings_type == 'activation':
         settings = get_default_generate_activation_map_settings(settings={})
     elif settings_type == 'analyze_plaques':
-        settings = {'src':'path to images'}
+        settings = get_analyze_plaque_settings(settings={})
     elif settings_type == 'convert':
         settings = {'src':'path to images'}
     else:

spacr/gui_utils.py

@@ -380,7 +380,7 @@ def convert_settings_dict_for_gui(settings):
     variables = {}
     special_cases = {
         'metadata_type': ('combo', ['cellvoyager', 'cq1', 'nikon', 'zeis', 'custom'], 'cellvoyager'),
-        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
+        'channels': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]', '[0,0]'], '[0,1,2,3]'),
         'train_channels': ('combo', ["['r','g','b']", "['r','g']", "['r','b']", "['g','b']", "['r']", "['g']", "['b']"], "['r','g','b']"),
         'channel_dims': ('combo', ['[0,1,2,3]', '[0,1,2]', '[0,1]', '[0]'], '[0,1,2,3]'),
         'dataset_mode': ('combo', ['annotation', 'metadata', 'recruitment'], 'metadata'),

spacr/io.py

@@ -191,107 +191,130 @@ def _load_images_and_labels(image_files, label_files, circular=False, invert=Fal
         print(f'image shape: {images[0].shape}, image type: images[0].shape mask shape: {labels[0].shape}, image type: labels[0].shape')
     return images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10):
+def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  
+                                       circular=False, invert=False, visualize=False, 
+                                       remove_background=False, background=0, Signal_to_noise=10, 
+                                       target_height=None, target_width=None):
     
-    from .plot import normalize_and_visualize
+    from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
+    from skimage.transform import resize as resizescikit
+
+    # Ensure percentiles are valid
+    if isinstance(percentiles, list) and len(percentiles) == 2:
+        try:
+            percentiles = [int(percentiles[0]), int(percentiles[1])]
+        except ValueError:
+            percentiles = None
+    else:
+        percentiles = None
 
-    signal_thresholds = background*Signal_to_noise
+    signal_thresholds = float(background) * float(Signal_to_noise)
     lower_percentile = 2
 
-    images = []
-    labels = []
-    
+    images, labels, orig_dims = [], [], []
     num_channels = 4
     percentiles_1 = [[] for _ in range(num_channels)]
     percentiles_99 = [[] for _ in range(num_channels)]
 
     image_names = [os.path.basename(f) for f in image_files]
-    
+    image_dir = os.path.dirname(image_files[0])
+
     if label_files is not None:
         label_names = [os.path.basename(f) for f in label_files]
         label_dir = os.path.dirname(label_files[0])
+    else:
+        label_names, label_dir = [], None
 
-    # Load images and check percentiles
-    for i,img_file in enumerate(image_files):
+    # Load, normalize, and resize images
+    for i, img_file in enumerate(image_files):
         image = cellpose.io.imread(img_file)
+        orig_dims.append((image.shape[0], image.shape[1]))
+
         if invert:
             image = invert_image(image)
         if circular:
             image = apply_mask(image, output_value=0)
 
-        # If specific channels are specified, select them
+        # Select specific channels if needed
         if channels is not None and image.ndim == 3:
             image = image[..., channels]
 
         if remove_background:
-            image[image < background] = 0
-        
+            image = np.where(image < background, 0, image)
+
         if image.ndim < 3:
             image = np.expand_dims(image, axis=-1)
-        
-        images.append(image)
+
+        # Calculate percentiles if not provided
         if percentiles is None:
             for c in range(image.shape[-1]):
                 p1 = np.percentile(image[..., c], lower_percentile)
                 percentiles_1[c].append(p1)
+
+                # Ensure `signal_thresholds` and `p` are floats for comparison
                 for percentile in [98, 99, 99.9, 99.99, 99.999]:
                     p = np.percentile(image[..., c], percentile)
-                    if p > signal_thresholds:
+                    if float(p) > signal_thresholds:
                         percentiles_99[c].append(p)
                         break
-                    
-    if not percentiles is None:
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                low_p = np.percentile(image[..., c], percentiles[0])
-                high_p = np.percentile(image[..., c], percentiles[1])
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(low_p, high_p), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
+
+        # Resize image if required
+        if target_height and target_width:
+            image_shape = (target_height, target_width) if image.ndim == 2 else (target_height, target_width, image.shape[-1])
+            image = resizescikit(image, image_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
+
+        images.append(image)
+
+    # Calculate average percentiles if needed
     if percentiles is None:
-        # Calculate average percentiles for normalization
         avg_p1 = [np.mean(p) for p in percentiles_1]
-        avg_p99 = [np.mean(p) if len(p) > 0 else np.mean(percentiles_1[i]) for i, p in enumerate(percentiles_99)]
+        avg_p99 = [np.mean(p) if p else avg_p1[i] for i, p in enumerate(percentiles_99)]
 
         print(f'Average 1st percentiles: {avg_p1}, Average 99th percentiles: {avg_p99}')
 
-        normalized_images = []
-        for image in images:
-            normalized_image = np.zeros_like(image, dtype=np.float32)
-            for c in range(image.shape[-1]):
-                normalized_image[..., c] = rescale_intensity(image[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
-            normalized_images.append(normalized_image)
-            if visualize:
-                normalize_and_visualize(image, normalized_image, title=f"Channel {c+1} Normalized")
-            
-    if not image_files is None:
-        image_dir = os.path.dirname(image_files[0])
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], in_range=(avg_p1[c], avg_p99[c]), out_range=(0, 1))
+                      for c in range(img.shape[-1])], axis=-1) for img in images
+        ]
 
     else:
-        image_dir = None
-            
+        normalized_images = [
+            np.stack([rescale_intensity(img[..., c], 
+                                        in_range=(np.percentile(img[..., c], percentiles[0]),
+                                                  np.percentile(img[..., c], percentiles[1])), 
+                                        out_range=(0, 1)) for c in range(img.shape[-1])], axis=-1) 
+            for img in images
+        ]
+
+    # Load and resize labels if provided
     if label_files is not None:
-        for lbl_file in label_files:
-            labels.append(cellpose.io.imread(lbl_file))
-    else:
-        label_names = []
-        label_dir = None
+        labels = [resizescikit(cellpose.io.imread(lbl_file), 
+                               (target_height, target_width) if target_height and target_width else orig_dims[i], 
+                               order=0, preserve_range=True, anti_aliasing=False).astype(np.uint8)
+                  for i, lbl_file in enumerate(label_files)]
 
     print(f'Loaded and normalized {len(normalized_images)} images and {len(labels)} labels from {image_dir} and {label_dir}')
-    
-    return normalized_images, labels, image_names, label_names
 
-def _load_normalized_images_and_labels(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
+    if visualize and images and labels:
+        plot_resize(images, normalized_images, labels, labels)
+
+    return normalized_images, labels, image_names, label_names, orig_dims
+
+def _load_normalized_images_and_labels_v1(image_files, label_files, channels=None, percentiles=None,  circular=False, invert=False, visualize=False, remove_background=False, background=0, Signal_to_noise=10, target_height=None, target_width=None):
     
     from .plot import normalize_and_visualize, plot_resize
     from .utils import invert_image, apply_mask
     from skimage.transform import resize as resizescikit
 
+    if isinstance(percentiles, list):
+        if len(percentiles) !=2:
+            percentiles = None
+        if not percentiles[0] is int:
+            percentiles = None
+        if not percentiles[1] is int:
+            percentiles = None
+    
     signal_thresholds = background * Signal_to_noise
     lower_percentile = 2
 

spacr/measure.py

@@ -710,7 +710,7 @@ def _measure_crop_core(index, time_ls, file, settings):
         else:
             cell_mask = np.zeros_like(data[:, :, 0])
             settings['cytoplasm'] = False
-            settings['include_uninfected'] = True
+            settings['uninfected'] = True
 
         if settings['nucleus_mask_dim'] is not None:
             nucleus_mask = data[:, :, settings['nucleus_mask_dim']].astype(data_type)
@@ -762,7 +762,7 @@ def _measure_crop_core(index, time_ls, file, settings):
             cytoplasm_mask = _filter_object(cytoplasm_mask, settings['cytoplasm_min_size'])
 
         if settings['cell_mask_dim'] is not None:
-            cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=settings['include_uninfected'])
+            cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, uninfected=settings['uninfected'])
 
         # Update data with the new masks
         if settings['cell_mask_dim'] is not None:
@@ -979,9 +979,9 @@ def measure_crop(settings):
                 #_create_database(source_folder+'/measurements/measurements.db')
             
             if settings['cell_mask_dim'] is None:
-                settings['include_uninfected'] = True
+                settings['uninfected'] = True
             if settings['pathogen_mask_dim'] is None:
-                settings['include_uninfected'] = True
+                settings['uninfected'] = True
             if settings['cell_mask_dim'] is not None and settings['pathogen_min_size'] is not None:
                 settings['cytoplasm'] = True
             elif settings['cell_mask_dim'] is not None and settings['nucleus_min_size'] is not None:

spacr/ml.py

@@ -449,26 +449,28 @@ def perform_regression(settings):
             return df, n_gene
         else:
             return df
+        
+
     
     settings = get_perform_regression_default_settings(settings)
     count_data_df, score_data_df = _perform_regression_read_data(settings)
     results_path, results_path_gene, results_path_grna, hits_path, res_folder, csv_path = _perform_regression_set_paths(settings)
     save_settings(settings, name='regression', show=True)
+
+    if isinstance(settings['filter_value'], list):
+        filter_value = settings['filter_value']
+    else:
+        filter_value = []
+    if isinstance(settings['filter_column'], str):
+        filter_column = settings['filter_column']
     
-    score_data_df = clean_controls(score_data_df, settings['pc'], settings['nc'], settings['other'])
+    score_data_df = clean_controls(score_data_df, settings['filter_value'], settings['filter_column'])
     print(f"Dependent variable after clean_controls: {len(score_data_df)}")
 
     dependent_df, dependent_variable = process_scores(score_data_df, settings['dependent_variable'], settings['plate'], settings['min_cell_count'], settings['agg_type'], settings['transform'])
     print(f"Dependent variable after process_scores: {len(dependent_df)}")
 
-    filter_value = [settings['nc'], settings['pc']]
-
-    if settings['other'] is not None:
-        if isinstance(settings['other'], str):
-            settings['other'] = [settings['other']]
-        filter_value.extend(settings['other'])
-
-    independent_df = process_reads(count_data_df, settings['fraction_threshold'], settings['plate'], filter_column=settings['location_column'], filter_value=filter_value)
+    independent_df = process_reads(count_data_df, settings['fraction_threshold'], settings['plate'], filter_column=filter_column, filter_value=filter_value)
     independent_df, n_grna, n_gene = _count_variable_instances(independent_df, column_1='grna', column_2='gene')
 
     print(f"Independent variable after process_reads: {len(independent_df)}")
@@ -498,12 +500,14 @@ def perform_regression(settings):
     if settings['controls'] is not None:
         control_coef_df = grna_coef_df[grna_coef_df['grna'].isin(settings['controls'])]
         mean_coef = control_coef_df['coefficient'].mean()
-        variance_coef = control_coef_df['coefficient'].var()
-        std_coef = control_coef_df['coefficient'].std()
-        reg_threshold = mean_coef + (3 * std_coef)
-    
-    print('coef_df')
-    display(coef_df)
+        
+        if settings['threshold_method'] in ['var','variance']:
+            coef_mes = control_coef_df['coefficient'].var()
+        elif settings['threshold_method'] in ['std', 'standard_deveation']:
+            coef_mes = control_coef_df['coefficient'].std()
+        else:
+            raise ValueError(f"Unsupported threshold method {settings['threshold_method']}. Supported methods: ['var','variance','std','standard_deveation']")
+        reg_threshold = mean_coef + (settings['threshold_multiplier'] * coef_mes)
     
     coef_df.to_csv(results_path, index=False)
     gene_coef_df.to_csv(results_path_gene, index=False)
@@ -596,7 +600,7 @@ def process_reads(csv_path, fraction_threshold, plate, filter_column=None, filte
     if isinstance(filter_value, str):
         filter_value = [filter_value]
 
-    if isinstance(filter_column, list):
+    if isinstance(filter_column, list):            
         for filter_col in filter_column:
             for value in filter_value:
                 csv_df = csv_df[csv_df[filter_col] != value]
@@ -659,16 +663,12 @@ def check_normality(data, variable_name, verbose=False):
             print(f"Normal distribution: The data for {variable_name} is not normally distributed.")
         return False
 
-def clean_controls(df,pc,nc,other):
-    if 'col' in df.columns:
-        df['column'] = df['col']
-    if nc != None:
-        df = df[~df['column'].isin([nc])]
-    if pc != None:
-        df = df[~df['column'].isin([pc])]
-    if other != None:
-        df = df[~df['column'].isin([other])]
-        print(f'Removed data from {nc, pc, other}')
+def clean_controls(df,values, column):
+    if column in df.columns:
+        if isinstance(values, list):
+            for value in values:
+                df = df[~df[column].isin([value])]
+                print(f'Removed data from {value}')
     return df
 
 def process_scores(df, dependent_variable, plate, min_cell_count=25, agg_type='mean', transform=None, regression_type='ols'):

spacr/plot.py

@@ -1521,7 +1521,7 @@ def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True
     return fig
 
 def print_mask_and_flows(stack, mask, flows, overlay=False):
-    fig, axs = plt.subplots(1, 3, figsize=(30, 10))  # Adjust subplot layout
+    fig, axs = plt.subplots(1, 3, figsize=(12, 4))  # Adjust subplot layout
     
     if stack.shape[-1] == 1:
         stack = np.squeeze(stack)

spacr/settings.py

@@ -261,7 +261,7 @@ def get_measure_crop_settings(settings={}):
     settings.setdefault('nucleus_mask_dim',None)
     settings.setdefault('pathogen_mask_dim',None)
     settings.setdefault('cytoplasm',False)
-    settings.setdefault('include_uninfected',True)
+    settings.setdefault('uninfected',True)
     settings.setdefault('cell_min_size',0)
     settings.setdefault('nucleus_min_size',0)
     settings.setdefault('pathogen_min_size',0)
@@ -527,26 +527,31 @@ def set_generate_dataset_defaults(settings):
     return settings
 
 def get_perform_regression_default_settings(settings):
-    settings.setdefault('highlight','239740')
-    settings.setdefault('dependent_variable','predictions')
+    settings.setdefault('count_data','list of paths')
+    settings.setdefault('score_data','list of paths')
+    settings.setdefault('positive_control','239740')
+    settings.setdefault('negative_control','233460')
+    settings.setdefault('controls',['000000_1','000000_10','000000_11','000000_12','000000_13','000000_14','000000_15','000000_16','000000_17','000000_18','000000_19','000000_20','000000_21','000000_22','000000_23','000000_24','000000_25','000000_26','000000_27','000000_28','000000_29','000000_3','000000_30','000000_31','000000_32','000000_4','000000_5','000000_6','000000_8','000000_9'])
+    settings.setdefault('fraction_threshold',0.12)
+    settings.setdefault('dependent_variable','pred')
+    settings.setdefault('threshold_method','std')
+    settings.setdefault('threshold_multiplier',3)
     settings.setdefault('transform',None)
     settings.setdefault('agg_type','mean')
     settings.setdefault('min_cell_count',25)
     settings.setdefault('regression_type','ols')
     settings.setdefault('random_row_column_effects',False)
+    settings.setdefault('split_axis_lims','')
+    settings.setdefault('plate','')
+    settings.setdefault('cov_type',None)
     settings.setdefault('alpha',1)
-    settings.setdefault('fraction_threshold',0.1)
-    settings.setdefault('location_column','column')
-    settings.setdefault('nc','c1')
-    settings.setdefault('pc','c2')
-    settings.setdefault('other','c3')
+    settings.setdefault('filter_value',['c1', 'c2', 'c3'])
+    settings.setdefault('filter_column','column')
     settings.setdefault('plate','plate1')
     settings.setdefault('class_1_threshold',None)
-    settings.setdefault('cov_type',None)
     settings.setdefault('metadata_files',['/home/carruthers/Documents/TGME49_Summary.csv','/home/carruthers/Documents/TGGT1_Summary.csv'])
     settings.setdefault('toxo', True)
 
-    
     if settings['regression_type'] == 'quantile':
         print(f"Using alpha as quantile for quantile regression, alpha: {settings['alpha']}")
         settings['agg_type'] = None
@@ -576,6 +581,7 @@ def get_check_cellpose_models_default_settings(settings):
     return settings
 
 def get_identify_masks_finetune_default_settings(settings):
+    settings.setdefault('src', 'path')
     settings.setdefault('model_name', 'cyto')
     settings.setdefault('custom_model', None)
     settings.setdefault('channels', [0,0])
@@ -664,7 +670,7 @@ expected_types = {
     "png_dims": list,
     "normalize_by": str,
     "save_measurements": bool,
-    "include_uninfected": bool,
+    "uninfected": bool,
     "dialate_pngs": bool,
     "dialate_png_ratios": list,
     "n_jobs": int,
@@ -685,6 +691,7 @@ expected_types = {
     "filter_min_max": (list, type(None)),
     "channel_dims": list,
     "backgrounds": list,
+    "background": str,
     "outline_thickness": int,
     "outline_color": str,
     "overlay_chans": list,
@@ -893,7 +900,7 @@ expected_types = {
 categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset","model_path","grna_csv","row_csv","column_csv"],
              "General": ["metadata_type", "custom_regex", "experiment", "channels", "magnification", "channel_dims", "apply_model_to_dataset", "generate_training_dataset", "train_DL_model", "segmentation_mode"],
              "Cellpose":["from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "circular", "invert", "diameter", "grayscale", "background", "Signal_to_noise", "resize", "target_height", "target_width"],
-             "Cell": ["cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "include_uninfected", "merge_edge_pathogen_cells", "adjust_cells", "cells", "cell_loc"],
+             "Cell": ["cell_intensity_range", "cell_size_range", "cell_chann_dim", "cell_channel", "cell_background", "cell_Signal_to_noise", "cell_CP_prob", "cell_FT", "remove_background_cell", "cell_min_size", "cell_mask_dim", "cytoplasm", "cytoplasm_min_size", "uninfected", "merge_edge_pathogen_cells", "adjust_cells", "cells", "cell_loc"],
              "Nucleus": ["nucleus_intensity_range", "nucleus_size_range", "nucleus_chann_dim", "nucleus_channel", "nucleus_background", "nucleus_Signal_to_noise", "nucleus_CP_prob", "nucleus_FT", "remove_background_nucleus", "nucleus_min_size", "nucleus_mask_dim", "nucleus_loc"],
              "Pathogen": ["pathogen_intensity_range", "pathogen_size_range", "pathogen_chann_dim", "pathogen_channel", "pathogen_background", "pathogen_Signal_to_noise", "pathogen_CP_prob", "pathogen_FT", "pathogen_model", "remove_background_pathogen", "pathogen_min_size", "pathogen_mask_dim", "pathogens", "pathogen_loc", "pathogen_types", "pathogen_plate_metadata", ],
              "Measurements": ["remove_image_canvas", "remove_highly_correlated", "homogeneity", "homogeneity_distances", "radial_dist", "calculate_correlation", "manders_thresholds", "save_measurements", "tables", "image_nr", "dot_size", "filter_by", "remove_highly_correlated_features", "remove_low_variance_features", "channel_of_interest"],
@@ -904,12 +911,12 @@ categories = {"Paths":[ "src", "grna", "barcodes", "custom_model_path", "dataset
              "Hyperparamiters (Embedding)": ["visualize","n_neighbors","min_dist","metric","resnet_features","reduction_method","embedding_by_controls","col_to_compare","log_data"],
              "Hyperparamiters (Clustering)": ["eps","min_samples","analyze_clusters","clustering","remove_cluster_noise"],
              "Hyperparamiters (Regression)":["cov_type", "class_1_threshold", "plate", "other", "fraction_threshold", "alpha", "random_row_column_effects", "regression_type", "min_cell_count", "agg_type", "transform", "dependent_variable"],
-             "Hyperparamiters (Activation)":["cam_type", "normalize", "overlay", "correlation", "target_layer", "normalize_input"],
+             "Hyperparamiters (Activation)":["cam_type", "overlay", "correlation", "target_layer", "normalize_input"],
              "Annotation": ["nc_loc", "pc_loc", "nc", "pc", "cell_plate_metadata","treatment_plate_metadata", "metadata_types", "cell_types", "target","positive_control","negative_control", "location_column", "treatment_loc", "channel_of_interest", "measurement", "treatments", "um_per_pixel", "nr_imgs", "exclude", "exclude_conditions", "mix", "pos", "neg"],
              "Plot": ["plot", "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"],
              "Test": ["test_mode", "test_images", "random_test", "test_nr", "test", "test_split"],
              "Timelapse": ["timelapse", "fps", "timelapse_displacement", "timelapse_memory", "timelapse_frame_limits", "timelapse_remove_transient", "timelapse_mode", "timelapse_objects", "compartments"],
-             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "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"],
+             "Advanced": ["shuffle", "target_intensity_min", "cells_per_well", "nuclei_limit", "pathogen_limit", "uninfected", "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"],
              "Miscellaneous": ["all_to_mip", "pick_slice", "skip_mode", "upscale", "upscale_factor"]
              }
 
@@ -1083,7 +1090,7 @@ def generate_fields(variables, scrollable_frame):
         "nuclei_limit": "(int) - Whether to include multinucleated cells in the analysis.",
         "pathogen_limit": "(int) - Whether to include multi-infected cells in the analysis.",
         "uninfected": "(bool) - Whether to include non-infected cells in the analysis.",
-        "include_uninfected": "(bool) - Whether to include uninfected cells in the analysis.",
+        "uninfected": "(bool) - Whether to include uninfected cells in the analysis.",
         "init_weights": "(bool) - Whether to initialize weights for the model.",
         "src": "(str) - Path to the folder containing the images.",
         "intermedeate_save": "(bool) - Whether to save intermediate results.",
@@ -1362,4 +1369,31 @@ def get_default_generate_activation_map_settings(settings):
     settings.setdefault('manders_thresholds', [15,50, 75])
     settings.setdefault('n_jobs', None)
     
+    return settings
+
+def get_analyze_plaque_settings(settings):
+    settings.setdefault('src', 'path')
+    settings.setdefault('masks', True)
+    settings.setdefault('model_name', 'plaque')
+    settings.setdefault('custom_model', None)
+    settings.setdefault('channels', [0,0])
+    settings.setdefault('background', 200)
+    settings.setdefault('remove_background', False)
+    settings.setdefault('Signal_to_noise', 10)
+    settings.setdefault('CP_prob', 0)
+    settings.setdefault('diameter', 30)
+    settings.setdefault('batch_size', 50)
+    settings.setdefault('flow_threshold', 0.4)
+    settings.setdefault('save', True)
+    settings.setdefault('verbose', True)
+    settings.setdefault('normalize', True)
+    settings.setdefault('percentiles', None)
+    settings.setdefault('circular', False)
+    settings.setdefault('invert', False)
+    settings.setdefault('resize', True)
+    settings.setdefault('target_height', 1120)
+    settings.setdefault('target_width', 1120)
+    settings.setdefault('rescale', False)
+    settings.setdefault('resample', False)
+    settings.setdefault('grayscale', True)
     return settings

spacr/submodules.py

@@ -8,6 +8,9 @@ from cellpose import models as cp_models
 from cellpose import train as train_cp
 from IPython.display import display
 
+import matplotlib.pyplot as plt
+from natsort import natsorted
+
 def analyze_recruitment(settings={}):
     """
     Analyze recruitment data by grouping the DataFrame by well coordinates and plotting controls and recruitment data.
@@ -122,7 +125,31 @@ def analyze_recruitment(settings={}):
 
     return [cells,wells]
 
-def analyze_plaques(folder):
+def analyze_plaques(settings):
+
+    from .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
+
+    download_models()
+    package_dir = os.path.dirname(spacr_path)
+    models_dir = os.path.join(package_dir, 'resources', 'models', 'cp')
+    model_path = os.path.join(models_dir, 'toxo_plaque_cyto_e25000_X1120_Y1120.CP_model')
+    settings['custom_model'] = model_path
+    print('custom_model',settings['custom_model'])
+
+    settings = get_analyze_plaque_settings(settings)
+    save_settings(settings, name='analyze_plaques', show=True)
+
+    if settings['masks']:
+        settings['dst'] = os.path.join(settings['src'], 'masks')
+        display(settings)
+        identify_masks_finetune(settings)
+        folder = settings['dst']
+    else:
+        folder = settings['src']
+
     summary_data = []
     details_data = []
     stats_data = []
@@ -346,4 +373,136 @@ def count_phenotypes(settings):
 
     pivot_df.to_csv(output_path)
 
-    return 
+    return
+
+def compare_reads_to_scores(reads_csv, scores_csv, empirical_dict={}, column='column', value='c3', plate='plate1', fraction_threshold=0.05):
+
+    def calculate_well_score_fractions(df, class_columns='cv_predictions'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find 'plate', 'row', or 'column' in df.columns")
+        prc_summary = df.groupby(['plate', 'row', 'column', 'prc']).size().reset_index(name='total_rows')
+        well_counts = (df.groupby(['plate', 'row', 'column', 'prc', class_columns])
+                       .size()
+                       .unstack(fill_value=0)
+                       .reset_index()
+                       .rename(columns={0: 'class_0', 1: 'class_1'}))
+        summary_df = pd.merge(prc_summary, well_counts, on=['plate', 'row', 'column', 'prc'], how='left')
+        summary_df['class_0_fraction'] = summary_df['class_0'] / summary_df['total_rows']
+        summary_df['class_1_fraction'] = summary_df['class_1'] / summary_df['total_rows']
+        return summary_df
+    
+    def plot_line(df, x_column, y_columns, group_column=None, 
+                  xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+                  save_path=None):
+        """
+        Create a line plot that can handle multiple y-columns, each becoming a separate line.
+        """
+        df = df.loc[natsorted(df.index, key=lambda x: df.loc[x, x_column])]
+
+        plt.figure(figsize=figsize)
+
+        if isinstance(y_columns, list):
+            for y_col in y_columns:
+                sns.lineplot(data=df, x=x_column, y=y_col, label=y_col, marker='o')
+        else:
+            sns.lineplot(data=df, x=x_column, y=y_columns, hue=group_column, marker='o')
+        plt.xlabel(xlabel if xlabel else x_column)
+        plt.ylabel(ylabel if ylabel else 'Value')
+        plt.title(title if title else f'Line Plot')
+        if group_column or isinstance(y_columns, list):
+            plt.legend(title='Legend')
+
+        plt.tight_layout()
+
+        if save_path:
+            plt.savefig(save_path, format='png', dpi=300, bbox_inches='tight')
+            print(f"Plot saved to {save_path}")
+        plt.show()
+    
+    def calculate_grna_fraction_ratio(df, grna1='TGGT1_220950_1', grna2='TGGT1_233460_4'):
+        # Filter relevant grna_names within each prc and group them
+        grouped = df[df['grna_name'].isin([grna1, grna2])] \
+            .groupby(['prc', 'grna_name']) \
+            .agg({'fraction': 'sum', 'count': 'sum'}) \
+            .unstack(fill_value=0)
+        grouped.columns = ['_'.join(col).strip() for col in grouped.columns.values]
+        grouped['fraction_ratio'] = grouped[f'fraction_{grna1}'] / grouped[f'fraction_{grna2}']
+        grouped = grouped.assign(
+            fraction_ratio=lambda x: x['fraction_ratio'].replace([float('inf'), -float('inf')], 0)
+        ).fillna({'fraction_ratio': 0})
+        grouped = grouped.rename(columns={
+            f'count_{grna1}': f'{grna1}_count',
+            f'count_{grna2}': f'{grna2}_count'
+        })
+        result = grouped.reset_index()[['prc', f'{grna1}_count', f'{grna2}_count', 'fraction_ratio']]
+        
+        result['total_reads'] = result[f'{grna1}_count'] + result[f'{grna2}_count']
+        
+        result[f'{grna1}_fraction'] = result[f'{grna1}_count'] / result['total_reads']
+        result[f'{grna2}_fraction'] = result[f'{grna2}_count'] / result['total_reads']
+
+        return result
+
+    def calculate_well_read_fraction(df, count_column='count'):
+        if all(col in df.columns for col in ['plate', 'row', 'column']):
+            df['prc'] = df['plate'] + '_' + df['row'] + '_' + df['column']
+        else:
+            raise ValueError("Cannot find plate, row or column in df.columns")
+        grouped_df = df.groupby('prc')[count_column].sum().reset_index()
+        grouped_df = grouped_df.rename(columns={count_column: 'total_counts'})
+        df = pd.merge(df, grouped_df, on='prc')
+        df['fraction'] = df['count'] / df['total_counts']
+        return df
+    
+    reads_df = pd.read_csv(reads_csv)
+    scores_df = pd.read_csv(scores_csv)
+    
+    if plate != None:
+        reads_df['plate'] = plate
+        scores_df['plate'] = plate
+    
+    if 'col' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'col': 'column'})
+    if 'column_name' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'column_name': 'column'})
+    if 'col' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'col': 'column'})
+    if 'column_name' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'column_name': 'column'})
+    if 'row_name' in reads_df.columns:
+        reads_df = reads_df.rename(columns={'row_name': 'row'})
+    if 'row_name' in scores_df.columns:
+        scores_df = scores_df.rename(columns={'row_name': 'row'})
+    
+    reads_df = calculate_well_read_fraction(reads_df)
+    scores_df = calculate_well_score_fractions(scores_df)
+    reads_col_df = reads_df[reads_df[column]==value]
+    scores_col_df = scores_df[scores_df[column]==value]
+    
+    #reads_col_df = reads_col_df[reads_col_df['fraction'] >= fraction_threshold]
+    reads_col_df = calculate_grna_fraction_ratio(reads_col_df, grna1='TGGT1_220950_1', grna2='TGGT1_233460_4')
+    df = pd.merge(reads_col_df, scores_col_df, on='prc')
+    
+    
+    # Convert the dictionary to a DataFrame and calculate fractions
+    df_emp = pd.DataFrame(
+        [(key, val[0], val[1], val[0] / (val[0] + val[1]), val[1] / (val[0] + val[1])) 
+         for key, val in empirical_dict.items()],
+        columns=['key', 'value1', 'value2', 'fraction1', 'fraction2']
+    )
+
+    df = pd.merge(df, df_emp, left_on='row', right_on='key')
+    display(df)
+    y_columns = ['class_1_fraction', 'TGGT1_220950_1_fraction', 'fraction2']
+    
+    plot_line(df, x_column='row', y_columns=y_columns, group_column=None, 
+              xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+              save_path=None)
+    
+    y_columns = ['class_0_fraction', 'TGGT1_233460_4_fraction', 'fraction1']
+
+    plot_line(df, x_column='row', y_columns=y_columns, group_column=None, 
+          xlabel=None, ylabel=None, title=None, figsize=(10, 6), 
+          save_path=None)

spacr/toxo.py

@@ -136,6 +136,7 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
     data['variable'].fillna(data['feature'], inplace=True)
     split_columns = data['variable'].str.split('_', expand=True)
     data['gene_nr'] = split_columns[0]
+    data = data[data['variable'] != 'Intercept']
 
     # Load metadata
     if isinstance(metadata_path, pd.DataFrame):
@@ -158,11 +159,14 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
         merged_data['condition'],
         categories=['other','pc', 'nc', 'control'],
         ordered=True)
+    
+
+    display(merged_data)
 
     # Create subplots with a broken y-axis
     figsize_2 = figsize / 2
     fig, (ax1, ax2) = plt.subplots(
-        2, 1, figsize=(figsize_2, figsize), 
+        2, 1, figsize=(figsize, figsize), 
         sharex=True, gridspec_kw={'height_ratios': [1, 3]}
     )
 
@@ -178,11 +182,12 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
         data=merged_data,
         x='coefficient',
         y='-log10(p_value)',
-        hue='condition',
-        style=metadata_column if metadata_column else None,
+        hue='condition',  # Keep colors but prevent them from showing in the final legend
+        style=metadata_column if metadata_column else None,  # Shape-based legend
         s=point_size,
         edgecolor='black', 
         palette=palette,
+        legend='brief',  # Capture the full legend initially
         alpha=0.8,
         ax=ax2  # Lower plot
     )
@@ -196,6 +201,7 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
         s=point_size,
         palette=palette,
         edgecolor='black', 
+        legend=False,  # Suppress legend for upper plot
         alpha=0.8,
         ax=ax1  # Upper plot
     )
@@ -222,9 +228,24 @@ def custom_volcano_plot(data_path, metadata_path, metadata_column='tagm_location
     ax2.spines['top'].set_visible(False)
     ax1.tick_params(labelbottom=False)
 
-    ax1.legend_.remove()
     if ax1.get_legend() is not None:
-        ax1.get_legend().remove()
+        ax1.legend_.remove()
+        ax1.get_legend().remove()    # Extract handles and labels from the legend
+    handles, labels = ax2.get_legend_handles_labels()
+
+    # Identify shape-based legend entries (skip color-based entries)
+    shape_handles = handles[len(set(merged_data['condition'])):]
+    shape_labels = labels[len(set(merged_data['condition'])):]
+
+    # Set the legend with only shape-based entries
+    ax2.legend(
+        shape_handles,
+        shape_labels,
+        bbox_to_anchor=(1.05, 1),
+        loc='upper left',
+        borderaxespad=0.
+    )
+
     ax1.tick_params(axis='x', which='both', bottom=False, top=False, labelbottom=False)
 
     # Add vertical threshold lines to both plots

spacr/utils.py

@@ -64,6 +64,7 @@ from sklearn.decomposition import PCA
 from sklearn.ensemble import RandomForestClassifier
 
 from huggingface_hub import list_repo_files
+from spacr import __file__ as spacr_path
 
 import umap.umap_ as umap
 #import umap
@@ -2912,7 +2913,7 @@ def _relabel_parent_with_child_labels(parent_mask, child_mask):
 
     return parent_mask_new, child_mask
     
-def _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=True):
+def _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, uninfected=True):
     """
     Exclude objects from the masks based on certain criteria.
 
@@ -2921,7 +2922,7 @@ def _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, inc
         nucleus_mask (ndarray): Mask representing nucleus.
         pathogen_mask (ndarray): Mask representing pathogens.
         cytoplasm_mask (ndarray): Mask representing cytoplasm.
-        include_uninfected (bool, optional): Whether to include uninfected cells. Defaults to True.
+        uninfected (bool, optional): Whether to include uninfected cells. Defaults to True.
 
     Returns:
         tuple: A tuple containing the filtered cell mask, nucleus mask, pathogen mask, and cytoplasm mask.
@@ -2936,7 +2937,7 @@ def _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, inc
         has_nucleus = np.any(nucleus_mask[cell_region])
         has_cytoplasm = np.any(cytoplasm_mask[cell_region])
         has_pathogen = np.any(pathogen_mask[cell_region])
-        if include_uninfected:
+        if uninfected:
             if has_nucleus and has_cytoplasm:
                 filtered_cells[cell_region] = cell_label
         else:
@@ -4963,7 +4964,71 @@ def map_condition(col_value, neg='c1', pos='c2', mix='c3'):
     else:
         return 'screen'
     
-def download_models(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
+def download_models(repo_id="einarolafsson/models", retries=5, delay=5):
+    """
+    Downloads all model files from Hugging Face and stores them in the `resources/models` directory 
+    within the installed `spacr` package.
+
+    Args:
+        repo_id (str): The repository ID on Hugging Face (default is 'einarolafsson/models').
+        retries (int): Number of retry attempts in case of failure.
+        delay (int): Delay in seconds between retries.
+
+    Returns:
+        str: The local path to the downloaded models.
+    """
+    # Construct the path to the `resources/models` directory in the installed `spacr` package
+    package_dir = os.path.dirname(spacr_path)
+    local_dir = os.path.join(package_dir, 'resources', 'models')
+
+    # Create the local directory if it doesn't exist
+    if not os.path.exists(local_dir):
+        os.makedirs(local_dir)
+    elif len(os.listdir(local_dir)) > 0:
+        print(f"Models already downloaded to: {local_dir}")
+        return local_dir
+
+    attempt = 0
+    while attempt < retries:
+        try:
+            # List all files in the repo
+            files = list_repo_files(repo_id, repo_type="dataset")
+            print(f"Files in repository: {files}")  # Debugging print to check file list
+
+            # Download each file
+            for file_name in files:
+                for download_attempt in range(retries):
+                    try:
+                        url = f"https://huggingface.co/datasets/{repo_id}/resolve/main/{file_name}?download=true"
+                        print(f"Downloading file from: {url}")  # Debugging
+
+                        response = requests.get(url, stream=True)
+                        print(f"HTTP response status: {response.status_code}")  # Debugging
+                        response.raise_for_status()
+
+                        # Save the file locally
+                        local_file_path = os.path.join(local_dir, os.path.basename(file_name))
+                        with open(local_file_path, 'wb') as file:
+                            for chunk in response.iter_content(chunk_size=8192):
+                                file.write(chunk)
+                        print(f"Downloaded model file: {file_name} to {local_file_path}")
+                        break  # Exit the retry loop if successful
+                    except (requests.HTTPError, requests.Timeout) as e:
+                        print(f"Error downloading {file_name}: {e}. Retrying in {delay} seconds...")
+                        time.sleep(delay)
+                else:
+                    raise Exception(f"Failed to download {file_name} after multiple attempts.")
+
+            return local_dir  # Return the directory where models are saved
+
+        except (requests.HTTPError, requests.Timeout) as e:
+            print(f"Error downloading files: {e}. Retrying in {delay} seconds...")
+            attempt += 1
+            time.sleep(delay)
+
+    raise Exception("Failed to download model files after multiple attempts.")
+
+def download_models_v1(repo_id="einarolafsson/models", local_dir=None, retries=5, delay=5):
     """
     Downloads all model files from Hugging Face and stores them in the specified local directory.
 

{spacr-0.3.41.dist-info → spacr-0.3.43.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.1
 Name: spacr
-Version: 0.3.41
+Version: 0.3.43
 Summary: Spatial phenotype analysis of crisp screens (SpaCr)
 Home-page: https://github.com/EinarOlafsson/spacr
 Author: Einar Birnir Olafsson

{spacr-0.3.41.dist-info → spacr-0.3.43.dist-info}/RECORD

@@ -7,27 +7,27 @@ spacr/app_mask.py,sha256=l-dBY8ftzCMdDe6-pXc2Nh_u-idNL9G7UOARiLJBtds,153
 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/cellpose.py,sha256=zv4BzhaP2O-mtQ-pUfYvpOyxgn1ke_bDWgdHD5UWm9I,13942
+spacr/cellpose.py,sha256=KxgPAHEs4iLYZA-h_HBYnpSB_rSZKhEBZ6Fs0I9x5E0,13849
 spacr/core.py,sha256=dW9RrAKFLfVsFhX0-kaVMc2T7b47Ky0pTXK-CEVOeWQ,48235
 spacr/deep_spacr.py,sha256=HdOcNU8cHcE_19nP7_5uTz-ih3E169ffr2Hm--NvMvA,43255
 spacr/gui.py,sha256=ARyn9Q_g8HoP-cXh1nzMLVFCKqthY4v2u9yORyaQqQE,8230
-spacr/gui_core.py,sha256=LV_HX5zreu3Bye6sQFDbOuk8Dfj4StMoohy6hsrDEXA,41363
+spacr/gui_core.py,sha256=N7R7yvfK_dJhOReM_kW3Ci8Bokhi1OzsxeKqvSGdvV4,41460
 spacr/gui_elements.py,sha256=w-S1MZdyxt5O3DsNAHNNXy_WGfwBPg0NhwQtCsJeiao,137071
-spacr/gui_utils.py,sha256=7e9DsZIuV7-jh97kEf7v1In_cFzlFueV4SGcGYGpTxw,45454
-spacr/io.py,sha256=LN_gJq_oqjbf8y-lBtLLZtJi8DLbNdyoGEcBYyOjbhQ,143606
+spacr/gui_utils.py,sha256=KDWDWsi7UdZVhXk1ZWGx3ZqJMIxCUm3lGfjrVhbk52s,45463
+spacr/io.py,sha256=ahsUaDwvkCHxGu_uvhgNCGWiJL_-ze291rHHQvdrFXQ,144622
 spacr/logger.py,sha256=lJhTqt-_wfAunCPl93xE65Wr9Y1oIHJWaZMjunHUeIw,1538
-spacr/measure.py,sha256=BThn_sALgKrwGKnLOGpT4FyoJeRVoTZoP9SXbCtCMRw,54857
+spacr/measure.py,sha256=KdboGXoi85BO5-_6er7932FgjFI7G7tuaQDnWSiEuew,54817
 spacr/mediar.py,sha256=FwLvbLQW5LQzPgvJZG8Lw7GniA2vbZx6Jv6vIKu7I5c,14743
-spacr/ml.py,sha256=e6nUQaiKBPwcDN_aZZKsbZG6qEa5k9B42wtuL8ipv3Q,50287
+spacr/ml.py,sha256=vzuEnbQd96mn7T8h3GRsEDnpWSSpxd3ApGMXTiG6b2o,50507
 spacr/openai.py,sha256=5vBZ3Jl2llYcW3oaTEXgdyCB2aJujMUIO5K038z7w_A,1246
-spacr/plot.py,sha256=TDGMwiIHjvk6v94WFlIvemU-6JfEik_GmSez51vyvCc,135869
+spacr/plot.py,sha256=mqD0XyExAZ_qhnz71bLJo7nTVGod2eN8bJ_9sAV2eN8,135868
 spacr/sequencing.py,sha256=t18mgpK6rhWuB1LtFOsPxqgpFXxuUmrD06ecsaVQ0Gw,19655
-spacr/settings.py,sha256=AzP9NGiXI1MqT69bHObxwDSCUk0kdstBVvl1JpcD_-w,75960
+spacr/settings.py,sha256=VkCgZ8r30Q3VmTmYCf2_KRX3htqXR80osOjq37vLbwM,77770
 spacr/sim.py,sha256=1xKhXimNU3ukzIw-3l9cF3Znc_brW8h20yv8fSTzvss,71173
-spacr/submodules.py,sha256=AB7s6-cULsaqz-haAaCtXfGEIi8uPZGT4xoCslUJC3Y,18391
+spacr/submodules.py,sha256=QRzojeHMZ2iRskmU5D7Q9iu6U1wPTODRm55r30KLZyY,25653
 spacr/timelapse.py,sha256=FSYpUtAVy6xc3lwprRYgyDTT9ysUhfRQ4zrP9_h2mvg,39465
-spacr/toxo.py,sha256=7dUJe5_HSvDCP16OIXtbYLyshh9LXb2JQ80Vtn-XdPk,15979
-spacr/utils.py,sha256=_8OxwGVCZaMNBiweB4_YOxBkqQX1LR9YstPSIFmeQKA,216420
+spacr/toxo.py,sha256=MVDfkfTl6fhbzg3izLWdtr2arARYIhI1TdScnHtPVqI,16770
+spacr/utils.py,sha256=yDxP8TslqLoKFpKyaCPDOulAitkDBR6MOwPG8FH8mYw,219417
 spacr/version.py,sha256=axH5tnGwtgSnJHb5IDhiu4Zjk5GhLyAEDRe-rnaoFOA,409
 spacr/resources/MEDIAR/.gitignore,sha256=Ff1q9Nme14JUd-4Q3jZ65aeQ5X4uttptssVDgBVHYo8,152
 spacr/resources/MEDIAR/LICENSE,sha256=yEj_TRDLUfDpHDNM0StALXIt6mLqSgaV2hcCwa6_TcY,1065
@@ -150,9 +150,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.3.41.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
-spacr-0.3.41.dist-info/METADATA,sha256=zGZO-9iZjljHTjnVg9kAxQJjr2vqpobl7S7ZSQlgxP8,5949
-spacr-0.3.41.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
-spacr-0.3.41.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
-spacr-0.3.41.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
-spacr-0.3.41.dist-info/RECORD,,
+spacr-0.3.43.dist-info/LICENSE,sha256=SR-2MeGc6SCM1UORJYyarSWY_A-JaOMFDj7ReSs9tRM,1083
+spacr-0.3.43.dist-info/METADATA,sha256=NBeaa28RVdVWa4lgSnWFKTuqVS_hJzUtg3sdMjgmf40,5949
+spacr-0.3.43.dist-info/WHEEL,sha256=HiCZjzuy6Dw0hdX5R3LCFPDmFS4BWl8H-8W39XfmgX4,91
+spacr-0.3.43.dist-info/entry_points.txt,sha256=BMC0ql9aNNpv8lUZ8sgDLQMsqaVnX5L535gEhKUP5ho,296
+spacr-0.3.43.dist-info/top_level.txt,sha256=GJPU8FgwRXGzKeut6JopsSRY2R8T3i9lDgya42tLInY,6
+spacr-0.3.43.dist-info/RECORD,,