spacr 0.0.1__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.
@@ -220,10 +300,11 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
         if not filter_min_max is None:
             min_max = filter_min_max[i]
         else:
-            min_max = [0, 100000]
+            min_max = [0, 100000000]
 
         mask = np.take(stack, mask_dim, axis=2)
         props = measure.regionprops_table(mask, properties=['label', 'area'])
+        #props = measure.regionprops_table(mask, intensity_image=intensity_image, properties=['label', 'area', 'mean_intensity'])
         avg_size_before = np.mean(props['area'])
         total_count_before = len(props['label'])
 
@@ -264,7 +345,55 @@ def _filter_objects_in_plot(stack, cell_mask_dim, nucleus_mask_dim, pathogen_mas
 
     return stack
 
-def _normalize_and_outline(image, remove_background, backgrounds, normalize, normalization_percentiles, overlay, overlay_chans, mask_dims, outline_colors, outline_thickness):
+def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1, q2=99):
+    """
+    Plot randomly selected arrays from a given directory.
+
+    Parameters:
+    - src (str): The directory path containing the arrays.
+    - figuresize (int): The size of the figure (default: 50).
+    - cmap (str): The colormap to use for displaying the arrays (default: 'inferno').
+    - nr (int): The number of arrays to plot (default: 1).
+    - normalize (bool): Whether to normalize the arrays (default: True).
+    - q1 (int): The lower percentile for normalization (default: 1).
+    - q2 (int): The upper percentile for normalization (default: 99).
+
+    Returns:
+    None
+    """
+    from .utils import normalize_to_dtype
+    
+    mask_cmap = random_cmap()
+    paths = []
+    for file in os.listdir(src):
+        if file.endswith('.npy'):
+            path = os.path.join(src, file)
+            paths.append(path)
+    paths = random.sample(paths, nr)
+    for path in paths:
+        print(f'Image path:{path}')
+        img = np.load(path)
+        if normalize:
+            img = normalize_to_dtype(array=img, p1=q1, p2=q2)
+        dim = img.shape
+        if len(img.shape)>2:
+            array_nr = img.shape[2]
+            fig, axs = plt.subplots(1, array_nr,figsize=(figuresize,figuresize))
+            for channel in range(array_nr):
+                i = np.take(img, [channel], axis=2)
+                axs[channel].imshow(i, cmap=plt.get_cmap(cmap)) #_imshow
+                axs[channel].set_title('Channel '+str(channel),size=24)
+                axs[channel].axis('off')
+        else:
+            fig, ax = plt.subplots(1, 1,figsize=(figuresize,figuresize))
+            ax.imshow(img, cmap=plt.get_cmap(cmap)) #_imshow
+            ax.set_title('Channel 0',size=24)
+            ax.axis('off')
+        fig.tight_layout()
+        plt.show()
+    return
+
+def _normalize_and_outline(image, remove_background, normalize, normalization_percentiles, overlay, overlay_chans, mask_dims, outline_colors, outline_thickness):
     """
     Normalize and outline an image.
 
@@ -283,43 +412,37 @@ def _normalize_and_outline(image, remove_background, backgrounds, normalize, nor
     Returns:
         tuple: A tuple containing the overlayed image, the original image, and a list of outlines.
     """
-    from .utils import normalize_to_dtype
-    
-    outlines = []
+    from .utils import normalize_to_dtype, _outline_and_overlay, _gen_rgb_image
+
     if remove_background:
-        for chan_index, channel in enumerate(range(image.shape[-1])):
-            single_channel = image[:, :, channel]  # Extract the specific channel
-            background = backgrounds[chan_index]
-            single_channel[single_channel < background] = 0
-            image[:, :, channel] = single_channel
+        backgrounds = np.percentile(image, 1, axis=(0, 1))
+        backgrounds = backgrounds[:, np.newaxis, np.newaxis]
+        mask = np.zeros_like(image, dtype=bool)
+        for chan_index in range(image.shape[-1]):
+            if chan_index not in mask_dims:
+                mask[:, :, chan_index] = image[:, :, chan_index] < backgrounds[chan_index]
+        image[mask] = 0
+
     if normalize:
-        image = normalize_to_dtype(array=image, q1=normalization_percentiles[0], q2=normalization_percentiles[1])
-    rgb_image = np.take(image, overlay_chans, axis=-1)
-    rgb_image = rgb_image.astype(float)
-    rgb_image -= rgb_image.min()
-    rgb_image /= rgb_image.max()
+        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, channels=overlay_chans)
+
     if overlay:
-        overlayed_image = rgb_image.copy()
-        for i, mask_dim in enumerate(mask_dims):
-            mask = np.take(image, mask_dim, axis=2)
-            outline = np.zeros_like(mask)
-            # Find the contours of the objects in the mask
-            for j in np.unique(mask)[1:]:
-                contours = find_contours(mask == j, 0.5)
-                for contour in contours:
-                    contour = contour.astype(int)
-                    outline[contour[:, 0], contour[:, 1]] = j
-            # Make the outline thicker
-            outline = dilation(outline, square(outline_thickness))
-            outlines.append(outline)
-            # Overlay the outlines onto the RGB image
-            for j in np.unique(outline)[1:]:
-                overlayed_image[outline == j] = outline_colors[i % len(outline_colors)]
+        overlayed_image, outlines, image = _outline_and_overlay(image, rgb_image, mask_dims, outline_colors, outline_thickness)
+
         return overlayed_image, image, outlines
     else:
+        # Remove mask_dims from image
+        channels_to_keep = [i for i in range(image.shape[-1]) if i not in mask_dims]
+        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):
+    
     """
     Plot the merged plot with overlay, image channels, and masks.
 
@@ -338,6 +461,7 @@ def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_im
     Returns:
         fig (Figure): The generated matplotlib figure.
     """
+    
     if overlay:
         fig, ax = plt.subplots(1, image.shape[-1] + len(mask_dims) + 1, figsize=(4 * figuresize, figuresize))
         ax[0].imshow(overlayed_image) #_imshow
@@ -378,66 +502,20 @@ def _plot_merged_plot(overlay, image, stack, mask_dims, figuresize, overlayed_im
     plt.show()
     return fig
 
-def plot_arrays(src, figuresize=50, cmap='inferno', nr=1, normalize=True, q1=1, q2=99):
-    """
-    Plot randomly selected arrays from a given directory.
-
-    Parameters:
-    - src (str): The directory path containing the arrays.
-    - figuresize (int): The size of the figure (default: 50).
-    - cmap (str): The colormap to use for displaying the arrays (default: 'inferno').
-    - nr (int): The number of arrays to plot (default: 1).
-    - normalize (bool): Whether to normalize the arrays (default: True).
-    - q1 (int): The lower percentile for normalization (default: 1).
-    - q2 (int): The upper percentile for normalization (default: 99).
-
-    Returns:
-    None
-    """
-    from .utils import normalize_to_dtype
-    
-    mask_cmap = random_cmap()
-    paths = []
-    for file in os.listdir(src):
-        if file.endswith('.npy'):
-            path = os.path.join(src, file)
-            paths.append(path)
-    paths = random.sample(paths, nr)
-    for path in paths:
-        print(f'Image path:{path}')
-        img = np.load(path)
-        if normalize:
-            img = normalize_to_dtype(array=img, q1=q1, q2=q2)
-        dim = img.shape
-        if len(img.shape)>2:
-            array_nr = img.shape[2]
-            fig, axs = plt.subplots(1, array_nr,figsize=(figuresize,figuresize))
-            for channel in range(array_nr):
-                i = np.take(img, [channel], axis=2)
-                axs[channel].imshow(i, cmap=plt.get_cmap(cmap)) #_imshow
-                axs[channel].set_title('Channel '+str(channel),size=24)
-                axs[channel].axis('off')
-        else:
-            fig, ax = plt.subplots(1, 1,figsize=(figuresize,figuresize))
-            ax.imshow(img, cmap=plt.get_cmap(cmap)) #_imshow
-            ax.set_title('Channel 0',size=24)
-            ax.axis('off')
-        fig.tight_layout()
-        plt.show()
-    return
-
 def plot_merged(src, settings):
     """
     Plot the merged images after applying various filters and modifications.
 
     Args:
-        src (ndarray): The source images.
+        src (path): Path to folder with images.
         settings (dict): The settings for the plot.
 
     Returns:
         None
     """
     from .utils import _remove_noninfected
+
+    
     
     font = settings['figuresize']/2
     outline_colors = _get_colours_merged(settings['outline_color'])
@@ -463,13 +541,27 @@ def plot_merged(src, settings):
         if settings['include_multiinfected'] is not True or settings['include_multinucleated'] is not True or settings['filter_min_max'] is not None:
             stack = _filter_objects_in_plot(stack, settings['cell_mask_dim'], settings['nucleus_mask_dim'], settings['pathogen_mask_dim'], mask_dims, settings['filter_min_max'], settings['include_multinucleated'], settings['include_multiinfected'])
 
-        #image = np.take(stack, settings['channel_dims'], axis=2)
-        print('stack.shape', stack.shape)
-        overlayed_image, image, outlines = _normalize_and_outline(stack, settings['remove_background'], settings['backgrounds'], settings['normalize'], settings['normalization_percentiles'], settings['overlay'], settings['overlay_chans'], mask_dims, outline_colors, settings['outline_thickness'])
-        
+        overlayed_image, image, outlines = _normalize_and_outline(image=stack, 
+                                                                  remove_background=settings['remove_background'],
+                                                                  normalize=settings['normalize'],
+                                                                  normalization_percentiles=settings['normalization_percentiles'],
+                                                                  overlay=settings['overlay'],
+                                                                  overlay_chans=settings['overlay_chans'],
+                                                                  mask_dims=mask_dims,
+                                                                  outline_colors=outline_colors,
+                                                                  outline_thickness=settings['outline_thickness'])
         if index < settings['nr']:
             index += 1
-            fig = _plot_merged_plot(settings['overlay'], image, stack, mask_dims, settings['figuresize'], overlayed_image, outlines, settings['cmap'], outline_colors, settings['print_object_number'])
+            fig = _plot_merged_plot(overlay=settings['overlay'],
+                                    image=image,
+                                    stack=stack,
+                                    mask_dims=mask_dims,
+                                    figuresize=settings['figuresize'],
+                                    overlayed_image=overlayed_image,
+                                    outlines=outlines,
+                                    cmap=settings['cmap'],
+                                    outline_colors=outline_colors,
+                                    print_object_number=settings['print_object_number'])
         else:
             return fig
 
@@ -700,7 +792,7 @@ def _visualize_and_save_timelapse_stack_with_tracks(masks, tracks_df, save, src,
         interactive (bool, optional): Flag indicating whether to display the timelapse stack interactively. Defaults to False.
     """
     
-    from .timelapse import _save_mask_timelapse_as_gif
+    from .io import _save_mask_timelapse_as_gif
     
     highest_label = max(np.max(mask) for mask in masks)
     # Generate random colors for each label, including the background
@@ -948,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
@@ -1036,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('_'))
     
@@ -1049,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}")
@@ -1067,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):
@@ -1089,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):
@@ -1229,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)