small-fish-gui 2.0.1__py3-none-any.whl → 2.0.3__py3-none-any.whl

small_fish_gui/pipeline/detection.py

@@ -1,18 +1,18 @@
 """
-Contains code to handle detection as well as bigfish wrappers related to spot detection.
+Submodule to handle detection as well as bigfish wrappers related to spot detection.
 """
 from ..hints import pipeline_parameters
 
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
 
-from ..gui.napari_visualiser import correct_spots, threshold_selection
+from ..gui.napari_visualiser import correct_spots, interactive_detection
 from ..gui import add_default_loading
 from ..gui import detection_parameters_promt
 
 from ..interface import get_voxel_size
 from ..utils import compute_anisotropy_coef
-from ._signaltonoise import compute_snr_spots
+from ._bigfish_wrapers import compute_snr_spots, _apply_log_filter, _local_maxima_mask
 
 from magicgui import magicgui
 
@@ -20,7 +20,7 @@ from types import GeneratorType
 from napari.types import LayerDataTuple
 
 import numpy as np
-from numpy import NaN
+from numpy import nan
 import pandas as pd
 import FreeSimpleGUI as sg
 import bigfish.detection as detection
@@ -31,8 +31,6 @@ from bigfish.detection.spot_detection import get_object_radius_pixel
 from skimage.measure import regionprops
 from scipy.ndimage import binary_dilation
 
-
-
 def compute_auto_threshold(images, voxel_size=None, spot_radius=None, log_kernel_size=None, minimum_distance=None, im_number= 15, crop_zstack= None) :
     """
     Compute bigfish auto threshold efficiently for list of images. In case on large set of images user can set im_number to only consider a random subset of image for threshold computation.
@@ -214,8 +212,13 @@ def initiate_detection(user_parameters : pipeline_parameters, map_, shape) :
     
     #Attempt to read voxel size from metadata
     voxel_size = get_voxel_size(user_parameters['image_path'])
-    if voxel_size is None or not user_parameters.get('voxel_size') is None:
-        pass
+    if voxel_size is None  :
+        if not user_parameters.get('voxel_size') is None:
+            pass
+        else :
+            detection_parameters['voxel_size_z'] = None
+            detection_parameters['voxel_size_y'] = None
+            detection_parameters['voxel_size_x'] = None
     else :
         detection_parameters['voxel_size'] = [round(v) if isinstance(v, (float,int)) else None for v in voxel_size]
         detection_parameters['voxel_size_z'] = detection_parameters['voxel_size'][0] if isinstance(detection_parameters['voxel_size'][0], (float,int)) else None
@@ -223,8 +226,8 @@ def initiate_detection(user_parameters : pipeline_parameters, map_, shape) :
         detection_parameters['voxel_size_x'] = detection_parameters['voxel_size'][2] if isinstance(detection_parameters['voxel_size'][2], (float,int)) else None
 
     #Setting default spot size to 1.5 voxel
-    if detection_parameters.get('spot_size') is None :
-        detection_parameters['spot_size_z'] = round(detection_parameters['voxel_size_z']*1.5) if isinstance(detection_parameters['voxel_size_z'], (float,int)) else None
+    if detection_parameters.get('spot_size') is None and not detection_parameters.get('voxel_size') is None:
+        detection_parameters['spot_size_z'] = round(detection_parameters['voxel_size_z']*1.5) if isinstance(detection_parameters.get('voxel_size_z'), (float,int)) else None
         detection_parameters['spot_size_y'] = round(detection_parameters['voxel_size_y']*1.5) if isinstance(detection_parameters['voxel_size_y'],(float,int)) else None
         detection_parameters['spot_size_x'] = round(detection_parameters['voxel_size_x']*1.5) if isinstance(detection_parameters['voxel_size_x'],(float,int)) else None
 
@@ -258,7 +261,7 @@ def initiate_detection(user_parameters : pipeline_parameters, map_, shape) :
     return user_parameters
 
 @add_default_loading
-def _launch_detection(image, image_input_values: dict) :
+def detect_spots(image, image_input_values: dict) :
 
     """
     Performs spots detection
@@ -267,7 +270,7 @@ def _launch_detection(image, image_input_values: dict) :
     #Extract parameters
     voxel_size = image_input_values['voxel_size']
     threshold = image_input_values.get('threshold')
-    threshold_penalty = image_input_values.setdefault('threshold penalty', 1)
+    threshold_penalty = image_input_values.setdefault('threshold_penalty', 1)
     spot_size = image_input_values.get('spot_size')
     log_kernel_size = image_input_values.get('log_kernel_size')
     minimum_distance = image_input_values.get('minimum_distance')
@@ -275,7 +278,7 @@ def _launch_detection(image, image_input_values: dict) :
     
     if type(threshold) == type(None) :     
         threshold = threshold_penalty * compute_auto_threshold(image, voxel_size=voxel_size, spot_radius=spot_size, log_kernel_size=log_kernel_size, minimum_distance=minimum_distance)
-        threshold = max(threshold,15) # Force threshold to be at least 15 to match napari widget and to not have too many spots for weak configs
+        threshold = max(threshold,1)
 
     filtered_image = _apply_log_filter(
         image=image,
@@ -291,29 +294,11 @@ def _launch_detection(image, image_input_values: dict) :
         minimum_distance=minimum_distance
     )
 
-    if threshold_user_selection :
-
-        threshold_slider = _create_threshold_slider(
-            logfiltered_image=filtered_image,
-            local_maxima=local_maxima,
-            default=threshold,
-            min_value=filtered_image[local_maxima].min(),
-            max_value=filtered_image[local_maxima].max(),
-            voxel_size=voxel_size
-        )
-
-        spots, threshold = threshold_selection(
-            image=image,
-            filtered_image=filtered_image,
-            threshold_slider=threshold_slider,
-            voxel_size=voxel_size
-        )
-    else :
-        spots = detection.spots_thresholding(
-            image=filtered_image,
-            mask_local_max=local_maxima,
-            threshold=threshold
-        )[0]
+    spots = detection.spots_thresholding(
+        image=filtered_image,
+        mask_local_max=local_maxima,
+        threshold=threshold
+    )[0]
         
     return spots, threshold
 
@@ -340,7 +325,16 @@ def launch_dense_region_deconvolution(image, spots, image_input_values: dict,) :
     deconvolution_kernel = image_input_values.get('deconvolution_kernel')
     dim = image_input_values['dim']
         
-    spots, dense_regions, ref_spot = detection.decompose_dense(image=image, spots=spots, voxel_size=voxel_size, spot_radius=spot_size, kernel_size=deconvolution_kernel, alpha=alpha, beta=beta, gamma=gamma)
+    spots, dense_regions, ref_spot = detection.decompose_dense(
+        image=image, 
+        spots=spots, 
+        voxel_size=voxel_size, 
+        spot_radius=spot_size, 
+        kernel_size=deconvolution_kernel, 
+        alpha=alpha, 
+        beta=beta, 
+        gamma=gamma
+        )
     del dense_regions, ref_spot
 
     return spots
@@ -356,7 +350,7 @@ def launch_post_detection(image, spots, image_input_values: dict,) :
     fov_res['spot_number'] = len(spots)
     snr_res = compute_snr_spots(image, spots, voxel_size, spot_size)
     if len(spots) == 0 :
-        fov_res['spotsSignal_median'], fov_res['spotsSignal_mean'], fov_res['spotsSignal_std'] = np.NaN, np.NaN, np.NaN
+        fov_res['spotsSignal_median'], fov_res['spotsSignal_mean'], fov_res['spotsSignal_std'] = np.nan, np.nan, np.nan
     else :
         if dim == 3 :
             Z,Y,X = list(zip(*spots))
@@ -381,9 +375,9 @@ def _compute_cell_snr(image: np.ndarray, bbox, spots, voxel_size, spot_size) :
 
     if len(spots) == 0 :
         res = {
-           'snr_mean' : np.NaN,
-           'snr_median' : np.NaN,
-           'snr_std' : np.NaN,
+           'snr_mean' : np.nan,
+           'snr_median' : np.nan,
+           'snr_std' : np.nan,
         }
 
         return res
@@ -541,8 +535,8 @@ def launch_cell_extraction(
                 else : raise AssertionError("Impossible number of dim for foci : ", len(foci_index))
                 foci_in_nuc_number = nuc_mask[tuple(foci_index)].astype(bool).sum()
         else :
-            foci_number = np.NaN
-            foci_in_nuc_number = np.NaN
+            foci_number = np.nan
+            foci_in_nuc_number = np.nan
 
         #Signal to noise
         snr_dict = _compute_cell_snr(
@@ -628,11 +622,34 @@ def launch_detection(
     do_dense_region_deconvolution = user_parameters['do_dense_regions_deconvolution']
     do_clustering = user_parameters['do_cluster_computation']
 
-    spots, threshold  = _launch_detection(image, user_parameters, hide_loading = hide_loading)
-        
-    if do_dense_region_deconvolution : 
-        spots = launch_dense_region_deconvolution(image, spots, user_parameters, hide_loading = hide_loading)
-        
+    if user_parameters['show_interactive_threshold_selector'] :
+        spots, image, updated_parameters = interactive_detection(
+            image=image,
+            voxel_size=user_parameters['voxel_size'],
+            interactive_threshold=True,
+            dense_region_deconvolution=user_parameters['do_dense_regions_deconvolution'],
+            do_background_removal= False,
+            default_threshold = user_parameters['threshold'],
+            default_kernel_size = user_parameters['log_kernel_size'],
+            default_min_distance = user_parameters['minimum_distance'],
+            default_spot_radius = user_parameters['spot_size'],
+            deconvolution_spot_radius = user_parameters['spot_size'],
+            deconvolution_kernel_size = user_parameters['log_kernel_size'],
+            alpha = user_parameters['alpha'],
+            beta = user_parameters['beta'],
+            gamma = user_parameters['gamma'],
+            other_image = other_image if user_parameters['is_multichannel'] else None,
+        )
+
+        user_parameters.update(updated_parameters)
+
+    else :
+        spots, threshold  = detect_spots(image, user_parameters, hide_loading = hide_loading)
+        user_parameters['threshold'] = threshold
+            
+        if do_dense_region_deconvolution : 
+            spots = launch_dense_region_deconvolution(image, spots, user_parameters, hide_loading = hide_loading)
+            
     if do_clustering : 
         clusters, clustered_spots = launch_clustering(spots, user_parameters, hide_loading = hide_loading) #012 are coordinates #3 is number of spots per cluster, #4 is cluster index
         spots, spots_cluster_id = clustered_spots[:,:-1], clustered_spots[:,-1]
@@ -641,8 +658,6 @@ def launch_detection(
         clusters = None
         spots_cluster_id = None
 
-    user_parameters['threshold'] = threshold
-
     if user_parameters['show_napari_corrector'] :
 
         spots, clusters, new_cluster_radius, new_min_spot_number = correct_spots(
@@ -671,7 +686,7 @@ def launch_detection(
     post_detection_dict = launch_post_detection(image, spots, user_parameters, hide_loading = hide_loading)
     fov_result.update(post_detection_dict)
     
-    return user_parameters, fov_result, spots, clusters, spots_cluster_id
+    return user_parameters, fov_result, spots, clusters, spots_cluster_id, image
             
 
 def launch_features_computation(
@@ -720,7 +735,7 @@ def launch_features_computation(
     if type(cell_label) != type(None) and type(nucleus_label) != type(None):
         frame_results['cell_number'] = len(cell_result_dframe) 
     else : 
-        frame_results['cell_number'] = NaN
+        frame_results['cell_number'] = nan
     frame_results['spots'] = spots
     frame_results['clusters'] = clusters
     frame_results['spots_cluster_id'] = spots_cluster_id
@@ -742,9 +757,9 @@ def launch_features_computation(
             cell_result_dframe['total_rna_number'] = cell_result_dframe['nb_rna_in_nuc'] + cell_result_dframe['nb_rna_out_nuc']
         else : # This can happen when segmentation is performed and detects cells but they are on fov edges and thus removed by big-fish.
             print("\033[1;31m All segmented cells where skipped because they are found on fov edges (incomplete cells), if you want to analyse this image check segmentation.\033[00m")
-            cell_result_dframe['nb_rna_in_nuc'] = np.NaN
-            cell_result_dframe['nb_rna_out_nuc'] = np.NaN
-            cell_result_dframe['total_rna_number'] = np.NaN
+            cell_result_dframe['nb_rna_in_nuc'] = np.nan
+            cell_result_dframe['nb_rna_out_nuc'] = np.nan
+            cell_result_dframe['total_rna_number'] = np.nan
 
         
     return frame_results, cell_result_dframe
@@ -763,7 +778,7 @@ def _compute_clustered_spots_dataframe(clustered_spots) :
     })
 
     null_idx = df[df['cluster_id'] == -1].index
-    df.loc[null_idx, 'cluster_id'] = np.NaN
+    df.loc[null_idx, 'cluster_id'] = np.nan
 
     return df
 
@@ -802,91 +817,6 @@ def get_nucleus_signal(image, other_images, user_parameters) :
     else :
         return image
 
-def _create_threshold_slider(
-        logfiltered_image : np.ndarray,
-        local_maxima : np.ndarray,
-        default : int,
-        min_value : int,
-        max_value : int,
-        voxel_size
-) :
-    
-    if isinstance(default, float) : default = round(default)
-    min_value = max(min_value,15) #Security to avoid user put too low threshold and crashes Napari if out of memory.
-
-    @magicgui(
-        threshold={'widget_type' : 'Slider', 'value' : default, 'min' : min_value, 'max' : max_value, 'tracking' : True,},
-        auto_call=False,
-        call_button= "Apply"
-    )
-    def threshold_slider(threshold: int) -> LayerDataTuple:
-        spots = detection.spots_thresholding(
-            image=logfiltered_image,
-            mask_local_max=local_maxima,
-            threshold=threshold
-        )[0]
-
-        scale = compute_anisotropy_coef(voxel_size)
-
-        layer_args = {
-            'size': 5, 
-            'scale' : scale, 
-            'face_color' : 'transparent', 
-            'border_color' : 'red', 
-            'symbol' : 'disc', 
-            'opacity' : 0.7, 
-            'blending' : 'translucent', 
-            'name': 'single spots',
-            'features' : {'threshold' : threshold},
-            'visible' : True,
-            }
-        return (spots, layer_args , 'points')
-    return threshold_slider
-
-def _apply_log_filter(
-        image: np.ndarray,
-        voxel_size : tuple,
-        spot_radius : tuple,
-        log_kernel_size,
-
-) :
-    """
-    Apply spot detection steps until local maxima step (just before final threshold).
-    Return filtered image.
-    """
-    
-    ndim = image.ndim
-
-    if type(log_kernel_size) == type(None) :
-        log_kernel_size = get_object_radius_pixel(
-                voxel_size_nm=voxel_size,
-                object_radius_nm=spot_radius,
-                ndim=ndim)
-    
-    
-    image_filtered = stack.log_filter(image, log_kernel_size)
-    
-    return image_filtered
-    
-def _local_maxima_mask(
-    image_filtered: np.ndarray,
-    voxel_size : tuple,
-    spot_radius : tuple,
-    minimum_distance
-
-    ) : 
-
-    ndim = image_filtered.ndim
-
-    if type(minimum_distance) == type(None) :
-        minimum_distance = get_object_radius_pixel(
-            voxel_size_nm=voxel_size,
-            object_radius_nm=spot_radius,
-            ndim=ndim)
-    mask_local_max = detection.local_maximum_detection(image_filtered, minimum_distance)
-    
-    return mask_local_max.astype(bool)
-
 def output_spot_tiffvisual(channel,spots_list, path_output, dot_size = 3, rescale = True):
     
     """