spacr 0.0.70__py3-none-any.whl → 0.0.80__py3-none-any.whl

spacr/plot.py

@@ -12,17 +12,13 @@ import imageio.v2 as imageio
 from IPython.display import display
 from skimage.segmentation import find_boundaries
 from skimage import measure
+from skimage.measure import find_contours, label, regionprops
 
 from ipywidgets import IntSlider, interact
 from IPython.display import Image as ipyimage
 
 from .logger import log_function_call
 
-
-#from .io import _save_figure
-#from .timelapse import _save_mask_timelapse_as_gif
-#from .utils import normalize_to_dtype, _remove_outside_objects, _remove_multiobject_cells, _find_similar_sized_images, _remove_noninfected
-
 def plot_masks(batch, masks, flows, cmap='inferno', figuresize=20, nr=1, file_type='.npz', print_object_number=True):
     """
     Plot the masks and flows for a given batch of images.
@@ -193,7 +189,7 @@ 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']):
+def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, threshold=1000, extensions=['.npy', '.tif', '.tiff', '.png'], overlay=False, max_nr=None, randomize=True):
     """
     Plot images and arrays from the given folders.
 
@@ -203,6 +199,7 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
         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'].
+        overlay (bool, optional): If True, overlay the outlines of the objects on the image. Defaults to False.
     """
 
     def normalize_image(image, lower=1, upper=99):
@@ -226,7 +223,7 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
         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):
+    def plot_from_file_dict(file_dict, threshold=1000, lower_percentile=1, upper_percentile=99, overlay=False, save=False):
         """
         Plot images and arrays from the given file dictionary.
 
@@ -235,18 +232,14 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
             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.
+            overlay (bool, optional): If True, overlay the outlines of the objects on the image. Defaults to False.
         """
 
         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]
+            image_data = None
+            mask_data = None
 
-            for i, (folder, path) in enumerate(folder_paths.items()):
+            for folder, path in folder_paths.items():
                 if path.endswith('.npy'):
                     data = np.load(path)
                 elif path.endswith('.tif') or path.endswith('.tiff'):
@@ -254,25 +247,57 @@ def plot_images_and_arrays(folders, lower_percentile=1, upper_percentile=99, thr
                 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')
+                    image_data = normalize_image(data, lower_percentile, upper_percentile)
                 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()
-                        
+                    mask_data = data
+
+            if image_data is not None and mask_data is not None:
+                fig, axes = plt.subplots(1, 2, figsize=(15, 7))
+                
+                # Display the mask with random colormap
+                cmap = random_cmap(num_objects=len(np.unique(mask_data)))
+                axes[0].imshow(mask_data, cmap=cmap)
+                axes[0].set_title(f"{filename} - Mask")
+                axes[0].axis('off')
+
+                # Display the normalized image
+                axes[1].imshow(image_data, cmap='gray')
+                if overlay:
+                    labeled_mask = label(mask_data)
+                    for region in regionprops(labeled_mask):
+                        if region.image.shape[0] >= 2 and region.image.shape[1] >= 2:
+                            contours = find_contours(region.image, 0.75)
+                            for contour in contours:
+                                # Adjust contour coordinates relative to the full image
+                                contour[:, 0] += region.bbox[0]
+                                contour[:, 1] += region.bbox[1]
+                                axes[1].plot(contour[:, 1], contour[:, 0], linewidth=2, color='magenta')
+
+                axes[1].set_title(f"{filename} - Normalized Image")
+                axes[1].axis('off')
+
+                plt.tight_layout()
+                plt.show()
+
+                if save:
+                    save_path = os.path.join(folder,f"{filename}.png")
+                    plt.savefig(save_path)
+
+    if overlay:
+        print(f'Overlay will only work on the first two folders in the list')
+
     file_dict = find_files(folders, extensions)
-    plot_from_file_dict(file_dict, threshold, lower_percentile, upper_percentile)
+    items = list(file_dict.items())
+    if randomize:
+        random.shuffle(items)
+    if isinstance(max_nr, (int, float)):
+        items = items[:int(max_nr)]
+    file_dict = dict(items)
+
+    plot_from_file_dict(file_dict, threshold, lower_percentile, upper_percentile, overlay, save=False)
     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):
@@ -739,7 +764,53 @@ def _save_scimg_plot(src, nr_imgs=16, channel_indices=[0,1,2], um_per_pixel=0.1,
 
     return
 
-def _plot_cropped_arrays(stack, figuresize=20,cmap='inferno'):
+def _plot_cropped_arrays(stack, filename, figuresize=20, cmap='inferno', threshold=500):
+    """
+    Plot cropped arrays.
+
+    Args:
+        stack (ndarray): The array to be plotted.
+        figuresize (int, optional): The size of the figure. Defaults to 20.
+        cmap (str, optional): The colormap to be used. Defaults to 'inferno'.
+        threshold (int, optional): The threshold for the number of unique intensity values. Defaults to 1000.
+
+    Returns:
+        None
+    """
+    #start = time.time()
+    dim = stack.shape
+    
+    def plot_single_array(array, ax, title, chosen_cmap):
+        unique_values = np.unique(array)
+        num_unique_values = len(unique_values)
+        
+        if num_unique_values <= threshold:
+            chosen_cmap = _generate_mask_random_cmap(array)
+            title = f'{title}, {num_unique_values} (obj.)'
+        
+        ax.imshow(array, cmap=chosen_cmap)
+        ax.set_title(title, size=18)
+        ax.axis('off')
+
+    if len(dim) == 2:
+        fig, ax = plt.subplots(1, 1, figsize=(figuresize, figuresize))
+        plot_single_array(stack, ax, 'Channel one', plt.get_cmap(cmap))
+        fig.tight_layout()
+        plt.show()
+    elif len(dim) > 2:
+        num_channels = dim[2]
+        fig, axs = plt.subplots(1, num_channels, figsize=(figuresize, figuresize))
+        for channel in range(num_channels):
+            plot_single_array(stack[:, :, channel], axs[channel], f'C. {channel}', plt.get_cmap(cmap))
+        fig.tight_layout()
+        plt.show()
+    
+    #stop = time.time()
+    #duration = stop - start
+    #print('plot_cropped_arrays', duration)
+    print(f'{filename}')
+
+def _plot_cropped_arrays_v1(stack, figuresize=20, cmap='inferno'):
     """
     Plot cropped arrays.
 
@@ -1192,56 +1263,6 @@ def _plot_plates(df, variable, grouping, min_max, cmap, min_count=0):
     plt.show()
     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):
-#    paths = []
-#    for file in os.listdir(src):
-#        if file.endswith('.tif') or file.endswith('.tiff'):
-#            path = os.path.join(src, file)
-#            paths.append(path)
-#    paths = random.sample(paths, nr)
-#    for path in paths:
-#        print(f'Image path:{path}')
-#        img = cv2.imread(path, cv2.IMREAD_UNCHANGED)
-#        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))
-#                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))
-#            ax.set_title('Channel 0', size=24)
-#            ax.axis('off')
-#        fig.tight_layout()
-#        plt.show()
-#    return
-
 def print_mask_and_flows(stack, mask, flows, overlay=False):
     fig, axs = plt.subplots(1, 3, figsize=(30, 10))  # Adjust subplot layout
     
@@ -1434,3 +1455,18 @@ def plot_comparison_results(comparison_results):
     plt.tight_layout()
     plt.show()
     return fig
+
+def plot_object_outlines(src, objects=['nucleus','cell','pathogen'], channels=[0,1,2], max_nr=10):
+    
+    for object_, channel in zip(objects, channels):
+        folders = [os.path.join(src, 'norm_channel_stack', f'{object_}_mask_stack'),
+                   os.path.join(src,f'{channel+1}')]
+        print(folders)
+        plot_images_and_arrays(folders,
+                               lower_percentile=2,
+                               upper_percentile=99.5,
+                               threshold=1000,
+                               extensions=['.npy', '.tif', '.tiff', '.png'],
+                               overlay=True,
+                               max_nr=10,
+                               randomize=True)