small-fish-gui 1.4.0__tar.gz → 1.5.0__tar.gz

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.4.0
+Version: 1.5.0
 Summary: Small Fish is a python application for the analysis of smFish images. It provides a ready to use graphical interface to combine famous python packages for cell analysis without any need for coding.
 Project-URL: Homepage, https://github.com/2Echoes/small_fish
 Project-URL: Issues, https://github.com/2Echoes/small_fish/issues

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "small_fish_gui"
-version = "1.4.0"
+version = "1.5.0"
 authors = [
   { name="Slimani Floric", email="floric.slimani@live.com" },
 ]

small_fish_gui-1.5.0/src/small_fish_gui/.readthedocs.yaml

@@ -0,0 +1,21 @@
+# .readthedocs.yaml
+# Read the Docs configuration file
+# See for details
+
+# Required
+version: 2
+
+# Set the OS, Python version and other tools you might need
+build:
+  os: ubuntu-22.04
+  tools:
+    python: "3.8"
+
+# Build documentation in the "docs/" directory with Sphinx
+sphinx:
+  configuration: docs/conf.py
+
+# Optionally build your docs in additional formats such as PDF and ePub
+formats:
+   - pdf
+   - epub

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/README.md

@@ -5,7 +5,7 @@ Cell segmentation (**2D**) is peformed using *cellpose* (published work) : https
 
 Spot detection is performed via *big-fish* (published work) : https://github.com/fish-quant/big-fish
 
-Time stacks are not yet supported.
+**Time stacks are not supported.**
 
 ## What can you do with small fish ?
 
@@ -77,7 +77,7 @@ If you run into any problems I would recommend following the official cellpose i
 
 
 ### Training cellpose
-If you want to train your own cellpose model or import custom model from exterior source I recommend doing so from the cellpose GUI 
+If you want to train your own cellpose model or import custom model from exterior source I recommend doing so from the cellpose GUI. Note that Small fish uses mean projection to segment images in 2D, if you want to retrain a cellpose model to fit your data it is recommended to do so on mean or max projection of your data.
 
 To install the GUI run : 
 
@@ -93,6 +93,5 @@ Note that for training it is recommended to first set up your GPU as training co
 ## Developpement
 
 Optional features to include in future versions : 
-- batch processing
 - time stack (which would include cell tracking)
 - 3D segmentation

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/__init__.py

@@ -38,4 +38,4 @@ ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
 SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 """
-__version__ = "1.4.0"
+__version__ = "1.5.0"

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/batch/prompt.py

@@ -35,7 +35,7 @@ def batch_promp(
     sanity_header = sg.Text("Dimension sanity", font=('bold',15), pad=(0,10))
     dimension_number_text = sg.Text("Dimension number : unknown")
     
-
+#LAYOUT INIT
 #########################################
 #####   COLUMNS
 #########################################
@@ -182,8 +182,6 @@ def batch_promp(
         [tab_col, launch_col],
         [stream_output],
     ]
-    stream_output.restore_stderr()
-    stream_output.restore_stdout()
 
     window = sg.Window("small fish", layout=layout, size= (800,800), auto_size_buttons=True, auto_size_text=True, resizable=True)
     
@@ -332,7 +330,11 @@ def batch_promp(
                 batch_name_input.update(value=values.get('batch_name'))
 
             elif event == "Cancel" :
-                raise InterruptedError("cancel")
+                stream_output.restore_stderr()
+                stream_output.restore_stdout()
+                window.close()
+                return results_df, cell_results_df, acquisition_id, preset, False, None,None #Segmentation done : False, cell label : None, Nucleus label : None
+
 
             elif event == None :
                 raise InterruptedError("closed")

small_fish_gui-1.5.0/src/small_fish_gui/docs/conf.py

@@ -0,0 +1 @@
+#init conf file

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/gui/layout.py

@@ -95,7 +95,7 @@ def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd())
 
     max_length = len(max(keys, key=len))
     layout = [
-        [sg.Text(pad_right(name, max_length, ' ')), Browse(key= name, initial_folder= preset)] for name in keys
+        [sg.Text(pad_right(name, max_length, ' ')), Browse(key= name, target=(555666777,2), initial_folder= preset), sg.Text('')] for name in keys
         ]
     if isinstance(header, str) :
         layout = [add_header(header)] + layout
@@ -152,7 +152,20 @@ def radio_layout(values, header=None) :
         layout = [add_header(header)] + layout
     return layout
 
-def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_model_preset= 'nuclei', cytoplasm_channel_preset=0, nucleus_channel_preset=0, cyto_diameter_preset=30, nucleus_diameter_preset= 30, show_segmentation_preset= False, segment_only_nuclei_preset=False, saving_path_preset=os.getcwd(), filename_preset='cell_segmentation.png',) :
+def _segmentation_layout(
+        multichannel, 
+        cytoplasm_model_preset= 'cyto3', 
+        nucleus_model_preset= 'nuclei', 
+        cytoplasm_channel_preset=0, 
+        nucleus_channel_preset=0, 
+        other_nucleus_image_preset = None,
+        cyto_diameter_preset=30, 
+        nucleus_diameter_preset= 30, 
+        show_segmentation_preset= False, 
+        segment_only_nuclei_preset=False, 
+        saving_path_preset=os.getcwd(), 
+        filename_preset='cell_segmentation.png',
+        ) :
     
     USE_GPU = use_gpu()
 
@@ -160,7 +173,9 @@ def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_
     if len(models_list) == 0 : models_list = ['no model found']
     
     #Header : GPU availabality
-    layout = [[sg.Text("GPU is currently "), sg.Text('ON', text_color= 'green') if USE_GPU else sg.Text('OFF', text_color= 'red')]]
+    layout = [
+        [sg.Text("GPU is currently "), sg.Text('ON', text_color= 'green') if USE_GPU else sg.Text('OFF', text_color= 'red')]
+        ]
     
     #cytoplasm parameters
     layout += [
@@ -170,6 +185,8 @@ def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_
                         ]
                         
     if multichannel : layout += parameters_layout(['cytoplasm channel'],default_values= [cytoplasm_channel_preset])
+
+
     layout += parameters_layout(['cytoplasm diameter'], unit= "px", default_values= [cyto_diameter_preset])
     #Nucleus parameters
     layout += [
@@ -179,6 +196,7 @@ def _segmentation_layout(multichannel, cytoplasm_model_preset= 'cyto2', nucleus_
                 ]
     
     if multichannel : layout += parameters_layout(['nucleus channel'], default_values= [nucleus_channel_preset])
+    layout += path_layout(['other_nucleus_image'], preset=other_nucleus_image_preset)
     layout += parameters_layout([ 'nucleus diameter'],unit= "px", default_values= [nucleus_diameter_preset])
     layout += bool_layout(["Segment only nuclei"], preset=segment_only_nuclei_preset)
     

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/gui/prompts.py

@@ -32,14 +32,14 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY',
         window.close()
         return event, values
 
-def prompt_with_help(layout, help =None, add_scrollbar=True) :
+def prompt_with_help(layout, help =None, add_scrollbar=True, vertical_scroll_only=True) :
     layout += [[]]
     layout += [[sg.Button('Help')]]
     layout += [[sg.Button('Ok'), sg.Button('Cancel')]]
     
     if add_scrollbar :
         size = (400,500)
-        col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size)
+        col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=vertical_scroll_only, size=size)
         layout = [[col_elmt]]
     else :
         size = (None,None)
@@ -280,11 +280,13 @@ def _warning_popup(warning:str) :
 
 def _sumup_df(results: pd.DataFrame) :
 
+    COLUMNS = ['acquisition_id','threshold', 'spot_number', 'cell_number', 'filename', 'channel to compute']
+
     if len(results) > 0 :
         if 'channel to compute' not in results : results['channel to compute'] = np.NaN
-        res = results.loc[:,['acquisition_id', 'spot_number', 'cell_number', 'filename', 'channel to compute']]
+        res = results.loc[:,COLUMNS]
     else :
-        res = pd.DataFrame(columns= ['acquisition_id', 'spot_number', 'cell_number', 'filename', 'channel to compute'])
+        res = pd.DataFrame(columns= COLUMNS)
 
     return res
 
@@ -293,9 +295,9 @@ def hub_prompt(fov_results, do_segmentation=False) :
     sumup_df = _sumup_df(fov_results)
     
     if do_segmentation :
-        segmentation_object = sg.Text('Segmentation was performed', font='8', text_color= 'green')
+        segmentation_object = sg.Text('Segmentation in memory', font='8', text_color= 'green')
     else :
-        segmentation_object = sg.Text('Segmentation was not performed', font='8', text_color= 'red')
+        segmentation_object = sg.Text('No segmentation in memory', font='8', text_color= 'red')
 
     layout = [
         [sg.Text('RESULTS', font= 'bold 13')],

small_fish_gui-1.5.0/src/small_fish_gui/pipeline/_napari_wrapper.py

@@ -0,0 +1,202 @@
+"""
+Contains Napari wrappers to visualise and correct spots/clusters.
+"""
+
+import napari.layers
+import napari.types
+import numpy as np
+import napari
+
+from bigfish.stack import check_parameter
+from ..utils import compute_anisotropy_coef
+from ._colocalisation import spots_multicolocalisation
+
+def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cluster_size, min_spot_number, shape) :
+    if len(new_clusters) == 0 : return new_clusters
+    if len(spots) == 0 : return new_clusters
+
+    if len(new_clusters[0]) in [2,3] :
+        new_clusters = np.concatenate([
+            new_clusters,
+            np.zeros(shape=(len(new_clusters),1), dtype=int),
+            np.arange(len(new_clusters), dtype=int).reshape(len(new_clusters),1)
+            ],axis=1, dtype=int)
+
+    assert len(new_clusters[0]) == 4 or len(new_clusters[0]) == 5, "Wrong number of coordinates for clusters should not happen."
+    
+    # Update spots clusters
+    if len(voxel_size) == 3 :
+        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:3], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
+    elif len(voxel_size) == 2 :
+        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:2], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
+
+    # delete too small clusters
+        new_clusters = np.delete(new_clusters, new_clusters[:,-2] < min_spot_number, 0)
+
+    return new_clusters
+
+def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_size=None, min_spot_number=0, cell_label= None, nucleus_label= None, other_images =[]):
+    """
+    Open Napari viewer for user to visualize and corrects spots, clusters.
+
+    Returns
+    -------
+        new_spots,new_clusters
+    """
+    check_parameter(image= np.ndarray, voxel_size= (tuple,list))
+    dim = len(voxel_size)
+
+    if dim == 3 and type(cell_label) != type(None) :
+        cell_label = np.repeat(
+            cell_label[np.newaxis],
+            repeats= len(image),
+            axis=0
+        )
+    if dim == 3 and type(nucleus_label) != type(None) :
+        nucleus_label = np.repeat(
+            nucleus_label[np.newaxis],
+            repeats= len(image),
+            axis=0
+        )
+
+    scale = compute_anisotropy_coef(voxel_size)
+    Viewer = napari.Viewer(ndisplay=2, title= 'Spot correction', axis_labels=['z','y','x'], show= False)
+    Viewer.add_image(image, scale=scale, name= "rna signal", blending= 'additive', colormap='red', contrast_limits=[image.min(), image.max()])
+    other_colors = ['green', 'blue', 'gray', 'cyan', 'bop orange', 'bop purple'] * ((len(other_images)-1 // 7) + 1)
+    for im, color in zip(other_images, other_colors) : 
+        Viewer.add_image(im, scale=scale, blending='additive', visible=False, colormap=color, contrast_limits=[im.min(), im.max()])
+    layer_offset = len(other_images)
+
+    Viewer.add_points(  # single molecule spots; this layer can be update by user.
+        spots, 
+        size = 5, 
+        scale=scale, 
+        face_color= 'transparent', 
+        opacity= 1, 
+        symbol= 'disc', 
+        name= 'single spots'
+        )
+    
+    if type(clusters) != type(None) : Viewer.add_points( # cluster; this layer can be update by user.
+        clusters[:,:dim], 
+        size = 10, 
+        scale=scale, 
+        face_color= 'blue', 
+        opacity= 0.7, 
+        symbol= 'diamond', 
+        name= 'foci', 
+        features= {"spot_number" : clusters[:,dim], "id" : clusters[:,dim+1]}, 
+        feature_defaults= {"spot_number" : 0, "id" : -1}
+        )
+
+    if type(cell_label) != type(None) and not np.array_equal(nucleus_label, cell_label) : Viewer.add_labels(cell_label, scale=scale, opacity= 0.2, blending= 'additive')
+    if type(nucleus_label) != type(None) : Viewer.add_labels(nucleus_label, scale=scale, opacity= 0.2, blending= 'additive')
+        
+    Viewer.show(block=False)
+    napari.run()
+
+    new_spots = np.array(Viewer.layers['single spots'].data, dtype= int)
+
+    if type(clusters) != type(None) :
+        if len(clusters) > 0 : 
+            new_clusters = np.array(Viewer.layers['foci'].data, dtype= int)
+            new_clusters = _update_clusters(new_clusters, new_spots, voxel_size=voxel_size, cluster_size=cluster_size, min_spot_number=min_spot_number, shape=image.shape)
+    else : new_clusters = None
+
+    return new_spots, new_clusters
+
+def show_segmentation(
+        nuc_image : np.ndarray,
+        nuc_label : np.ndarray,
+        cyto_image : np.ndarray = None,
+        cyto_label : np.ndarray = None,
+) :
+    dim = nuc_image.ndim
+    
+    if type(cyto_image) != type(None) :
+        if cyto_image.ndim != nuc_image.ndim : raise ValueError("Cyto and Nuc dimensions missmatch.")
+        if type(cyto_label) == type(None) : raise ValueError("If cyto image is passed cyto label must be passed too.")
+
+    if dim == 3 and nuc_label.ndim == 2 :
+        nuc_label = np.repeat(
+            nuc_label[np.newaxis],
+            repeats= len(nuc_image),
+            axis=0
+        )
+    if type(cyto_label) != type(None) :
+        
+        if type(cyto_image) == type(None) : raise ValueError("If cyto label is passed cyto image must be passed too.")
+        
+        if dim == 3 and cyto_label.ndim == 2 :
+            cyto_label = np.repeat(
+                cyto_label[np.newaxis],
+                repeats= len(nuc_image),
+                axis=0
+            )
+
+    #Init Napari viewer
+    Viewer = napari.Viewer(ndisplay=2, title= 'Show segmentation', axis_labels=['z','y','x'] if dim == 3 else ['y', 'x'], show= False)
+    
+    # Adding channels
+    nuc_signal_layer = Viewer.add_image(nuc_image, name= "nucleus signal", blending= 'additive', colormap='blue', contrast_limits=[nuc_image.min(), nuc_image.max()])
+    nuc_label_layer = Viewer.add_labels(nuc_label, opacity= 0.5, blending= 'additive', name= 'nucleus_label',)
+    nuc_label_layer.preserve_labels = True
+    
+    #Adding labels
+    if type(cyto_image) != type(None) : Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()])
+    if (type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label) ) or (type(cyto_label) != type(None) and cyto_label.max() == 0): 
+        cyto_label_layer = Viewer.add_labels(cyto_label, opacity= 0.4, blending= 'additive', name= 'cytoplasm_label')
+        cyto_label_layer.preserve_labels = True
+    
+    #Launch Napari
+    Viewer.show(block=False)
+    napari.run()
+
+
+    new_nuc_label = Viewer.layers['nucleus_label'].data
+    if type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label) : new_cyto_label = Viewer.layers['cytoplasm_label'].data
+    else : new_cyto_label = new_nuc_label
+
+    return new_nuc_label, new_cyto_label
+
+def threshold_selection(
+        image : np.ndarray,
+        filtered_image : np.ndarray,
+        threshold_slider,
+        voxel_size : tuple,
+        ) :
+    
+    """
+    To view code for spot selection have a look at magicgui instance created with `detection._create_threshold_slider` which is then passed to this napari wrapper as 'threshold_slider' argument.
+    """
+    
+    Viewer = napari.Viewer(title= "Small fish - Threshold selector", ndisplay=2, show=True)
+    scale = compute_anisotropy_coef(voxel_size)
+    Viewer.add_image(
+        data= image,
+        contrast_limits= [image.min(), image.max()],
+        name= "raw signal",
+        colormap= 'green',
+        scale= scale,
+        blending= 'additive'
+    )
+    Viewer.add_image(
+        data= filtered_image,
+        contrast_limits= [filtered_image.min(), filtered_image.max()],
+        colormap= 'gray',
+        scale=scale,
+        blending='additive'
+    )
+
+    Viewer.window.add_dock_widget(threshold_slider, name='threshold_selector')
+    threshold_slider() #First occurence with auto or entered threshold.
+    
+    napari.run()
+
+    spots = Viewer.layers['single spots'].data.astype(int)
+    if len(spots) == 0 :
+        pass
+    else :
+        threshold = Viewer.layers['single spots'].properties.get('threshold')[0]
+
+    return spots, threshold

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/pipeline/_preprocess.py

@@ -69,7 +69,7 @@ def map_channels(user_parameters) :
     try : 
         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 :
@@ -125,14 +125,16 @@ def _auto_map_channels(is_3D_stack, is_time_stack, multichannel, image: np.ndarr
 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])]
@@ -140,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)
@@ -157,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) :
     """

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/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)
@@ -386,4 +454,49 @@ def plot_segmentation(
             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-1.4.0 → small_fish_gui-1.5.0}/src/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-1.4.0 → small_fish_gui-1.5.0}/src/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
@@ -279,7 +278,6 @@ 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)
@@ -315,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,
@@ -412,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) :
     
@@ -639,7 +637,6 @@ def launch_detection(
 
     else : clusters = None
 
-    spots, post_detection_dict = launch_post_detection(image, spots, user_parameters, hide_loading = hide_loading)
     user_parameters['threshold'] = threshold
 
     if user_parameters['Napari correction'] :
@@ -655,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
@@ -783,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

{small_fish_gui-1.4.0 → small_fish_gui-1.5.0}/src/small_fish_gui/pipeline/main.py

@@ -1,4 +1,7 @@
-#### New version for main.py
+"""
+This script is called when software starts; it is the main loop.
+"""
+
 import pandas as pd
 import PySimpleGUI as sg
 from ..gui import hub_prompt
@@ -7,7 +10,7 @@ from ._preprocess import clean_unused_parameters_cache
 from ..batch import batch_promp
 
 #'Global' parameters
-user_parameters = dict() # Very important object containg all choice from user that will influence the behavior of the main loop.
+user_parameters = dict() # Very important instance containg all choice from user that will influence the behavior of the actions loops.
 acquisition_id = -1
 result_df = pd.DataFrame()
 cell_result_df = pd.DataFrame()

small_fish_gui-1.5.0/src/small_fish_gui/pipeline/utils.py

@@ -0,0 +1,16 @@
+import numpy as np
+
+from math import ceil
+from itertools import zip_longest
+from skimage.measure import regionprops_table
+
+
+def from_label_get_centeroidscoords(label: np.ndarray):
+    """
+    Returns
+    --------
+      centroid : dict{"label": list, "centroid-n": list} 
+        n should be replace with 1,2.. according to the axe you wish to access."""
+
+    centroid = regionprops_table(label, properties= ["label","centroid"])
+    return centroid

small_fish_gui-1.4.0/src/small_fish_gui/pipeline/_napari_wrapper.py

@@ -1,229 +0,0 @@
-"""
-Contains Napari wrappers to visualise and correct spots/clusters.
-"""
-
-import numpy as np
-import scipy.ndimage as ndi
-import napari
-
-from napari.utils.events import Event
-from napari.layers import Points
-from bigfish.stack import check_parameter
-from ..utils import compute_anisotropy_coef
-from ._colocalisation import spots_multicolocalisation
-
-class Points_callback :
-    """
-    Custom class to handle points number evolution during Napari run.
-    """
-    
-    def __init__(self, points, next_id) -> None:
-        self.points = points
-        self.next_id = next_id
-        self._set_callback()
-    
-    def __str__(self) -> str:
-        string = 'Points_callback object state :\ncurrent_points_number : {0}\ncurrnet_id : {1}'.format(self.current_points_number, self.next_id)
-        return string
-    
-    def get_points(self) :
-        return self.points
-    
-    def get_next_id(self) : 
-        return self.next_id
-    
-    def _set_callback(self) :
-        def callback(event:Event) :
-
-            old_points = self.get_points()
-            new_points:Points = event.source.data
-            features = event.source.features
-            
-            current_point_number = len(old_points)
-            next_id = self.get_next_id()
-            new_points_number = len(new_points)
-
-            if new_points_number > current_point_number :
-                features.at[new_points_number - 1, "id"] = next_id
-                self.next_id += 1
-
-            #preparing next callback
-            self.points = new_points
-            self._set_callback()
-        self.callback = callback
-
-def _update_clusters(new_clusters: np.ndarray, spots: np.ndarray, voxel_size, cluster_size, min_spot_number, shape) :
-    if len(new_clusters) == 0 : return new_clusters
-    if len(spots) == 0 : return new_clusters
-    assert len(new_clusters[0]) == 4 or len(new_clusters[0]) == 5, "Wrong number of coordinates for clusters should not happen."
-    
-    # Update spots clusters
-    if len(voxel_size) == 3 :
-        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:3], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
-    elif len(voxel_size) == 2 :
-        new_clusters[:,-2] = spots_multicolocalisation(new_clusters[:,:2], spots, radius_nm= cluster_size, voxel_size=voxel_size, image_shape=shape)
-
-    # delete too small clusters
-        new_clusters = np.delete(new_clusters, new_clusters[:,-2] < min_spot_number, 0)
-
-    return new_clusters
-
-def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_size=None, min_spot_number=0, cell_label= None, nucleus_label= None, other_images =[]):
-    """
-    Open Napari viewer for user to visualize and corrects spots, clusters.
-
-    Returns
-    -------
-        new_spots,new_clusters
-    """
-    check_parameter(image= np.ndarray, voxel_size= (tuple,list))
-    dim = len(voxel_size)
-
-    if dim == 3 and type(cell_label) != type(None) :
-        cell_label = np.repeat(
-            cell_label[np.newaxis],
-            repeats= len(image),
-            axis=0
-        )
-    if dim == 3 and type(nucleus_label) != type(None) :
-        nucleus_label = np.repeat(
-            nucleus_label[np.newaxis],
-            repeats= len(image),
-            axis=0
-        )
-
-    scale = compute_anisotropy_coef(voxel_size)
-    try :
-        Viewer = napari.Viewer(ndisplay=2, title= 'Spot correction', axis_labels=['z','y','x'], show= False)
-        Viewer.add_image(image, scale=scale, name= "rna signal", blending= 'additive', colormap='red', contrast_limits=[image.min(), image.max()])
-        other_colors = ['green', 'blue', 'gray', 'cyan', 'bop orange', 'bop purple'] * ((len(other_images)-1 // 7) + 1)
-        for im, color in zip(other_images, other_colors) : 
-            Viewer.add_image(im, scale=scale, blending='additive', visible=False, colormap=color, contrast_limits=[im.min(), im.max()])
-        layer_offset = len(other_images)
-
-        Viewer.add_points(spots, size = 5, scale=scale, face_color= 'green', opacity= 1, symbol= 'ring', name= 'single spots') # spots
-        if type(clusters) != type(None) : Viewer.add_points(clusters[:,:dim], size = 10, scale=scale, face_color= 'blue', opacity= 0.7, symbol= 'diamond', name= 'foci', features= {"spot_number" : clusters[:,dim], "id" : clusters[:,dim+1]}, feature_defaults= {"spot_number" : 0, "id" : -1}) # cluster
-        if type(cell_label) != type(None) and not np.array_equal(nucleus_label, cell_label) : Viewer.add_labels(cell_label, scale=scale, opacity= 0.2, blending= 'additive')
-        if type(nucleus_label) != type(None) : Viewer.add_labels(nucleus_label, scale=scale, opacity= 0.2, blending= 'additive')
-        
-        #prepare cluster update
-        if type(clusters) != type(None) : 
-            next_cluster_id = clusters[-1,-1] + 1 if len(clusters) > 0 else 1
-            _callback = Points_callback(points=clusters[:dim], next_id=next_cluster_id)
-            points_callback = Viewer.layers[2 + layer_offset].events.data.connect((_callback, 'callback'))
-        Viewer.show(block=False)
-        napari.run()
-        
-
-        new_spots = np.array(Viewer.layers[1 + layer_offset].data, dtype= int)
-
-        if type(clusters) != type(None) :
-            if len(clusters) > 0 : 
-                new_clusters = np.concatenate([
-                    np.array(Viewer.layers[2 + layer_offset].data, dtype= int),
-                    np.array(Viewer.layers[2 + layer_offset].features, dtype= int)
-                ],
-                axis= 1)
-
-                new_clusters = _update_clusters(new_clusters, new_spots, voxel_size=voxel_size, cluster_size=cluster_size, min_spot_number=min_spot_number, shape=image.shape)
-        else : new_clusters = None
-
-    except Exception as error :
-        new_spots = spots
-        new_clusters = clusters
-        raise error
-
-    return new_spots, new_clusters
-
-def show_segmentation(
-        nuc_image : np.ndarray,
-        nuc_label : np.ndarray,
-        cyto_image : np.ndarray = None,
-        cyto_label : np.ndarray = None,
-) :
-    dim = nuc_image.ndim
-    
-    if type(cyto_image) != type(None) :
-        if cyto_image.ndim != nuc_image.ndim : raise ValueError("Cyto and Nuc dimensions missmatch.")
-        if type(cyto_label) == type(None) : raise ValueError("If cyto image is passed cyto label must be passed too.")
-
-    if dim == 3 and nuc_label.ndim == 2 :
-        nuc_label = np.repeat(
-            nuc_label[np.newaxis],
-            repeats= len(nuc_image),
-            axis=0
-        )
-    if type(cyto_label) != type(None) :
-        
-        if type(cyto_image) == type(None) : raise ValueError("If cyto label is passed cyto image must be passed too.")
-        
-        if dim == 3 and cyto_label.ndim == 2 :
-            cyto_label = np.repeat(
-                cyto_label[np.newaxis],
-                repeats= len(nuc_image),
-                axis=0
-            )
-
-    #Init Napari viewer
-    Viewer = napari.Viewer(ndisplay=2, title= 'Show segmentation', axis_labels=['z','y','x'] if dim == 3 else ['y', 'x'], show= False)
-    
-    # Adding channels
-    Viewer.add_image(nuc_image, name= "nucleus signal", blending= 'additive', colormap='blue', contrast_limits=[nuc_image.min(), nuc_image.max()])
-    Viewer.add_labels(nuc_label, opacity= 0.5, blending= 'additive')
-    
-    #Adding labels
-    if type(cyto_image) != type(None) : Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()])
-    if type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label): Viewer.add_labels(cyto_label, opacity= 0.4, blending= 'additive')
-    
-    #Launch Napari
-    Viewer.show(block=False)
-    napari.run()
-
-    new_nuc_label = Viewer.layers[1].data
-    if type(cyto_label) != type(None) and not np.array_equal(cyto_label, nuc_label) : new_cyto_label = Viewer.layers[3].data
-    else : new_cyto_label = new_nuc_label
-
-    return new_nuc_label, new_cyto_label
-
-
-
-def threshold_selection(
-        image : np.ndarray,
-        filtered_image : np.ndarray,
-        threshold_slider,
-        voxel_size : tuple,
-        ) :
-    
-    """
-    To view code for spot selection please have a look at magicgui instance created with `detection._create_threshold_slider` which is then passed to this napari wrapper as 'threshold_slider' argument.
-    """
-    
-    Viewer = napari.Viewer(title= "Small fish - Threshold selector", ndisplay=2, show=True)
-    scale = compute_anisotropy_coef(voxel_size)
-    Viewer.add_image(
-        data= image,
-        contrast_limits= [image.min(), image.max()],
-        name= "raw signal",
-        colormap= 'green',
-        scale= scale,
-        blending= 'additive'
-    )
-    Viewer.add_image(
-        data= filtered_image,
-        contrast_limits= [filtered_image.min(), filtered_image.max()],
-        colormap= 'gray',
-        scale=scale,
-        blending='additive'
-    )
-
-    Viewer.window.add_dock_widget(threshold_slider, name='threshold_selector')
-    threshold_slider() #First occurence with auto or entered threshold.
-    napari.run()
-
-    spots = Viewer.layers[-1].data.astype(int)
-    if len(spots) == 0 :
-        threshold = filtered_image.max()
-    else :
-        threshold = Viewer.layers[-1].properties.get('threshold')[0]
-
-    return spots, threshold