spacr 0.3.42__py3-none-any.whl → 0.3.45__py3-none-any.whl

spacr/plot.py

@@ -1,8 +1,9 @@
-import os, random, cv2, glob, math, torch
+import os, random, cv2, glob, math, torch, skimage
 
 import numpy as np
 import pandas as pd
 import matplotlib.pyplot as plt
+from matplotlib.colors import ListedColormap
 import matplotlib as mpl
 import scipy.ndimage as ndi
 import seaborn as sns
@@ -13,6 +14,9 @@ from IPython.display import display
 from skimage.segmentation import find_boundaries
 from skimage import measure
 from skimage.measure import find_contours, label, regionprops
+from skimage.segmentation import mark_boundaries
+from skimage.transform import resize as sk_resize
+
 import tifffile as tiff
 
 from scipy.stats import normaltest, ttest_ind, mannwhitneyu, f_oneway, kruskal
@@ -1520,8 +1524,135 @@ def plot_plates(df, variable, grouping, min_max, cmap, min_count=0, verbose=True
         plt.show()
     return fig
 
-def print_mask_and_flows(stack, mask, flows, overlay=False):
-    fig, axs = plt.subplots(1, 3, figsize=(30, 10))  # Adjust subplot layout
+def print_mask_and_flows(stack, mask, flows, overlay=True, max_size=1000, thickness=2):
+    """
+    Display the original image, mask with outlines, and flow images.
+    
+    Args:
+        stack (np.array): Original image or stack.
+        mask (np.array): Mask image.
+        flows (list): List of flow images.
+        overlay (bool): Whether to overlay the mask outlines on the original image.
+        max_size (int): Maximum allowed size for any dimension of the images.
+        thickness (int): Thickness of the contour outlines.
+    """
+
+    def resize_if_needed(image, max_size):
+        """Resize image if any dimension exceeds max_size while maintaining aspect ratio."""
+        if max(image.shape[:2]) > max_size:
+            scale = max_size / max(image.shape[:2])
+            new_shape = (int(image.shape[0] * scale), int(image.shape[1] * scale))
+            if image.ndim == 3:
+                new_shape += (image.shape[2],)
+            return sk_resize(image, new_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
+        return image
+
+    def generate_contours(mask):
+        """Generate contours for each object in the mask using OpenCV."""
+        contours, _ = cv2.findContours(mask.astype(np.uint8), cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+        return contours
+
+    def apply_contours_on_image(image, mask, color=(255, 0, 0), thickness=2):
+        """Draw the contours on the original image."""
+        # Ensure the image is in RGB format
+        if image.ndim == 2:  # Grayscale to RGB
+            image = normalize_to_uint8(image)  # Convert to uint8 if needed
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+        else:
+            image_rgb = image.copy()
+
+        # Generate and draw contours
+        contours = generate_contours(mask)
+        cv2.drawContours(image_rgb, contours, -1, color, thickness)
+
+        return image_rgb
+
+    def normalize_to_uint8(image):
+        """Normalize and convert image to uint8."""
+        image = np.clip(image, 0, 1)  # Ensure values are between 0 and 1
+        return (image * 255).astype(np.uint8)  # Convert to uint8
+    
+    
+    # Resize if necessary
+    stack = resize_if_needed(stack, max_size)
+    mask = resize_if_needed(mask, max_size)
+    if flows != None:
+        flows = [resize_if_needed(flow, max_size) for flow in flows]
+
+        fig, axs = plt.subplots(1, 3, figsize=(12, 4))
+    else:
+        fig, axs = plt.subplots(1, 2, figsize=(12, 4))
+
+    if stack.shape[-1] == 1:
+        stack = np.squeeze(stack)
+
+    # Display original image
+    if stack.ndim == 2:
+        original_image = stack
+    elif stack.ndim == 3:
+        original_image = stack[..., 0]  # Use the first channel as the base
+    else:
+        raise ValueError("Unexpected stack dimensionality.")
+
+    axs[0].imshow(original_image, cmap='gray')
+    axs[0].set_title('Original Image')
+    axs[0].axis('off')
+
+    # Overlay mask outlines on original image if overlay is True
+    if overlay:
+        outlined_image = apply_contours_on_image(original_image, mask, color=(255, 0, 0), thickness=thickness)
+        axs[1].imshow(outlined_image)
+    else:
+        axs[1].imshow(mask, cmap='gray')
+
+    axs[1].set_title('Mask with Overlay' if overlay else 'Mask')
+    axs[1].axis('off')
+
+    if flows != None:
+
+        # Display flow image or its first channel
+        if flows and isinstance(flows, list) and flows[0].ndim in [2, 3]:
+            flow_image = flows[0]
+            if flow_image.ndim == 3:
+                flow_image = flow_image[:, :, 0]  # Use first channel for 3D
+            axs[2].imshow(flow_image, cmap='jet')
+        else:
+            raise ValueError("Unexpected flow dimensionality or structure.")
+
+        axs[2].set_title('Flows')
+        axs[2].axis('off')
+
+    fig.tight_layout()
+    plt.show()
+
+def print_mask_and_flows_v1(stack, mask, flows, overlay=False, max_size=1000):
+    """
+    Display the original image, mask, and flow with optional resizing for large images.
+    
+    Args:
+        stack (np.array): Original image or stack.
+        mask (np.array): Mask image.
+        flows (list): List of flow images.
+        overlay (bool): Whether to overlay the mask on the original image.
+        max_size (int): Maximum allowed size for any dimension of the images.
+    """
+
+    def resize_if_needed(image, max_size):
+        """Resize image if any dimension exceeds max_size while maintaining aspect ratio."""
+        if max(image.shape[:2]) > max_size:
+            scale = max_size / max(image.shape[:2])
+            new_shape = (int(image.shape[0] * scale), int(image.shape[1] * scale))
+            if image.ndim == 3:
+                new_shape += (image.shape[2],)
+            return skimage.transform.resize(image, new_shape, preserve_range=True, anti_aliasing=True).astype(image.dtype)
+        return image
+
+    # Resize if necessary
+    stack = resize_if_needed(stack, max_size)
+    mask = resize_if_needed(mask, max_size)
+    flows = [resize_if_needed(flow, max_size) for flow in flows]
+
+    fig, axs = plt.subplots(1, 3, figsize=(12, 4))  # Adjust subplot layout
     
     if stack.shape[-1] == 1:
         stack = np.squeeze(stack)
@@ -2140,8 +2271,8 @@ def create_grouped_plot(df, grouping_column, data_column, graph_type='bar', summ
     
 class spacrGraph:
     def __init__(self, df, grouping_column, data_column, graph_type='bar', summary_func='mean', 
-                 order=None, colors=None, output_dir='./output', save=False, y_lim=None, 
-                 error_bar_type='std', remove_outliers=False, theme='pastel', representation='object',
+                 order=None, colors=None, output_dir='./output', save=False, y_lim=None, log_y=False,
+                 log_x=False, error_bar_type='std', remove_outliers=False, theme='pastel', representation='object',
                  paired=False, all_to_all=True, compare_group=None, graph_name=None):
         
         """
@@ -2166,7 +2297,8 @@ class spacrGraph:
         self.compare_group = compare_group
         self.y_lim = y_lim
         self.graph_name = graph_name
-
+        self.log_x = log_x
+        self.log_y = log_y
 
         self.results_df = pd.DataFrame()
         self.sns_palette = None
@@ -2582,6 +2714,11 @@ class spacrGraph:
         # Set legend and labels
         ax.set_xlabel(self.grouping_column)
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_jitter_plot(self, ax):
         """Helper method to create a jitter plot (strip plot) with consistent spacing."""
         # Combine grouping column and data column if needed
@@ -2606,6 +2743,11 @@ class spacrGraph:
         unique_labels = dict(zip(labels, handles))
         ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_line_graph(self, ax):
         """Helper method to create a line graph with one line per group based on epochs and accuracy."""
         #display(self.df)
@@ -2629,6 +2771,11 @@ class spacrGraph:
         ax.set_xlabel(f"{x_axis_column}")
         ax.set_ylabel(f"{y_axis_column}")
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_line_with_std_area(self, ax):
         """Helper method to create a line graph with shaded area representing standard deviation."""
 
@@ -2652,7 +2799,12 @@ class spacrGraph:
         # Adjust axis labels
         ax.set_xlabel(f"{x_axis_column}")
         ax.set_ylabel(f"{y_axis_column}")
-     
+        
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_box_plot(self, ax):
         """Helper method to create a box plot with consistent spacing."""
         # Combine grouping column and data column if needed
@@ -2676,6 +2828,11 @@ class spacrGraph:
         handles, labels = ax.get_legend_handles_labels()
         unique_labels = dict(zip(labels, handles))
         ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
+
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
     
     def _create_violin_plot(self, ax):
         """Helper method to create a violin plot with consistent spacing."""
@@ -2702,6 +2859,11 @@ class spacrGraph:
         unique_labels = dict(zip(labels, handles))
         ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_jitter_bar_plot(self, ax):
         """Helper method to create a bar plot with consistent bar thickness and centered error bars."""
         # Flatten DataFrame: Combine grouping column and data column into one group if needed
@@ -2739,6 +2901,11 @@ class spacrGraph:
         # Set legend and labels
         ax.set_xlabel(self.grouping_column)
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _create_jitter_box_plot(self, ax):
         """Helper method to create a box plot with consistent spacing."""
         # Combine grouping column and data column if needed
@@ -2764,6 +2931,11 @@ class spacrGraph:
         unique_labels = dict(zip(labels, handles))
         ax.legend(unique_labels.values(), unique_labels.keys(), loc='best')
 
+        if self.log_y:
+            ax.set_yscale('log')
+        if self.log_x:
+            ax.set_xscale('log')
+
     def _save_results(self):
         """Helper method to save the plot and results."""
         os.makedirs(self.output_dir, exist_ok=True)
@@ -2907,15 +3079,12 @@ def plot_data_from_csv(settings):
 
     dfs = []
     for i, src in enumerate(srcs):
-
         dft = pd.read_csv(src)
         if 'plate' not in dft.columns:
             dft['plate'] = f"plate{i+1}"
         dfs.append(dft)
-        
-    df = pd.concat(dfs, axis=0)
-    #display(df)
 
+    df = pd.concat(dfs, axis=0)
     df = df.dropna(subset=settings['data_column'])
     df = df.dropna(subset=settings['grouping_column'])
     src = srcs[0] 
@@ -2933,6 +3102,7 @@ def plot_data_from_csv(settings):
         output_dir=dst,                              # Directory to save the plot and results
         save=settings['save'],                       # Whether to save the plot and results
         y_lim=settings['y_lim'],                     # Starting point for y-axis (optional)
+        log_y=settings['log_y'],                     # Log-transform the y-axis
         error_bar_type='std',                        # Type of error bar ('std' or 'sem')
         representation=settings['representation'],
         theme=settings['theme'],                     # Seaborn color palette theme (e.g., 'pastel', 'muted')
@@ -3073,3 +3243,87 @@ def plot_image_grid(image_paths, percentiles):
     plt.subplots_adjust(wspace=0, hspace=0, left=0, right=1, top=1, bottom=0)
 
     return fig
+
+def overlay_masks_on_images(img_folder, normalize=True, resize=True, save=False, plot=False, thickness=2):
+    """
+    Load images and masks from folders, overlay mask contours on images, and optionally normalize, resize, and save.
+
+    Args:
+        img_folder (str): Path to the folder containing images.
+        mask_folder (str): Path to the folder containing masks.
+        normalize (bool): If True, normalize images to the 1st and 99th percentiles.
+        resize (bool): If True, resize the final overlay to 500x500.
+        save (bool): If True, save the final overlay in an 'overlay' folder within the image folder.
+        thickness (int): Thickness of the contour lines.
+    """
+
+    def normalize_image(image):
+        """Normalize the image to the 1st and 99th percentiles."""
+        lower, upper = np.percentile(image, [1, 99])
+        image = np.clip((image - lower) / (upper - lower), 0, 1)
+        return (image * 255).astype(np.uint8)
+
+    
+    mask_folder = os.path.join(img_folder,'masks')    
+    overlay_folder = os.path.join(img_folder, "overlay")
+    if save and not os.path.exists(overlay_folder):
+        os.makedirs(overlay_folder)
+
+    # Get common filenames in both image and mask folders
+    image_filenames = set(os.listdir(img_folder))
+    mask_filenames = set(os.listdir(mask_folder))
+    common_filenames = image_filenames.intersection(mask_filenames)
+
+    if not common_filenames:
+        print("No matching filenames found in both folders.")
+        return
+
+    for filename in common_filenames:
+        # Load image and mask
+        img_path = os.path.join(img_folder, filename)
+        mask_path = os.path.join(mask_folder, filename)
+
+        image = tiff.imread(img_path)
+        mask = tiff.imread(mask_path)
+
+        # Normalize the image if requested
+        if normalize:
+            image = normalize_image(image)
+
+        # Ensure the mask is binary
+        mask = (mask > 0).astype(np.uint8)
+
+        # Resize the mask if it doesn't match the image size
+        if mask.shape != image.shape[:2]:
+            mask = cv2.resize(mask, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_NEAREST)
+
+        # Generate contours from the mask
+        contours, _ = cv2.findContours(mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+
+        # Convert to RGB if grayscale
+        if image.ndim == 2:
+            image_rgb = cv2.cvtColor(image, cv2.COLOR_GRAY2RGB)
+        else:
+            image_rgb = image.copy()
+            
+        # Draw contours with alpha blending
+        overlay = image_rgb.copy()
+        cv2.drawContours(overlay, contours, -1, (255, 0, 0), thickness)
+        blended = cv2.addWeighted(overlay, 0.7, image_rgb, 0.3, 0)
+        
+        # Resize the final overlay if requested
+        if resize:
+            blended = cv2.resize(blended, (1000, 1000), interpolation=cv2.INTER_AREA)
+
+        # Save the overlay if requested
+        if save:
+            save_path = os.path.join(overlay_folder, filename)
+            cv2.imwrite(save_path, cv2.cvtColor(blended, cv2.COLOR_RGB2BGR))
+        
+        if plot:
+            # Display the result
+            plt.figure(figsize=(10, 10))
+            plt.imshow(blended)
+            plt.title(f"Overlay: {filename}")
+            plt.axis('off')
+            plt.show()

spacr/settings.py

@@ -566,7 +566,6 @@ def get_check_cellpose_models_default_settings(settings):
     settings.setdefault('normalize', True)
     settings.setdefault('channels', [0,0])
     settings.setdefault('percentiles', None)
-    settings.setdefault('circular', False)
     settings.setdefault('invert', False)
     settings.setdefault('plot', True)
     settings.setdefault('diameter', 40)
@@ -581,6 +580,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])
@@ -595,7 +595,6 @@ def get_identify_masks_finetune_default_settings(settings):
     settings.setdefault('verbose', False)
     settings.setdefault('normalize', True)
     settings.setdefault('percentiles', None)
-    settings.setdefault('circular', False)
     settings.setdefault('invert', False)
     settings.setdefault('resize', False)
     settings.setdefault('target_height', None)
@@ -603,6 +602,7 @@ def get_identify_masks_finetune_default_settings(settings):
     settings.setdefault('rescale', False)
     settings.setdefault('resample', False)
     settings.setdefault('grayscale', True)
+    settings.setdefault('fill_in', True)
     return settings
 
 q = None
@@ -690,6 +690,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,
@@ -706,6 +707,7 @@ expected_types = {
     "remove_background_pathogen": bool,
     "pathogen_model": (str, type(None)),
     "filter": bool,
+    "fill_in":bool,
     "upscale": bool,
     "upscale_factor": float,
     "adjust_cells": bool,
@@ -831,7 +833,6 @@ expected_types = {
     "CP_prob": float,
     "flow_threshold": float,
     "percentiles": (list, type(None)),
-    "circular": bool,
     "invert": bool,
     "diameter": int,
     "grayscale": bool,
@@ -897,7 +898,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"],
+             "Cellpose":["fill_in","from_scratch", "n_epochs", "width_height", "model_name", "custom_model", "resample", "rescale", "CP_prob", "flow_threshold", "percentiles", "invert", "diameter", "grayscale", "Signal_to_noise", "resize", "target_height", "target_width"],
              "Cell": ["cell_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", ],
@@ -909,12 +910,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"]
              }
 
@@ -1069,6 +1070,7 @@ def generate_fields(variables, scrollable_frame):
         "figuresize": "(tuple) - Size of the figures to plot.",
         "filter": "(dict) - Filter settings for the analysis.",
         "filter_by": "(str) - Feature to filter the data by.",
+        "fill_in": "(bool) - Whether to fill in the segmented objects.",
         "flow_threshold": "(float) - Flow threshold for segmentation.",
         "fps": "(int) - Frames per second of the automatically generated timelapse movies.",
         "fraction_threshold": "(float) - Threshold for the fraction of cells to consider in the analysis.",
@@ -1252,7 +1254,6 @@ def generate_fields(variables, scrollable_frame):
         "pos": "(str) - Positive control identifier.",
         "neg": "(str) - Negative control identifier.",
         "minimum_cell_count": "(int) - Minimum number of cells/well. if number of cells < minimum_cell_count, the well is excluded from the analysis.",
-        "circular": "(bool) - If a circle is to be drawn and corners excluded (e.g. square images of round wells).",
         "highlight": "(str) - highlight genes/grnas containing this string.",
         "pathogen_plate_metadata": "(str) - Metadata for the pathogen plate.",
         "treatment_plate_metadata": "(str) - Metadata for the treatment plate.",
@@ -1313,6 +1314,8 @@ descriptions = {
     
     'activation': "",
 
+    'analyze_plaques': "Analyze plaque images to quantify plaque properties. Function: analyze_plaques from spacr.analysis.\n\nKey Features:\n- Plaque Analysis: Quantify plaque properties such as size, intensity, and shape.\n- Batch Processing: Analyze multiple plaque images efficiently.\n- Visualization: Generate visualizations to represent plaque data and patterns.",
+
     'recruitment': "Analyze recruitment data to understand sample recruitment dynamics. Function: recruitment_analysis_tools from spacr.analysis.\n\nKey Features:\n- Recruitment Analysis: Investigate and analyze the recruitment of samples over time or conditions.\n- Visualization: Generate visualizations to represent recruitment trends and patterns.\n- Integration: Utilize data from various sources for a comprehensive recruitment analysis."
 }
 
@@ -1366,5 +1369,23 @@ def get_default_generate_activation_map_settings(settings):
     settings.setdefault('correlation', True)
     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('background', 200)
+    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('resize', True)
+    settings.setdefault('target_height', 1120)
+    settings.setdefault('target_width', 1120)
+    settings.setdefault('rescale', False)
+    settings.setdefault('resample', False)
+    settings.setdefault('fill_in', True)
     return settings