spacr 0.3.41__tar.gz → 0.3.43__tar.gz

{spacr-0.3.41/spacr.egg-info → spacr-0.3.43}/PKG-INFO

@@ -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 → spacr-0.3.43}/setup.py

@@ -67,7 +67,7 @@ dependencies = [
 
 setup(
     name="spacr",
-    version="0.3.41",
+    version="0.3.43",
     author="Einar Birnir Olafsson",
     author_email="olafsson@med.umich.com",
     description="Spatial phenotype analysis of crisp screens (SpaCr)",

{spacr-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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-0.3.41 → spacr-0.3.43}/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