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

spacr/measure.py

@@ -12,6 +12,8 @@ from scipy.ndimage import binary_dilation
 from skimage.segmentation import find_boundaries
 from skimage.feature import graycomatrix, graycoprops
 from mahotas.features import zernike_moments
+from skimage import morphology, measure, filters
+from skimage.util import img_as_bool
 
 from .logger import log_function_call
 
@@ -92,6 +94,69 @@ def _calculate_zernike(mask, df, degree=8):
     else:
         return df
 
+def _analyze_cytoskeleton(array, mask, channel):
+    """
+    Analyzes and extracts skeleton properties from labeled objects in a masked image based on microtubule staining intensities.
+
+    Parameters:
+    image : numpy array
+        Intensity image where the microtubules are stained.
+    mask : numpy array
+        Mask where objects are labeled for analysis. Each label corresponds to a unique object.
+
+    Returns:
+    DataFrame
+        A pandas DataFrame containing the measured properties of each object's skeleton.
+    """
+
+    image = array[:, :, channel]
+
+    properties_list = []
+
+    # Process each object in the mask based on its label
+    for label in np.unique(mask):
+        if label == 0:
+            continue  # Skip background
+
+        # Isolate the object using the label
+        object_region = mask == label
+        region_intensity = np.where(object_region, image, 0)  # Use np.where for more efficient masking
+
+        # Ensure there are non-zero values to process
+        if np.any(region_intensity):
+            # Calculate adaptive offset based on intensity percentiles within the object
+            valid_pixels = region_intensity[region_intensity > 0]
+            if len(valid_pixels) > 1:  # Ensure there are enough pixels to compute percentiles
+                offset = np.percentile(valid_pixels, 90) - np.percentile(valid_pixels, 50)
+                block_size = 35  # Adjust this based on your object sizes and detail needs
+                local_thresh = filters.threshold_local(region_intensity, block_size=block_size, offset=offset)
+                cytoskeleton = region_intensity > local_thresh
+
+                # Skeletonize the thresholded cytoskeleton
+                skeleton = morphology.skeletonize(img_as_bool(cytoskeleton))
+
+                # Measure properties of the skeleton
+                skeleton_props = measure.regionprops(measure.label(skeleton), intensity_image=image)
+                skeleton_length = sum(prop.area for prop in skeleton_props)  # Sum of lengths of all skeleton segments
+                branch_data = morphology.skeleton_branch_analysis(skeleton)
+
+                # Store properties
+                properties = {
+                    "object_label": label,
+                    "skeleton_length": skeleton_length,
+                    "skeleton_branch_points": len(branch_data['branch_points'])
+                }
+                properties_list.append(properties)
+            else:
+                # Handle cases with insufficient pixels
+                properties_list.append({
+                    "object_label": label,
+                    "skeleton_length": 0,
+                    "skeleton_branch_points": 0
+                })
+
+    return pd.DataFrame(properties_list)
+
 @log_function_call
 def _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings, zernike=True, degree=8):
     """
@@ -526,6 +591,7 @@ def _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_ma
 
 @log_function_call
 def _measure_crop_core(index, time_ls, file, settings):
+
     """
     Measure and crop the images based on specified settings.
 
@@ -624,9 +690,8 @@ def _measure_crop_core(index, time_ls, file, settings):
         if settings['cytoplasm_min_size'] is not None and settings['cytoplasm_min_size'] != 0:
             cytoplasm_mask = _filter_object(cytoplasm_mask, settings['cytoplasm_min_size'])
 
-        if settings['cell_mask_dim'] is not None and settings['pathogen_mask_dim'] is not None:
-            if settings['include_uninfected'] == False:
-                cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask = _exclude_objects(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, include_uninfected=False)
+        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'])
 
         # Update data with the new masks
         if settings['cell_mask_dim'] is not None:
@@ -645,6 +710,10 @@ def _measure_crop_core(index, time_ls, file, settings):
 
             cell_df, nucleus_df, pathogen_df, cytoplasm_df = _morphological_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, settings)
 
+            #if settings['skeleton']:
+                #skeleton_df = _analyze_cytoskeleton(image=channel_arrays, mask=cell_mask, channel=1)
+                #merge skeleton_df with cell_df here
+
             cell_intensity_df, nucleus_intensity_df, pathogen_intensity_df, cytoplasm_intensity_df = _intensity_measurements(cell_mask, nucleus_mask, pathogen_mask, cytoplasm_mask, channel_arrays, settings, sizes=[1, 2, 3, 4, 5], periphery=True, outside=True)
             if settings['cell_mask_dim'] is not None:
                 cell_merged_df = _merge_and_save_to_database(cell_df, cell_intensity_df, 'cell', source_folder, file_name, settings['experiment'], settings['timelapse'])
@@ -658,7 +727,6 @@ def _measure_crop_core(index, time_ls, file, settings):
             if settings['cytoplasm']:
                 cytoplasm_merged_df = _merge_and_save_to_database(cytoplasm_df, cytoplasm_intensity_df, 'cytoplasm', source_folder, file_name, settings['experiment'], settings['timelapse'])
 
-        
         if settings['save_png'] or settings['save_arrays'] or settings['plot']:
 
             if isinstance(settings['dialate_pngs'], bool):
@@ -731,7 +799,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                             png_channels = data[:, :, settings['png_dims']].astype(data_type)
 
                             if settings['normalize_by'] == 'fov':
-                                percentiles_list = _get_percentiles(png_channels, settings['normalize_percentiles'][0],q2=settings['normalize_percentiles'][1])
+                                percentiles_list = _get_percentiles(png_channels, settings['normalize'][0],q2=settings['normalize'][1])
 
                             png_channels = _crop_center(png_channels, region, new_width=width, new_height=height)
 
@@ -788,6 +856,7 @@ def _measure_crop_core(index, time_ls, file, settings):
                                     conn.commit()
                                 except sqlite3.OperationalError as e:
                                     print(f"SQLite error: {e}", flush=True)
+                                    traceback.print_exc()
 
                             if settings['plot']:
                                 _plot_cropped_arrays(png_channels)
@@ -819,14 +888,13 @@ def _measure_crop_core(index, time_ls, file, settings):
     return average_time, cells
 
 @log_function_call
-def measure_crop(settings, annotation_settings, advanced_settings):
+def measure_crop(settings):
+    
     """
     Measure the crop of an image based on the provided settings.
 
     Args:
         settings (dict): The settings for measuring the crop.
-        annotation_settings (dict): The annotation settings.
-        advanced_settings (dict): The advanced settings.
 
     Returns:
         None
@@ -845,19 +913,6 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     from .plot import _save_scimg_plot
     from .utils import _list_endpoint_subdirectories, _generate_representative_images
     
-    settings = {**settings, **annotation_settings, **advanced_settings}
-    
-    dirname = os.path.dirname(settings['input_folder'])
-    settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
-    settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
-    os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
-    settings_df.to_csv(settings_csv, index=False)
-
-    if settings['timelapse_objects'] == 'nucleus':
-        if not settings['cell_mask_dim'] is None:
-            tlo = settings['timelapse_objects']
-            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
-
     #general settings
     settings['merge_edge_pathogen_cells'] = True
     settings['radial_dist'] = True
@@ -866,6 +921,26 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     settings['homogeneity'] = True
     settings['homogeneity_distances'] = [8,16,32]
     settings['save_arrays'] = False
+
+    settings['dialate_pngs'] = False
+    settings['dialate_png_ratios'] = [0.2]
+    settings['timelapse'] = False
+    settings['representative_images'] = False
+    settings['timelapse_objects'] = 'cell'
+    settings['max_workers'] = os.cpu_count()-2
+    settings['experiment'] = 'test'
+    settings['cells'] = 'HeLa'
+    settings['cell_loc'] = None
+    settings['pathogens'] = ['ME49Dku80WT', 'ME49Dku80dgra8:GRA8', 'ME49Dku80dgra8', 'ME49Dku80TKO']
+    settings['pathogen_loc'] = [['c1', 'c2', 'c3', 'c4', 'c5', 'c6'], ['c7', 'c8', 'c9', 'c10', 'c11', 'c12'], ['c13', 'c14', 'c15', 'c16', 'c17', 'c18'], ['c19', 'c20', 'c21', 'c22', 'c23', 'c24']]
+    settings['treatments'] = ['BR1', 'BR2', 'BR3']
+    settings['treatment_loc'] = [['c1', 'c2', 'c7', 'c8', 'c13', 'c14', 'c19', 'c20'], ['c3', 'c4', 'c9', 'c10', 'c15', 'c16', 'c21', 'c22'], ['c5', 'c6', 'c11', 'c12', 'c17', 'c18', 'c23', 'c24']]
+    settings['channel_of_interest'] = 2
+    settings['compartments'] = ['pathogen', 'cytoplasm']
+    settings['measurement'] = 'mean_intensity'
+    settings['nr_imgs'] = 32
+    settings['um_per_pixel'] = 0.1
+    settings['center_crop'] = True
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -878,7 +953,18 @@ def measure_crop(settings, annotation_settings, advanced_settings):
     else:
         settings['cytoplasm'] = False
 
-    settings['center_crop'] = True
+    #settings = {**settings, **annotation_settings, **advanced_settings}
+    
+    dirname = os.path.dirname(settings['input_folder'])
+    settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
+    settings_csv = os.path.join(dirname,'settings','measure_crop_settings.csv')
+    os.makedirs(os.path.join(dirname,'settings'), exist_ok=True)
+    settings_df.to_csv(settings_csv, index=False)
+
+    if settings['timelapse_objects'] == 'nucleus':
+        if not settings['cell_mask_dim'] is None:
+            tlo = settings['timelapse_objects']
+            print(f'timelapse object:{tlo}, cells will be relabeled to nucleus labels to track cells.')
 
     int_setting_keys = ['cell_mask_dim', 'nucleus_mask_dim', 'pathogen_mask_dim', 'cell_min_size', 'nucleus_min_size', 'pathogen_min_size', 'cytoplasm_min_size']
     
@@ -922,49 +1008,49 @@ def measure_crop(settings, annotation_settings, advanced_settings):
                 time_left = (((files_to_process-files_processed)*average_time)/max_workers)/60
                 print(f'Progress: {files_processed}/{files_to_process} Time/img {average_time:.3f}sec, Time Remaining {time_left:.3f} min.', end='\r', flush=True)
             result.get()
-    
-    if settings['save_png']:
-        img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
-        sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
-
-        for i, well_src in enumerate(sc_img_fldrs):
-            if len(os.listdir(well_src)) < 16:
-                nr_imgs = len(os.listdir(well_src))
-                standardize = False
-            else:
-                nr_imgs = 16
-                standardize = True
-            try:
-                all_folders = len(sc_img_fldrs)
-                _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
-
-            except Exception as e:
-                print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
-                #traceback.print_exc()
+
+    if settings['representative_images']:
+        if settings['save_png']:
+            img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
+            sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
+
+            for i, well_src in enumerate(sc_img_fldrs):
+                if len(os.listdir(well_src)) < 16:
+                    nr_imgs = len(os.listdir(well_src))
+                    standardize = False
+                else:
+                    nr_imgs = 16
+                    standardize = True
+                try:
+                    all_folders = len(sc_img_fldrs)
+                    _save_scimg_plot(src=well_src, nr_imgs=nr_imgs, channel_indices=settings['png_dims'], um_per_pixel=0.1, scale_bar_length_um=10, standardize=standardize, fontsize=12, show_filename=True, channel_names=['red','green','blue'], dpi=300, plot=False, i=i, all_folders=all_folders)
+
+                except Exception as e:
+                    print(f"Unable to generate figure for folder {well_src}: {e}", end='\r', flush=True)
+                    #traceback.print_exc()
     
         if settings['save_measurements']:
-            if settings['representative_images']:
-                db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
-                channel_indices = settings['png_dims']
-                channel_indices = [min(value, 2) for value in channel_indices]
-                _generate_representative_images(db_path,
-                                            cells=settings['cells'],
-                                            cell_loc=settings['cell_loc'],
-                                            pathogens=settings['pathogens'],
-                                            pathogen_loc=settings['pathogen_loc'],
-                                            treatments=settings['treatments'],
-                                            treatment_loc=settings['treatment_loc'],
-                                            channel_of_interest=settings['channel_of_interest'],
-                                            compartments = settings['compartments'],
-                                            measurement = settings['measurement'],
-                                            nr_imgs=settings['nr_imgs'],
-                                            channel_indices=channel_indices,
-                                            um_per_pixel=settings['um_per_pixel'],
-                                            scale_bar_length_um=10,
-                                            plot=False,
-                                            fontsize=12,
-                                            show_filename=True,
-                                            channel_names=None)
+            db_path = os.path.join(os.path.dirname(settings['input_folder']), 'measurements', 'measurements.db')
+            channel_indices = settings['png_dims']
+            channel_indices = [min(value, 2) for value in channel_indices]
+            _generate_representative_images(db_path,
+                                        cells=settings['cells'],
+                                        cell_loc=settings['cell_loc'],
+                                        pathogens=settings['pathogens'],
+                                        pathogen_loc=settings['pathogen_loc'],
+                                        treatments=settings['treatments'],
+                                        treatment_loc=settings['treatment_loc'],
+                                        channel_of_interest=settings['channel_of_interest'],
+                                        compartments = settings['compartments'],
+                                        measurement = settings['measurement'],
+                                        nr_imgs=settings['nr_imgs'],
+                                        channel_indices=channel_indices,
+                                        um_per_pixel=settings['um_per_pixel'],
+                                        scale_bar_length_um=10,
+                                        plot=False,
+                                        fontsize=12,
+                                        show_filename=True,
+                                        channel_names=None)
 
     if settings['timelapse']:
         if settings['timelapse_objects'] == 'nucleus':
@@ -973,7 +1059,7 @@ def measure_crop(settings, annotation_settings, advanced_settings):
             object_types = ['nucleus','pathogen','cell']
             _timelapse_masks_to_gif(folder_path, mask_channels, object_types)
 
-        if settings['save_png']:
+        #if settings['save_png']:
             img_fldr = os.path.join(os.path.dirname(settings['input_folder']), 'data')
             sc_img_fldrs = _list_endpoint_subdirectories(img_fldr)
             _scmovie(sc_img_fldrs)

spacr/plot.py

@@ -8,7 +8,7 @@ import scipy.ndimage as ndi
 import seaborn as sns
 import scipy.stats as stats
 import statsmodels.api as sm
-
+import imageio.v2 as imageio
 from IPython.display import display
 from skimage.segmentation import find_boundaries
 from skimage.measure import find_contours
@@ -195,6 +195,88 @@ def _get_colours_merged(outline_color):
         outline_colors = [[1, 0, 0], [0, 0, 1], [0, 1, 0]]  # rbg
     return outline_colors
 
+def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, threshold=1000, extensions=['.npy', '.tif', '.tiff', '.png']):
+    """
+    Plot images and arrays from the given folders.
+
+    Args:
+        folders (list): A list of folder paths containing the images and arrays.
+        lower_percentile (int, optional): The lower percentile for image normalization. Defaults to 1.
+        upper_percentile (int, optional): The upper percentile for image normalization. Defaults to 99.
+        threshold (int, optional): The threshold for determining whether to display an image as a mask or normalize it. Defaults to 1000.
+        extensions (list, optional): A list of file extensions to consider. Defaults to ['.npy', '.tif', '.tiff', '.png'].
+    """
+
+    def normalize_image(image, lower=1, upper=99):
+        p2, p98 = np.percentile(image, (lower, upper))
+        return np.clip((image - p2) / (p98 - p2), 0, 1)
+
+    def find_files(folders, extensions=['.npy', '.tif', '.tiff', '.png']):
+        file_dict = {}
+
+        for folder in folders:
+            for root, _, files in os.walk(folder):
+                for file in files:
+                    if any(file.endswith(ext) for ext in extensions):
+                        file_name_wo_ext = os.path.splitext(file)[0]
+                        file_path = os.path.join(root, file)
+                        if file_name_wo_ext not in file_dict:
+                            file_dict[file_name_wo_ext] = {}
+                        file_dict[file_name_wo_ext][folder] = file_path
+
+        # Filter out files that don't have paths in all folders
+        filtered_dict = {k: v for k, v in file_dict.items() if len(v) == len(folders)}
+        return filtered_dict
+
+    def plot_from_file_dict(file_dict, threshold=1000, lower_percentile=1, upper_percentile=99):
+        """
+        Plot images and arrays from the given file dictionary.
+
+        Args:
+            file_dict (dict): A dictionary containing the file paths for each image or array.
+            threshold (int, optional): The threshold for determining whether to display an image as a mask or normalize it. Defaults to 1000.
+            lower_percentile (int, optional): The lower percentile for image normalization. Defaults to 1.
+            upper_percentile (int, optional): The upper percentile for image normalization. Defaults to 99.
+        """
+
+        for filename, folder_paths in file_dict.items():
+            num_files = len(folder_paths)
+            fig, axes = plt.subplots(1, num_files, figsize=(15, 5))
+            #fig.suptitle(filename)
+
+            # Ensure axes is always a list
+            if num_files == 1:
+                axes = [axes]
+
+            for i, (folder, path) in enumerate(folder_paths.items()):
+                if path.endswith('.npy'):
+                    data = np.load(path)
+                elif path.endswith('.tif') or path.endswith('.tiff'):
+                    data = imageio.imread(path)
+                else:
+                    continue
+
+                ax = axes[i]
+                unique_values = np.unique(data)
+                if len(unique_values) > threshold:
+                    # Normalize image to percentiles
+                    data = normalize_image(data, lower_percentile, upper_percentile)
+                    ax.imshow(data, cmap='gray')
+                else:
+                    # Display as mask with random colormap
+                    cmap = random_cmap(num_objects=len(unique_values))
+                    ax.imshow(data, cmap=cmap)
+
+                ax.set_title(f"{os.path.basename(folder)}: {os.path.basename(path)}")
+                ax.axis('off')
+            plt.tight_layout
+            plt.subplots_adjust(wspace=0.01, hspace=0.01)
+            plt.show()
+                        
+    file_dict = find_files(folders, extensions)
+    plot_from_file_dict(file_dict, threshold, lower_percentile, upper_percentile)
+    return
+
 def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mask_dim, mask_dims, filter_min_max, include_multinucleated, include_multiinfected):
     """
     Filters objects in a plot based on various criteria.
@@ -955,7 +1037,7 @@ def _imshow(img, labels, nrow=20, color='white', fontsize=12):
             if idx < n_images:
                 canvas[i * img_height:(i + 1) * img_height, j * img_width:(j + 1) * img_width] = np.transpose(img[idx], (1, 2, 0))        
     plt.figure(figsize=(50, 50))
-    plt._imshow(canvas)
+    plt.imshow(canvas)
     plt.axis("off")
     for i, label in enumerate(labels):
         row = i // n_col
@@ -1043,7 +1125,7 @@ def _reg_v_plot(df, grouping, variable, plate_number):
     plt.axhline(y=-np.log10(0.05), color='gray', linestyle='--')  # line for p=0.05
     plt.show()
     
-def generate_plate_heatmap(df, plate_number, variable, grouping, min_max):
+def generate_plate_heatmap(df, plate_number, variable, grouping, min_max, min_count):
     df = df.copy()  # Work on a copy to avoid SettingWithCopyWarning
     df['plate'], df['row'], df['col'] = zip(*df['prc'].str.split('_'))
     
@@ -1056,15 +1138,21 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max):
     
     df['row'] = pd.Categorical(df['row'], categories=row_order, ordered=True)
     df['col'] = pd.Categorical(df['col'], categories=col_order, ordered=True)
-    
+    df['count'] = df.groupby(['row', 'col'])['row'].transform('count')
+
+    if min_count > 0:
+        df = df[df['count'] >= min_count]
+
     # Explicitly set observed=True to avoid FutureWarning
-    grouped = df.groupby(['row', 'col'], observed=True)  
+    grouped = df.groupby(['row', 'col'], observed=True) 
+
     
     if grouping == 'mean':
         plate = grouped[variable].mean().reset_index()
     elif grouping == 'sum':
         plate = grouped[variable].sum().reset_index()
     elif grouping == 'count':
+        variable = 'count'
         plate = grouped[variable].count().reset_index()
     else:
         raise ValueError(f"Unsupported grouping: {grouping}")
@@ -1074,21 +1162,24 @@ def generate_plate_heatmap(df, plate_number, variable, grouping, min_max):
     if min_max == 'all':
         min_max = [plate_map.min().min(), plate_map.max().max()]
     elif min_max == 'allq':
-        min_max = np.quantile(plate_map.values, [0.2, 0.98])
-    elif min_max == 'plate':
-        min_max = [plate_map.min().min(), plate_map.max().max()]
+        min_max = np.quantile(plate_map.values, [0.02, 0.98])
+    elif isinstance(min_max, (list, tuple)) and len(min_max) == 2:
+        if isinstance(min_max[0], (float)) and isinstance(min_max[1], (float)):
+            min_max = np.quantile(plate_map.values, [min_max[0], min_max[1]])
+        if isinstance(min_max[0], (int)) and isinstance(min_max[1], (int)): 
+            min_max = [min_max[0], min_max[1]]
         
     return plate_map, min_max
 
-def _plot_plates(df, variable, grouping, min_max, cmap):
+def _plot_plates(df, variable, grouping, min_max, cmap, min_count=0):
     plates = df['prc'].str.split('_', expand=True)[0].unique()
     n_rows, n_cols = (len(plates) + 3) // 4, 4
     fig, ax = plt.subplots(n_rows, n_cols, figsize=(40, 5 * n_rows))
     ax = ax.flatten()
 
     for index, plate in enumerate(plates):
-        plate_map, min_max_values = generate_plate_heatmap(df, plate, variable, grouping, min_max)
-        sns.heatmap(plate_map, cmap=cmap, vmin=0, vmax=2, ax=ax[index])
+        plate_map, min_max_values = generate_plate_heatmap(df, plate, variable, grouping, min_max, min_count)
+        sns.heatmap(plate_map, cmap=cmap, vmin=min_max_values[0], vmax=min_max_values[1], ax=ax[index])
         ax[index].set_title(plate)
         
     for i in range(len(plates), n_rows * n_cols):
@@ -1096,7 +1187,26 @@ def _plot_plates(df, variable, grouping, min_max, cmap):
     
     plt.subplots_adjust(wspace=0.1, hspace=0.4)
     plt.show()
-    return
+    return fig
+
+#def plate_heatmap(src, variable='recruitment', grouping='mean', min_max='allq', cmap='viridis', channel_of_interest=3, min_count=25, verbose=False):
+#    db_loc = [src+'/measurements/measurements.db']
+#    tables = ['cell', 'nucleus', 'pathogen','cytoplasm']
+#    include_multinucleated, include_multiinfected, include_noninfected = True, 2.0, True
+#    df, _ = spacr.io._read_and_merge_data(db_loc, 
+#                                 tables,
+#                                 verbose=verbose,
+#                                 include_multinucleated=include_multinucleated,
+#                                 include_multiinfected=include_multiinfected,
+#                                 include_noninfected=include_noninfected)
+#    
+#    df['recruitment'] = df[f'pathogen_channel_{channel_of_interest}_outside_75_percentile']/df[f'cytoplasm_channel_{channel_of_interest}_mean_intensity']
+#
+#    spacr.plot._plot_plates(df, variable, grouping, min_max, cmap, min_count)
+#    #display(df)
+#    #for col in df.columns:
+#    #    print(col)
+#    return
 
 #from finetune cellpose
 #def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1, q2=99):
@@ -1236,6 +1346,35 @@ def visualize_masks(mask1, mask2, mask3, title="Masks Comparison"):
         ax.axis('off')
     plt.suptitle(title)
     plt.show()
+
+def visualize_cellpose_masks(masks, titles=None, comparison_title="Masks Comparison"):
+    """
+    Visualize multiple masks with optional titles.
+    
+    Parameters:
+        masks (list of np.ndarray): A list of masks to visualize.
+        titles (list of str, optional): A list of titles for the masks. If None, default titles will be used.
+        comparison_title (str): Title for the entire figure.
+    """
+    if titles is None:
+        titles = [f'Mask {i+1}' for i in range(len(masks))]
+    
+    # Ensure the length of titles matches the number of masks
+    assert len(titles) == len(masks), "Number of titles and masks must match"
+    
+    num_masks = len(masks)
+    fig, axs = plt.subplots(1, num_masks, figsize=(10 * num_masks, 10))  # Adjusting figure size dynamically
+    
+    for ax, mask, title in zip(axs, masks, titles):
+        cmap = generate_mask_random_cmap(mask)
+        # Normalize and display the mask
+        norm = plt.Normalize(vmin=0, vmax=mask.max())
+        ax.imshow(mask, cmap=cmap, norm=norm)
+        ax.set_title(title)
+        ax.axis('off')
+    
+    plt.suptitle(comparison_title)
+    plt.show()
     
 def plot_comparison_results(comparison_results):
     df = pd.DataFrame(comparison_results)