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

spacr/measure.py

@@ -626,7 +626,13 @@ def _measure_crop_core(index, time_ls, file, settings):
             _create_database(source_folder+'/measurements/measurements.db')    
 
         if settings['plot_filtration']:
-           _plot_cropped_arrays(data)
+            
+            if len(data.shape) == 3:
+                figuresize = data.shape[2]*10
+            else:
+                figuresize = 10
+            print('')
+            _plot_cropped_arrays(data, file, figuresize)
         
         channel_arrays = data[:, :, settings['channels']].astype(data_type)        
         if settings['cell_mask_dim'] is not None:
@@ -652,7 +658,6 @@ def _measure_crop_core(index, time_ls, file, settings):
                     data[:, :, settings['nucleus_mask_dim']] = nucleus_mask
                     save_folder = settings['input_folder']
                     np.save(os.path.join(save_folder, file), data)
-                
         else:
             nucleus_mask = np.zeros_like(data[:, :, 0])
 
@@ -703,7 +708,8 @@ def _measure_crop_core(index, time_ls, file, settings):
             data = np.concatenate((data, cytoplasm_mask[:, :, np.newaxis]), axis=2)
 
         if settings['plot_filtration']:
-            _plot_cropped_arrays(data)
+            _plot_cropped_arrays(data, file, figuresize)
+            #_plot_cropped_arrays(data)
 
         if settings['save_measurements']:
 
@@ -792,23 +798,25 @@ def _measure_crop_core(index, time_ls, file, settings):
                         if settings['save_png']:
                             fldr_type = f"{crop_mode}_png/"
                             png_folder = os.path.join(fldr,fldr_type)
-
                             img_path = os.path.join(png_folder, img_name)
-                            
+                            img_paths.append(img_path)
+
                             png_channels = data[:, :, settings['png_dims']].astype(data_type)
 
                             if settings['normalize_by'] == 'fov':
-                                percentiles_list = _get_percentiles(png_channels, settings['normalize'][0],q2=settings['normalize'][1])
+                                if not settings['normalize'] is False:
+                                    percentile_list = _get_percentiles(png_channels, settings['normalize'][0], settings['normalize'][1])
 
                             png_channels = _crop_center(png_channels, region, new_width=width, new_height=height)
-
                             if isinstance(settings['normalize'], list):
                                 if settings['normalize_by'] == 'png':
-                                    png_channels = normalize_to_dtype(png_channels, q1=settings['normalize'][0],q2=settings['normalize'][1])
+                                    png_channels = normalize_to_dtype(png_channels, settings['normalize'][0], settings['normalize'][1])
 
                                 if settings['normalize_by'] == 'fov':
-                                    png_channels = normalize_to_dtype(png_channels, q1=settings['normalize'][0],q2=settings['normalize'][1], percentiles=percentiles_list)
-                                    
+                                    png_channels = normalize_to_dtype(png_channels, settings['normalize'][0], settings['normalize'][1], percentile_list=percentile_list)
+                            else:
+                                png_channels = normalize_to_dtype(png_channels, 0, 100)
+
                             os.makedirs(png_folder, exist_ok=True)
 
                             if png_channels.shape[2] == 2:
@@ -818,8 +826,6 @@ def _measure_crop_core(index, time_ls, file, settings):
                             else:
                                 cv2.imwrite(img_path, png_channels)
 
-                            img_paths.append(img_path)
-
                             if len(img_paths) == len(objects_in_image):
 
                                 png_df = pd.DataFrame(img_paths, columns=['png_path'])
@@ -858,7 +864,11 @@ def _measure_crop_core(index, time_ls, file, settings):
                                     traceback.print_exc()
 
                             if settings['plot']:
-                                _plot_cropped_arrays(png_channels)
+                                if len(png_channels.shape) == 3:
+                                    figuresize = png_channels.shape[2]*10
+                                else:
+                                    figuresize = 10
+                                _plot_cropped_arrays(png_channels, img_name, figuresize, threshold=1)
 
                         if settings['save_arrays']:
                             row_idx, col_idx = np.where(region)
@@ -867,12 +877,20 @@ def _measure_crop_core(index, time_ls, file, settings):
                             os.makedirs(array_folder, exist_ok=True)
                             np.save(os.path.join(array_folder, img_name), region_array)
                             if settings['plot']:
-                                _plot_cropped_arrays(region_array)
+                                if len(png_channels.shape) == 3:
+                                    figuresize = png_channels.shape[2]*10
+                                else:
+                                    figuresize = 10
+                                _plot_cropped_arrays(png_channels, img_name, figuresize, threshold=1)
 
                         if not settings['save_arrays'] and not settings['save_png'] and settings['plot']:
                             row_idx, col_idx = np.where(region)
                             region_array = data[row_idx.min():row_idx.max()+1, col_idx.min():col_idx.max()+1, :]
-                            _plot_cropped_arrays(region_array)
+                            if len(png_channels.shape) == 3:
+                                figuresize = png_channels.shape[2]*10
+                            else:
+                                figuresize = 10
+                            _plot_cropped_arrays(png_channels, file, figuresize, threshold=1)
 
         cells = np.unique(cell_mask)
     except Exception as e:
@@ -899,47 +917,17 @@ def measure_crop(settings):
         None
     """
 
-    if settings.get('test_mode', False):
-        if not os.basename(settings['src']) == 'test':
-            src = os.path.join(src, 'test')
-            settings['src'] = src
-            print(f'Changed source folder to {src} for test mode')
-        else:
-            print(f'Test mode enabled, using source folder {settings["src"]}')
-    
     from .io import _save_settings_to_db
     from .timelapse import _timelapse_masks_to_gif, _scmovie
     from .plot import _save_scimg_plot
-    from .utils import _list_endpoint_subdirectories, _generate_representative_images
-    
-    #general settings
-    settings['merge_edge_pathogen_cells'] = True
-    settings['radial_dist'] = True
-    settings['calculate_correlation'] = True
-    settings['manders_thresholds'] = [15,85,95]
-    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
+    from .utils import _list_endpoint_subdirectories, _generate_representative_images, get_measure_crop_settings, measure_test_mode
+
+    settings = get_measure_crop_settings(settings)
+    settings = measure_test_mode(settings)
+
+    if not os.path.exists(settings['input_folder']):
+        print(f"Error: {settings['input_folder']} does not exist")
+        return
     
     if settings['cell_mask_dim'] is None:
         settings['include_uninfected'] = True
@@ -951,8 +939,6 @@ def measure_crop(settings):
         settings['cytoplasm'] = True
     else:
         settings['cytoplasm'] = False
-
-    #settings = {**settings, **annotation_settings, **advanced_settings}
     
     dirname = os.path.dirname(settings['input_folder'])
     settings_df = pd.DataFrame(list(settings.items()), columns=['Key', 'Value'])
@@ -970,10 +956,11 @@ def measure_crop(settings):
     if isinstance(settings['normalize'], bool) and settings['normalize']:
         print(f'WARNING: to notmalize single object pngs set normalize to a list of 2 integers, e.g. [1,99] (lower and upper percentiles)')
         return
-
-    if settings['normalize_by'] not in ['png', 'fov']:
-        print("Warning: normalize_by should be either 'png' to notmalize each png to its own percentiles or 'fov' to normalize each png to the fov percentiles ")
-        return
+    
+    if isinstance(settings['normalize'], list) or isinstance(settings['normalize'], bool) and settings['normalize']:
+        if settings['normalize_by'] not in ['png', 'fov']:
+            print("Warning: normalize_by should be either 'png' to notmalize each png to its own percentiles or 'fov' to normalize each png to the fov percentiles ")
+            return
 
     if not all(isinstance(settings[key], int) or settings[key] is None for key in int_setting_keys):
         print(f"WARNING: {int_setting_keys} must all be integers")

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)