spacr 0.0.2__py3-none-any.whl → 0.0.6__py3-none-any.whl

spacr/plot.py

@@ -8,11 +8,9 @@ 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
-from skimage.morphology import square, dilation 
 from skimage import measure
 
 from ipywidgets import IntSlider, interact
@@ -195,6 +193,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.
@@ -294,7 +374,7 @@ def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1,
         print(f'Image path:{path}')
         img = np.load(path)
         if normalize:
-            img = normalize_to_dtype(array=img, q1=q1, q2=q2)
+            img = normalize_to_dtype(array=img, p1=q1, p2=q2)
         dim = img.shape
         if len(img.shape)>2:
             array_nr = img.shape[2]
@@ -344,9 +424,11 @@ def _normalize_and_outline(image, remove_background, normalize, normalization_pe
         image[mask] = 0
 
     if normalize:
-        image = normalize_to_dtype(array=image, q1=normalization_percentiles[0], q2=normalization_percentiles[1])
+        image = normalize_to_dtype(array=image, p1=normalization_percentiles[0], p2=normalization_percentiles[1])
+    else:
+        image = normalize_to_dtype(array=image, p1=0, p2=100)
 
-    rgb_image = _gen_rgb_image(image, cahnnels=overlay_chans)
+    rgb_image = _gen_rgb_image(image, channels=overlay_chans)
 
     if overlay:
         overlayed_image, outlines, image = _outline_and_overlay(image, rgb_image, mask_dims, outline_colors, outline_thickness)
@@ -358,6 +440,7 @@ def _normalize_and_outline(image, remove_background, normalize, normalization_pe
         image = np.take(image, channels_to_keep, axis=-1)
         return [], image, []
 
+
 def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_image, outlines, cmap, outline_colors, print_object_number):
     
     """
@@ -431,6 +514,8 @@ def plot_merged(src, settings):
         None
     """
     from .utils import _remove_noninfected
+
+    
     
     font = settings['figuresize']/2
     outline_colors = _get_colours_merged(settings['outline_color'])
@@ -955,7 +1040,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 +1128,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 +1141,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 +1165,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 +1190,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 +1349,49 @@ def visualize_masks(mask1, mask2, mask3, title="Masks Comparison"):
         ax.axis('off')
     plt.suptitle(title)
     plt.show()
+
+def visualize_cellpose_masks(masks, titles=None, filename=None, save=False, src=None):
+    """
+    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.
+    """
+    
+    comparison_title=f"Masks Comparison for {filename}"
+    
+    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()
+    
+    if save:
+        if src is None:
+            src = os.getcwd()
+        results_dir = os.path.join(src, 'results')
+        os.makedirs(results_dir, exist_ok=True)
+        fig_path = os.path.join(results_dir, f'{filename}.pdf')
+        fig.savefig(fig_path, format='pdf')
+        print(f'Saved figure to {fig_path}')
+    return
+
     
 def plot_comparison_results(comparison_results):
     df = pd.DataFrame(comparison_results)