small-fish-gui 1.3.5__py3-none-any.whl → 1.5.0__py3-none-any.whl

small_fish_gui/pipeline/_preprocess.py

@@ -67,9 +67,9 @@ def map_channels(user_parameters) :
     multichannel = user_parameters['multichannel']
 
     try : 
-        map = _auto_map_channels(image, is_3D_stack, is_time_stack, multichannel)
+        map = _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image=image)
     except MappingError as e :
-        sg.popup("Automatic dimension mapping went wrong. Please indicate manually dimensions positions in the array.")
+        sg.popup("Automatic dimension mapping went wrong. Please indicate dimensions positions in the array.")
         map = _ask_channel_map(image.shape, is_3D_stack, is_time_stack, multichannel, preset_map= e.get_map())
 
     else :
@@ -77,8 +77,9 @@ def map_channels(user_parameters) :
 
     return map
 
-def _auto_map_channels(image: np.ndarray, is_3D_stack, is_time_stack, multichannel) :
-    shape = image.shape
+def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarray=None, shape=None) :
+    if type(shape) == type(None) :
+        shape = image.shape
     reducing_list = list(shape)
 
     #Set the biggest dimension to y
@@ -124,14 +125,16 @@ def _auto_map_channels(image: np.ndarray, is_3D_stack, is_time_stack, multichann
 def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map: dict= {}) :
     while True :
         relaunch = False
+        save_preset = preset_map.copy()
         x = preset_map.setdefault('x',0)
         y = preset_map.setdefault('y',0)
         z = preset_map.setdefault('z',0)
         c = preset_map.setdefault('c',0)
         t = preset_map.setdefault('t',0)
 
+
         layout = [
-            add_header("Dimensions mapping", [sg.Text("Image shape : {0}".format(shape))])
+            add_header("Dimensions mapping") + [sg.Text("Image shape : {0}".format(shape))]
         ]
         layout += [parameters_layout(['x','y'], default_values=[x,y])]
         if is_3D_stack : layout += [parameters_layout(['z'], default_values=[z])]
@@ -139,7 +142,7 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
         if is_time_stack : layout += [parameters_layout(['t'], default_values=[t])]
 
         event, preset_map = prompt_with_help(layout,help= 'mapping', add_scrollbar=False)
-        if event == 'Cancel' : quit()
+        if event == 'Cancel' : return save_preset
 
         #Check integrity
         channels_values = np.array(list(preset_map.values()), dtype= int)
@@ -156,24 +159,26 @@ def _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map
     return preset_map
 
 def _show_mapping(shape, map, is_3D_stack, is_time_stack, multichannel) :
-    layout = [
-        [sg.Text("Image shape : {0}".format(shape))],
-        [sg.Text('Dimensions mapping was set to :')],
-        [sg.Text('x : {0} \ny : {1} \nz : {2} \nc : {3} \nt : {4}'.format(
-            map['x'], map['y'], map.get('z'), map.get("c"), map.get('t')
-        ))],
-        [sg.Button('Change mapping')]
-    ]
-
-    event, values = prompt_with_help(layout, help='mapping', add_scrollbar=False)
-
-    if event == 'Ok' :
-        return map
-    elif event == 'Change mapping' or event == 'Cancel':
-        map = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map)
-    else : raise AssertionError('Unforseen event')
+    while True : 
+        layout = [
+            [sg.Text("Image shape : {0}".format(shape))],
+            [sg.Text('Dimensions mapping was set to :')],
+            [sg.Text('x : {0} \ny : {1} \nz : {2} \nc : {3} \nt : {4}'.format(
+                map['x'], map['y'], map.get('z'), map.get("c"), map.get('t')
+            ))],
+            [sg.Button('Change mapping')]
+        ]
+
+        event, values = prompt_with_help(layout, help='mapping', add_scrollbar=False)
+
+        if event == 'Ok' :
+            return map
+        elif event == 'Change mapping':
+            map = _ask_channel_map(shape, is_3D_stack, is_time_stack, multichannel, preset_map=map)
+        elif event == 'Cancel' : 
+            return None
+        else : raise AssertionError('Unforseen event')
 
-    return map
 
 def convert_parameters_types(values:dict) :
     """
@@ -194,8 +199,8 @@ def convert_parameters_types(values:dict) :
         else : values[tuple_parameter] = tuple_values
 
     #Parameters
-    int_list = ['threshold', 'channel_to_compute', 'min number of spots', 'cluster size','nucleus channel signal']
-    float_list = ['time_step', 'alpha', 'beta', 'gamma', 'threshold penalty']
+    int_list = ['threshold', 'channel_to_compute', 'channel to compute', 'min number of spots', 'cluster size','nucleus channel signal']
+    float_list = ['alpha', 'beta', 'gamma', 'threshold penalty']
 
     for parameter in int_list :
         try :
@@ -213,7 +218,15 @@ def convert_parameters_types(values:dict) :
 
     return values
 
-def check_integrity(values: dict, do_dense_region_deconvolution, multichannel,segmentation_done, map, shape):
+def check_integrity(
+        values: dict, 
+        do_dense_region_deconvolution,
+        do_clustering, 
+        multichannel,
+        segmentation_done, 
+        map, 
+        shape
+        ):
     """
     Checks that parameters given in input by user are fit to be used for bigfish detection.
     """
@@ -233,10 +246,22 @@ def check_integrity(values: dict, do_dense_region_deconvolution, multichannel,se
             _warning_popup('No gamma found; image will not be denoised before deconvolution.')
             values['gamma'] = 0
 
+        if values['alpha'] > 1 or values['alpha'] < 0 :
+            raise ParameterInputError("alpha must be set between 0 and 1.")
+
+    if do_clustering :
+        if not isinstance(values['min number of spots'], (int)) :
+            raise ParameterInputError("Incorrect min spot number parameter.")
+        if not isinstance(values['cluster size'], (int)) :
+            raise ParameterInputError("Incorrect cluster size parameter.")
+
     #channel
     if multichannel :
         ch_len = shape[int(map['c'])]
-        if segmentation_done :
+
+        if type(segmentation_done) == type(None) :
+            pass
+        elif segmentation_done :
             try : nuc_signal_ch = int(values['nucleus channel signal'])
             except Exception :
                 raise ParameterInputError("Incorrect channel for nucleus signal measure.")
@@ -259,7 +284,6 @@ def check_integrity(values: dict, do_dense_region_deconvolution, multichannel,se
 
     return values
 
-
 def reorder_shape(shape, map) :
     x = [int(map['x']),]
     y = [int(map['y']),]
@@ -275,6 +299,40 @@ def reorder_shape(shape, map) :
 
     return new_shape
 
+def _check_segmentation_parameters(
+        user_parameters,
+        shape,
+        is_multichannel,
+) :
+
+    available_channels = list(range(len(shape)))
+    do_only_nuc = user_parameters['Segment only nuclei']
+    cyto_model_name = user_parameters['cyto_model_name']
+    cyto_size = user_parameters['cytoplasm diameter']
+    cytoplasm_channel = user_parameters['cytoplasm channel']
+    nucleus_model_name = user_parameters['nucleus_model_name']
+    nucleus_size = user_parameters['nucleus diameter']
+    nucleus_channel = user_parameters['nucleus channel']
+   
+
+    if type(cyto_model_name) != str  and not do_only_nuc:
+        raise ParameterInputError('Invalid cytoplasm model name.')
+    if cytoplasm_channel not in available_channels and not do_only_nuc and is_multichannel:
+        raise ParameterInputError('For given input image please select channel in {0}\ncytoplasm channel : {1}'.format(available_channels, cytoplasm_channel))
+
+    if type(cyto_size) not in [int, float] and not do_only_nuc:
+        raise ParameterInputError("Incorrect cytoplasm size.")
+
+    if type(nucleus_model_name) != str :
+        raise ParameterInputError('Invalid nucleus model name.')
+    
+    if nucleus_channel not in available_channels and is_multichannel:
+        raise ParameterInputError('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
+    
+    if type(nucleus_size) not in [int, float] :
+        raise ParameterInputError("Incorrect nucleus size.")
+
+
 def clean_unused_parameters_cache(user_parameters: dict) :
     """
     Clean unused parameters that were set to None in previous run.

small_fish_gui/pipeline/_segmentation.py

@@ -6,14 +6,19 @@ from cellpose.core import use_gpu
 from skimage.measure import label
 from ..gui.layout import _segmentation_layout
 from ..gui import prompt, prompt_with_help, ask_cancel_segmentation
+from ..interface import open_image
 from ._napari_wrapper import show_segmentation as napari_show_segmentation
+from .utils import from_label_get_centeroidscoords
+from matplotlib.colors import ListedColormap
 
+import matplotlib as mpl
 import cellpose.models as models
 import numpy as np
 import bigfish.multistack as multistack
 import bigfish.stack as stack
 import bigfish.plot as plot
 import PySimpleGUI as sg
+import matplotlib.pyplot as plt
 import os
 
 def launch_segmentation(image: np.ndarray, user_parameters: dict) :
@@ -38,6 +43,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
         nucleus_model_name = user_parameters.setdefault('nucleus_model_name', 'nuclei')
         nucleus_size = user_parameters.setdefault('nucleus diameter', 130)
         nucleus_channel = user_parameters.setdefault('nucleus channel', 0)
+        other_nucleus_image = user_parameters.setdefault('other_nucleus_image',None)
         path = os.getcwd()
         show_segmentation = user_parameters.setdefault('show segmentation', False)
         segment_only_nuclei = user_parameters.setdefault('Segment only nuclei', False)
@@ -56,6 +62,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 nucleus_channel_preset= nucleus_channel,
                 cyto_diameter_preset= cyto_size,
                 nucleus_diameter_preset= nucleus_size,
+                other_nucleus_image_preset=other_nucleus_image,
                 saving_path_preset= path,
                 show_segmentation_preset=show_segmentation,
                 segment_only_nuclei_preset=segment_only_nuclei,
@@ -81,10 +88,11 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
             nucleus_model_name = values['nucleus_model_name']
             nucleus_size = values['nucleus diameter']
             nucleus_channel = values['nucleus channel']
+            other_nucleus_image = values['other_nucleus_image']
             path = values['saving path'] if values['saving path'] != '' else None
             show_segmentation = values['show segmentation']
             filename = values['filename'] if type(path) != type(None) else None
-            channels = [cytoplasm_channel, nucleus_channel]
+            channels = [cytoplasm_channel, nucleus_channel] if multichannel else [...,...]
 
             relaunch= False
             #Checking integrity of parameters
@@ -92,10 +100,13 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 sg.popup('Invalid cytoplasm model name.')
                 values['cyto_model_name'] = user_parameters.setdefault('cyto_model_name', 'cyto2')
                 relaunch= True
-            if cytoplasm_channel not in available_channels and not do_only_nuc:
-                sg.popup('For given input image please select channel in {0}\ncytoplasm channel : {1}'.format(available_channels, cytoplasm_channel))
-                relaunch= True
-                values['cytoplasm channel'] = user_parameters.setdefault('cytoplasm channel',0)
+            if multichannel :
+                if cytoplasm_channel not in available_channels and not do_only_nuc:
+                    sg.popup('For given input image please select channel in {0}\ncytoplasm channel : {1}'.format(available_channels, cytoplasm_channel))
+                    relaunch= True
+                    values['cytoplasm channel'] = user_parameters.setdefault('cytoplasm channel',0)
+            else :
+                cytoplasm_channel = ...
 
             if type(cyto_size) not in [int, float] and not do_only_nuc:
                 sg.popup("Incorrect cytoplasm size.")
@@ -106,14 +117,46 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 sg.popup('Invalid nucleus model name.')
                 values['nucleus_model_name'] = user_parameters.setdefault('nucleus_model_name', 'nuclei')
                 relaunch= True
-            if nucleus_channel not in available_channels :
-                sg.popup('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
-                relaunch= True
-                values['nucleus channel'] = user_parameters.setdefault('nucleus_channel', 0)
+            
+            if multichannel :
+                if nucleus_channel not in available_channels :
+                    sg.popup('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
+                    relaunch= True
+                    values['nucleus channel'] = user_parameters.setdefault('nucleus_channel', 0)
+            else : 
+                nucleus_channel = ...
+
             if type(nucleus_size) not in [int, float] :
                 sg.popup("Incorrect nucleus size.")
                 relaunch= True
                 values['nucleus diameter'] = user_parameters.setdefault('nucleus diameter', 30)
+            if other_nucleus_image != '' :
+                if not os.path.isfile(other_nucleus_image) :
+                    sg.popup("Nucleus image is not a file.")
+                    relaunch=True
+                    values['other_nucleus_image'] = None
+                else :
+                    try :
+                        nucleus_image = open_image(other_nucleus_image)
+                    except Exception as e :
+                        sg.popup("Could not open image.\n{0}".format(e))
+                        relaunch=True
+                        values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
+                    else :
+                        if nucleus_image.ndim != image.ndim - multichannel :
+                            sg.popup("Nucleus image dimension missmatched. Expected same dimension as cytoplasm_image for monochannel or same dimension as cytoplasm_image -1 for multichannel\ncytoplasm dimension : {0}, nucleus dimension : {1}".format(image.ndim, nucleus_image.ndim))
+                            nucleus_image = None
+                            relaunch=True
+                            values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
+                        
+                        elif nucleus_image.shape != image[cytoplasm_channel] :
+                            sg.popup("Nucleus image shape missmatched. Expected same shape as cytoplasm_image \ncytoplasm shape : {0}, nucleus shape : {1}".format(image[cytoplasm_channel].shape, nucleus_image.shape))
+                            nucleus_image = None
+                            relaunch=True
+                            values['other_nucleus_image'] = user_parameters.setdefault('other_nucleus_image', None)
+
+            else :
+                nucleus_image = None
 
             user_parameters.update(values)
             if not relaunch : break
@@ -149,14 +192,15 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 nucleus_model_name= nucleus_model_name,
                 nucleus_diameter= nucleus_size,
                 channels=channels,
-                do_only_nuc=do_only_nuc
+                do_only_nuc=do_only_nuc,
+                external_nucleus_image = nucleus_image,
                 )
 
         finally  : window.close()
 
         if show_segmentation :
             nucleus_label, cytoplasm_label = napari_show_segmentation(
-                nuc_image=image[nucleus_channel],
+                nuc_image=image[nucleus_channel] if type(nucleus_image) == type(None) else nucleus_image,
                 nuc_label= nucleus_label,
                 cyto_image=image[cytoplasm_channel],
                 cyto_label=cytoplasm_label,
@@ -175,16 +219,30 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 continue
 
         if type(output_path) != type(None) :
+            
+            #Get backgrounds
             nuc_proj = image[nucleus_channel]
             im_proj = image[cytoplasm_channel]
             if im_proj.ndim == 3 :
                 im_proj = stack.maximum_projection(im_proj)
             if nuc_proj.ndim == 3 :
                 nuc_proj = stack.maximum_projection(nuc_proj)
+            
+            #Call plots
             plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=False, path_output=nuc_path, title= "Nucleus segmentation (blue)", remove_frame=True,)
             if not do_only_nuc : 
                 plot.plot_segmentation_boundary(im_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
-        
+            plot_labels(
+                nucleus_label,
+                path_output=output_path + "_nucleus_label_map.png",
+                show=False
+                )
+            if not do_only_nuc : 
+                plot_labels(
+                    cytoplasm_label,
+                    path_output=output_path + "_cytoplasm_label_map.png",
+                    show=False
+                    )
 
 
 
@@ -204,7 +262,14 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
     user_parameters.update(values)
     return cytoplasm_label, nucleus_label, user_parameters
 
-def cell_segmentation(image, cyto_model_name, nucleus_model_name, channels, cyto_diameter, nucleus_diameter, do_only_nuc=False) :
+def cell_segmentation(
+        image, cyto_model_name, 
+        nucleus_model_name, 
+        channels, cyto_diameter, 
+        nucleus_diameter, 
+        do_only_nuc=False,
+        external_nucleus_image = None,
+        ) :
 
     nuc_channel = channels[1]
     if not do_only_nuc : 
@@ -214,10 +279,13 @@ def cell_segmentation(image, cyto_model_name, nucleus_model_name, channels, cyto
         else : 
             cyto = image[cyto_channel]
 
-    if image[nuc_channel].ndim >= 3 :
-        nuc = stack.maximum_projection(image[nuc_channel])
-    else : 
+    if type(external_nucleus_image) != type(None) :
+        nuc = external_nucleus_image
+    else :
         nuc = image[nuc_channel]
+
+    if nuc.ndim >= 3 :
+        nuc = stack.maximum_projection(nuc)
     
     if not do_only_nuc :
         image = np.zeros(shape=(2,) + cyto.shape)
@@ -351,3 +419,84 @@ def remove_disjoint(image):
         image_cleaned = image_cleaned.astype(bool)
 
     return image_cleaned
+
+def plot_segmentation(
+        cyto_image : np.ndarray, 
+        cyto_label : np.ndarray, 
+        nuc_image : np.ndarray, 
+        nuc_label : np.ndarray,
+        path :str, 
+        do_only_nuc=False
+        ) :
+
+    if nuc_image.ndim == 3 :
+        nuc_image = np.max(nuc_image,axis=0)
+    
+    plot.plot_segmentation_boundary(
+        image=nuc_image,
+        nuc_label= nuc_label,
+        boundary_size= 3,
+        contrast=True,
+        path_output=path + "_nuclei_segmentation.png",
+        show=False,
+    )
+
+
+    if not do_only_nuc :
+        if cyto_image.ndim == 3 :
+            cyto_image = np.max(cyto_image,axis=0)
+    
+        plot.plot_segmentation_boundary(
+            image=cyto_image,
+            cell_label= cyto_label,
+            nuc_label= nuc_label,
+            boundary_size= 3,
+            contrast=True,
+            path_output=path + "_cytoplasm_segmentation.png",
+            show=False,
+        )
+
+def plot_labels(labelled_image: np.ndarray, path_output:str = None, show= True, axis= False, close= True):
+    """
+    Plot a labelled image and indicate the label number at the center of each region.
+    """
+    stack.check_parameter(labelled_image = (np.ndarray, list), show = (bool))
+    if isinstance(labelled_image, np.ndarray) : 
+        stack.check_array(labelled_image, ndim= 2)
+        labelled_image = [labelled_image]
+    
+    #Setting a colormap with background to white so all cells can be visible
+    viridis = mpl.colormaps['viridis'].resampled(256)
+    newcolors = viridis(np.linspace(0, 1, 256))
+    white = np.array([1, 1, 1, 1])
+    newcolors[0, :] = white
+    newcmp = ListedColormap(newcolors)
+
+    plt.figure(figsize= (10,10))
+    rescaled_image = stack.rescale(np.array(labelled_image[0], dtype= np.int32), channel_to_stretch= 0)
+    rescaled_image[rescaled_image == 0] = -100
+    plot = plt.imshow(rescaled_image, cmap=newcmp)
+    plot.axes.get_xaxis().set_visible(axis)
+    plot.axes.get_yaxis().set_visible(axis)
+    plt.tight_layout()
+
+    for index in range(0, len(labelled_image)) :
+        centroid_dict = from_label_get_centeroidscoords(labelled_image[index])
+        labels = centroid_dict["label"]
+        Y = centroid_dict["centroid-0"]
+        X = centroid_dict["centroid-1"]
+        centroids = zip(Y,X)
+
+        for label in labels :
+            y,x = next(centroids)
+            y,x = round(y), round(x)
+            an = plt.annotate(str(label), [round(x), round(y)])
+
+    if not axis : plt.cla
+    if show : plt.show()
+    if path_output != None :
+        stack.check_parameter(path_output = (str))
+        plt.savefig(path_output)
+    if close : plt.close()
+
+    return plot

small_fish_gui/pipeline/actions.py

@@ -1,3 +1,7 @@
+"""
+This submodule groups all the possible actions of the user in the main windows. It is the start of each action the user can do.
+"""
+
 from ..gui.prompts import output_image_prompt, ask_detection_confirmation, ask_cancel_detection
 from ..interface.output import write_results
 from ._preprocess import map_channels, prepare_image_detection, reorder_shape, reorder_image_stack
@@ -25,6 +29,8 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
         user_parameters.update(new_parameters)
 
     map = map_channels(user_parameters)
+    if type(map) == type(None) : #User clicks Cancel 
+        return new_results_df, new_cell_results_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label, nucleus_label
     user_parameters['reordered_shape'] = reorder_shape(user_parameters['shape'], map)
 
 
@@ -89,7 +95,6 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
     if user_parameters['spots_extraction_folder'] != '' and type(user_parameters['spots_extraction_folder']) != type(None) :
         if user_parameters['spots_filename'] != '' and type(user_parameters['spots_filename']) != type(None) :
             if any((user_parameters['do_spots_excel'], user_parameters['do_spots_csv'], user_parameters['do_spots_feather'])) :
-                print((user_parameters['do_spots_excel'], user_parameters['do_spots_csv'], user_parameters['do_spots_feather']))
                 launch_spots_extraction(
                     acquisition_id=acquisition_id,
                     user_parameters=user_parameters,

small_fish_gui/pipeline/detection.py

@@ -1,7 +1,6 @@
 """
 Contains code to handle detection as well as bigfish wrappers related to spot detection.
 """
-
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
 from ._signaltonoise import compute_snr_spots
@@ -26,6 +25,7 @@ import bigfish.classification as classification
 from bigfish.detection.spot_detection import get_object_radius_pixel
 from types import GeneratorType
 from skimage.measure import regionprops
+from scipy.ndimage import binary_dilation
 
 
 def ask_input_parameters(ask_for_segmentation=True) :
@@ -278,11 +278,18 @@ def initiate_detection(user_parameters, segmentation_done, map, shape) :
             segmentation_done= segmentation_done,
             default_dict=user_parameters
             )
-        
         if type(user_parameters) == type(None) : return user_parameters
         try :
             user_parameters = convert_parameters_types(user_parameters)
-            user_parameters = check_integrity(user_parameters, do_dense_region_deconvolution, is_multichannel, segmentation_done, map, shape)
+            user_parameters = check_integrity(
+                user_parameters, 
+                do_dense_region_deconvolution,
+                do_clustering, 
+                is_multichannel, 
+                segmentation_done, 
+                map, 
+                shape
+                )
         except ParameterInputError as error:
             sg.popup(error)
         else :
@@ -306,7 +313,7 @@ def _launch_detection(image, image_input_values: dict) :
     threshold_user_selection = image_input_values.get('Interactive threshold selector')
     
     if type(threshold) == type(None) :     
-        threshold = compute_auto_threshold(image, voxel_size=voxel_size, spot_radius=spot_size, log_kernel_size=log_kernel_size, minimum_distance=minimum_distance) * threshold_penalty
+        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)
     
     filtered_image = _apply_log_filter(
         image=image,
@@ -403,7 +410,7 @@ def launch_post_detection(image, spots, image_input_values: dict,) :
     #appending results
     fov_res.update(snr_res)
 
-    return spots, fov_res
+    return fov_res
 
 def _compute_cell_snr(image: np.ndarray, bbox, spots, voxel_size, spot_size) :
     
@@ -592,7 +599,8 @@ def launch_detection(
         other_image,
         user_parameters,
         cell_label= None,
-        nucleus_label = None
+        nucleus_label = None,
+        hide_loading=False,
         ) :
     """
     Main call for features computation :
@@ -618,18 +626,17 @@ def launch_detection(
     do_dense_region_deconvolution = user_parameters['Dense regions deconvolution']
     do_clustering = user_parameters['Cluster computation']
 
-    spots, threshold  = _launch_detection(image, user_parameters)
+    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)
+        spots = launch_dense_region_deconvolution(image, spots, user_parameters, hide_loading = hide_loading)
         
     if do_clustering : 
-        clusters = launch_clustering(spots, user_parameters) #012 are coordinates #3 is number of spots per cluster, #4 is cluster index
+        clusters = launch_clustering(spots, user_parameters, hide_loading = hide_loading) #012 are coordinates #3 is number of spots per cluster, #4 is cluster index
         clusters = _update_clusters(clusters, spots, voxel_size=user_parameters['voxel_size'], cluster_size=user_parameters['cluster size'], min_spot_number= user_parameters['min number of spots'], shape=image.shape)
 
     else : clusters = None
 
-    spots, post_detection_dict = launch_post_detection(image, spots, user_parameters)
     user_parameters['threshold'] = threshold
 
     if user_parameters['Napari correction'] :
@@ -645,7 +652,7 @@ def launch_detection(
             nucleus_label=nucleus_label,
             other_images=other_image
             )
-        
+    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
@@ -773,12 +780,13 @@ def _create_threshold_slider(
             'size': 5, 
             'scale' : scale, 
             'face_color' : 'transparent', 
-            'edge_color' : 'blue', 
-            'symbol' : 'ring', 
+            'edge_color' : 'red', 
+            'symbol' : 'disc', 
             'opacity' : 0.7, 
-            'blending' : 'additive', 
+            'blending' : 'translucent', 
             'name': 'single spots',
-            'features' : {'threshold' : threshold}
+            'features' : {'threshold' : threshold},
+            'visible' : True,
             }
         return (spots, layer_args , 'points')
     return threshold_slider
@@ -825,4 +833,55 @@ def _local_maxima_mask(
             ndim=ndim)
     mask_local_max = detection.local_maximum_detection(image_filtered, minimum_distance)
     
-    return mask_local_max.astype(bool)
+    return mask_local_max.astype(bool)
+
+def output_spot_tiffvisual(channel,spots_list, path_output, dot_size = 3, rescale = True):
+    
+    """
+    Outputs a tiff image with one channel being {channel} and the other a mask containing dots where sports are located.
+    
+    Parameters
+    ----------
+        channel : np.ndarray
+            3D monochannel image
+        spots : list[np.ndarray] or np.ndarray
+            Spots arrays are ndarray where each element corresponds is a tuple(z,y,x) corresponding to 3D coordinate of a spot
+            To plot different spots on different channels a list of spots ndarray can be passed. 
+        path_output : str
+        dot_size : int
+            in pixels
+    """
+    
+    stack.check_parameter(channel = (np.ndarray), spots_list= (list, np.ndarray), path_output = (str), dot_size = (int))
+    stack.check_array(channel, ndim= [2,3])
+    if isinstance(spots_list, np.ndarray) : spots_list = [spots_list]
+
+    if channel.ndim == 3 : 
+        channel = stack.maximum_projection(channel)
+
+    im = np.zeros([1 + len(spots_list)] + list(channel.shape))
+    im[0,:,:] = channel
+
+    for level in range(len(spots_list)) :
+        if len(spots_list[level]) == 0 : continue
+        else :
+            spots_mask = np.zeros_like(channel)
+            
+            #Unpacking spots
+            if len(spots_list[level][0]) == 2 :
+                Y,X = zip(*spots_list[level])
+            elif len(spots_list[level][0]) == 3 :
+                Z,Y,X = zip(*spots_list[level])
+                del Z
+            else :
+                Z,Y,X,*_ = zip(*spots_list[level])
+                del Z,_
+            
+            #Reconstructing signal
+            spots_mask[Y,X] = 1
+            if dot_size > 1 : spots_mask = binary_dilation(spots_mask, iterations= dot_size-1)
+            spots_mask = stack.rescale(np.array(spots_mask, dtype = channel.dtype))
+            im[level + 1] = spots_mask
+
+    if rescale : channel = stack.rescale(channel, channel_to_stretch= 0)
+    stack.save_image(im, path_output, extension= 'tif')