small-fish-gui 1.2.0__py3-none-any.whl → 1.3.0__py3-none-any.whl

small_fish_gui/README.md

@@ -15,7 +15,10 @@ Time stacks are not yet supported.
 - Signal to noise analysis
 - multichannel colocalisation
 
+<img src="https://github.com/2Echoes/small_fish_gui/blob/main/Segmentation%20example.jpg" width="500" title="Cell segmentation with Cellpose" alt="Cell segmentation - cellpose">| <img src="https://github.com/2Echoes/small_fish_gui/blob/main/napari_detection_example.png" width="500" title="Spot detection; clustering visualisation on Napari" alt="detection; Napari example">
+
 ## Installation
+If you don't have a python installation yet I would recommend the [miniconda distribution](https://docs.anaconda.com/free/miniconda/miniconda-other-installer-links/); but any distribution should work.
 
 It is higly recommanded to create a specific [conda](https://docs.conda.io/projects/conda/en/latest/user-guide/tasks/manage-environments.html) or [virtual](https://docs.python.org/3.6/library/venv.html) environnement to install small fish.
 
@@ -46,7 +49,46 @@ python -m small_fish_gui
 
 ## Cellpose configuration
 
-If you want to train your own cellpose model or set-up your GPU you can follow the official cellpose documentation, just remember to **first activate your small_fish environnement**.
+For the following steps first activate your small fish environnement : 
+
+```bash
+conda activate small_fish
+```
+### Setting up your GPU for cellpose (Windows / Linux)
+This instructions describe how I installed CUDA and GPU cellpose on the machines I tested, unfortunatly, drivers installations don't always run smoothly, if you run into any difficulties please have a look at the *GPU version (CUDA) on Windows or Linux* section of the [cellpose documentation](https://github.com/MouseLand/cellpose) for assistance.
+
+First step is to check that your GPU is CUDA compatible which it should be if from the brand NVIIDA.
+Then you need to install CUDA from the [NVIDIA archives](https://developer.nvidia.com/cuda-toolkit-archive), any 11.x version should work but I recommend the 11.8 version.
+
+Finally we need to make some modifcation to your small fish environnement : 
+
+Remove the CPU version of torch
+
+```bash
+pip uninstall torch
+```
+Then install pytorch and cudatoolkit :
+
+```bash
+conda install pytorch==1.12.0 cudatoolkit=11.3 -c pytorch
+```
+If the installation succeeded next time your run segmentation with small fish you should see the "GPU is ON" notice upon entering the segmentation parameters.
+If you run into any problems I would recommend following the official cellpose instructions as mentionned above.
+
+
+### 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 
+
+To install the GUI run : 
+
+```bash
+pip install cellpose[gui]
+```
+Then to run cellpose
+```bash
+cellpose
+```
+Note that for training it is recommended to first set up your GPU as training computation can be quite long otherwise. To get started with how to train your models you can watch the [video](https://www.youtube.com/watch?v=5qANHWoubZU) from cellpose authors.
 
 ## Developpement
 

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.2.0"
+__version__ = "1.3.0"

small_fish_gui/gui/prompts.py

@@ -2,7 +2,7 @@ import PySimpleGUI as sg
 import pandas as pd
 import os
 import numpy as np
-from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_layout, add_header
+from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_layout, add_header, path_layout
 from ..interface import open_image, check_format, FormatError
 from .help_module import ask_help
 
@@ -113,7 +113,7 @@ def output_image_prompt(filename) :
         relaunch = False
         layout = path_layout(['folder'], look_for_dir= True, header= "Output parameters :")
         layout += parameters_layout(["filename"], default_values= [filename + "_quantification"], size=25)
-        layout += bool_layout(['Excel', 'Feather'])
+        layout += bool_layout(['csv','Excel', 'Feather'])
         layout.append([sg.Button('Cancel')])
 
         event,values= prompt(layout)
@@ -204,6 +204,23 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
         default_segmentation = [default_dict.setdefault('nucleus channel signal', default_dict.setdefault('nucleus channel',0))]
         layout += parameters_layout(['nucleus channel signal'], default_values=default_segmentation) + [[sg.Text(" channel from which signal will be measured for nucleus features.")]]
 
+    layout += bool_layout(['Interactive threshold selector'], preset=[False])
+    layout += path_layout(
+        keys=['spots_extraction_folder'],
+        look_for_dir=True,
+        header= "Individual spot extraction",
+        preset= default_dict.setdefault('spots_extraction_folder', '')
+    )
+    layout += parameters_layout(
+        parameters=['spots_filename'],
+        default_values=[default_dict.setdefault('spots_filename','spots_extraction')],
+        size= 13
+    )
+    layout += bool_layout(
+        parameters= ['do_spots_csv', 'do_spots_excel', 'do_spots_feather'],
+        preset= [default_dict.setdefault('do_spots_csv',False), default_dict.setdefault('do_spots_excel',False),default_dict.setdefault('do_spots_feather',False)]
+    )
+
     event, values = prompt_with_help(layout, help='detection')
     if event == 'Cancel' : return None
     if is_3D_stack : values['dim'] = 3

small_fish_gui/interface/output.py

@@ -2,7 +2,7 @@ import os
 import pandas as pd
 from bigfish.stack import check_parameter
 
-
+MAX_LEN_EXCEL = 1048576
 
 def _cast_spot_to_tuple(spot) :
     return tuple([coord for coord in spot])
@@ -10,11 +10,11 @@ def _cast_spot_to_tuple(spot) :
 def _cast_spots_to_tuple(spots) :
     return tuple(list(map(_cast_spot_to_tuple, spots)))
 
-def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= True, do_feather= False) :
+def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= True, do_feather= False, do_csv=False) :
     check_parameter(dataframe= pd.DataFrame, path= str, filename = str, do_excel = bool, do_feather = bool)
 
     if len(dataframe) == 0 : return True
-    if not do_excel and not do_feather : 
+    if not do_excel and not do_feather and not do_csv : 
         return False
 
     if not path.endswith('/') : path +='/'
@@ -23,7 +23,7 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
 
     new_filename = filename
     i= 1
-    while new_filename + '.xlsx' in os.listdir(path) or new_filename + '.feather' in os.listdir(path) :
+    while new_filename + '.xlsx' in os.listdir(path) or new_filename + '.feather' in os.listdir(path) or new_filename + '.csv' in os.listdir(path) :
         new_filename = filename + '_{0}'.format(i)
         i+=1
 
@@ -36,7 +36,14 @@ def write_results(dataframe: pd.DataFrame, path:str, filename:str, do_excel= Tru
     if 'clusters' in dataframe.columns : 
         dataframe = dataframe.drop(['clusters'], axis= 1)
 
-    if do_excel : dataframe.reset_index(drop=True).to_excel(path + filename + '.xlsx')
-    if do_feather : dataframe.reset_index(drop=True).to_feather(path + filename + '.feather')
+    if do_feather : dataframe.reset_index(drop=True).to_feather(path + new_filename + '.feather')
+    if do_csv : dataframe.reset_index(drop=True).to_csv(path + new_filename + '.csv', sep=";")
+    if do_excel : 
+        if len(dataframe) < MAX_LEN_EXCEL :
+            dataframe.reset_index(drop=True).to_excel(path + new_filename + '.xlsx')
+        else : 
+            print("Error : Table too big to be saved in excel format.")
+            return False
+    
 
     return True

small_fish_gui/pipeline/{_detection_visualisation.py → _napari_wrapper.py}

@@ -2,7 +2,6 @@
 Contains Napari wrappers to visualise and correct spots/clusters.
 """
 
-
 import numpy as np
 import scipy.ndimage as ndi
 import napari
@@ -96,15 +95,15 @@ def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_siz
     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')
+        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)
+            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 np.array_equal(nucleus_label, cell_label) : Viewer.add_labels(cell_label, scale=scale, opacity= 0.2, blending= 'additive')
+        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
@@ -136,4 +135,94 @@ def correct_spots(image, spots, voxel_size= (1,1,1), clusters= None, cluster_siz
 
     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) : 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) : new_cyto_label = Viewer.layers[3].data
+
+    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)
+    Viewer.add_image(
+        data= image,
+        contrast_limits= [image.min(), image.max()],
+        name= "raw signal",
+        colormap= 'green',
+        scale= voxel_size,
+        blending= 'additive'
+    )
+    Viewer.add_image(
+        data= filtered_image,
+        contrast_limits= [filtered_image.min(), filtered_image.max()],
+        colormap= 'gray',
+        scale=voxel_size,
+        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

small_fish_gui/pipeline/_preprocess.py

@@ -1,5 +1,5 @@
 import numpy as np
-import pandas as pd
+import os
 import PySimpleGUI as sg
 from ..gui import _error_popup, _warning_popup, parameters_layout, add_header, prompt, prompt_with_help
 
@@ -253,6 +253,11 @@ def check_integrity(values: dict, do_dense_region_deconvolution, multichannel,se
             raise ParameterInputError("Channel to compute is out of range for image.\nPlease select from {0}".format(list(range(ch_len))))
         values['channel to compute'] = ch
 
+    #Spot extraction
+    if not os.path.isdir(values['spots_extraction_folder']) and values['spots_extraction_folder'] != '':
+        raise ParameterInputError("Incorrect spot extraction folder.")
+
+
     return values
 
 

small_fish_gui/pipeline/_segmentation.py

@@ -6,6 +6,7 @@ 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 ._napari_wrapper import show_segmentation as napari_show_segmentation
 
 import cellpose.models as models
 import numpy as np
@@ -152,19 +153,18 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 )
 
         finally  : window.close()
-        if show_segmentation or type(output_path) != type(None) :
-            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)
-            plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=show_segmentation, path_output=None, title= "Nucleus segmentation (blue)", remove_frame=False,)
-            if type(nuc_path) != type(None) : 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=show_segmentation, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=False)
-                if type(cyto_path) != type(None) : 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)
+
         if show_segmentation :
+            nucleus_label, cytoplasm_label = napari_show_segmentation(
+                nuc_image=image[nucleus_channel],
+                nuc_label= nucleus_label,
+                cyto_image=image[cytoplasm_channel],
+                cyto_label=cytoplasm_label,
+            )
+
+            if nucleus_label.ndim == 3 : nucleus_label = np.max(nucleus_label, axis=0)
+            if cytoplasm_label.ndim == 3 : cytoplasm_label = np.max(cytoplasm_label, axis=0)
+
             layout = [
                 [sg.Text("Proceed with current segmentation ?")],
                 [sg.Button("Yes"), sg.Button("No")]
@@ -174,6 +174,20 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
             if event == "No" :
                 continue
 
+        if type(output_path) != type(None) :
+            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)
+            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)
+        
+
+
+
         if cytoplasm_label.max() == 0 : #No cell segmented
             layout = [
             [sg.Text("No cell segmented. Proceed anyway ?")],

small_fish_gui/pipeline/actions.py

@@ -4,13 +4,14 @@ from ._preprocess import map_channels, prepare_image_detection, reorder_shape, r
 from .detection import ask_input_parameters, initiate_detection, launch_detection, launch_features_computation, get_nucleus_signal
 from ._segmentation import launch_segmentation
 from ._colocalisation import initiate_colocalisation, launch_colocalisation
+from .spots import launch_spots_extraction
 
 import pandas as pd
 import PySimpleGUI as sg
 
 def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_label, nucleus_label) :
     """
-    #TODO : list all keys added to user_parameters when returned
+    #TODO : list all keys added to user_parameters when returned.
     """
 
     new_results_df = pd.DataFrame()
@@ -84,7 +85,20 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
             if ask_detection_confirmation(user_parameters.get('threshold')) : break
         else :
             break
-        
+
+    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,
+                    image=image,
+                    spots=spots,
+                    nucleus_label= nucleus_label,
+                    cell_label= cytoplasm_label,
+                )
+
     #Features computation
     new_results_df, new_cell_results_df = launch_features_computation(
     acquisition_id=acquisition_id,
@@ -108,9 +122,10 @@ def save_results(result_df, cell_result_df, coloc_df) :
             filename = dic['filename']
             do_excel = dic['Excel']
             do_feather = dic['Feather']
-            sucess1 = write_results(result_df, path= path, filename=filename, do_excel= do_excel, do_feather= do_feather)
-            sucess2 = write_results(cell_result_df, path= path, filename=filename + '_cell_result', do_excel= do_excel, do_feather= do_feather)
-            sucess3 = write_results(coloc_df, path= path, filename=filename + '_coloc_result', do_excel= do_excel, do_feather= do_feather)
+            do_csv = dic['csv']
+            sucess1 = write_results(result_df, path= path, filename=filename, do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
+            sucess2 = write_results(cell_result_df, path= path, filename=filename + '_cell_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
+            sucess3 = write_results(coloc_df, path= path, filename=filename + '_coloc_result', do_excel= do_excel, do_feather= do_feather, do_csv=do_csv)
             if sucess1 and sucess2 and sucess3 : sg.popup("Sucessfully saved at {0}.".format(path))
 
     else :
@@ -141,20 +156,19 @@ def delete_acquisitions(selected_acquisitions : pd.DataFrame,
         sg.popup("Please select the acquisitions you would like to delete.")
     else :
         acquisition_ids = list(result_df.iloc[list(selected_acquisitions)]['acquisition_id'])
-        print("Acquisitions to delete : ", acquisition_ids)
         result_drop_idx = result_df[result_df['acquisition_id'].isin(acquisition_ids)].index
-        print("{0} acquisitions to delete.".format(len(result_drop_idx)))
+        print("{0} acquisitions deleted.".format(len(result_drop_idx)))
         
         if len(cell_result_df) > 0 :
             cell_result_df_drop_idx = cell_result_df[cell_result_df['acquisition_id'].isin(acquisition_ids)].index
-            print("{0} cells to delete.".format(len(cell_result_df_drop_idx)))
+            print("{0} cells deleted.".format(len(cell_result_df_drop_idx)))
             cell_result_df = cell_result_df.drop(cell_result_df_drop_idx, axis=0)
         
         if len(coloc_df) > 0 :
             coloc_df_drop_idx = coloc_df[(coloc_df["acquisition_id_1"].isin(acquisition_ids)) | (coloc_df['acquisition_id_2'].isin(acquisition_ids))].index
-            print("{0} coloc measurement to delete.".format(len(coloc_df_drop_idx)))
+            print("{0} coloc measurement deleted.".format(len(coloc_df_drop_idx)))
             coloc_df = coloc_df.drop(coloc_df_drop_idx, axis=0)
 
         result_df = result_df.drop(result_drop_idx, axis=0)
 
-    return result_df, cell_result_df, coloc_df
+    return result_df, cell_result_df, coloc_df

small_fish_gui/pipeline/detection.py

@@ -5,9 +5,13 @@ Contains code to handle detection as well as bigfish wrappers related to spot de
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
 from ._signaltonoise import compute_snr_spots
-from ._detection_visualisation import correct_spots, _update_clusters
+from ._napari_wrapper import correct_spots, _update_clusters, threshold_selection
 from ..gui import add_default_loading
 from ..gui import detection_parameters_promt, input_image_prompt
+from .spots import compute_Spots
+from magicgui import magicgui
+from napari.layers import Image, Points
+from napari.types import LayerDataTuple
 
 import numpy as np
 import pandas as pd
@@ -20,6 +24,7 @@ import bigfish.multistack as multistack
 import bigfish.classification as classification
 from bigfish.detection.spot_detection import get_object_radius_pixel
 from types import GeneratorType
+from skimage.measure import regionprops
 
 
 def ask_input_parameters(ask_for_segmentation=True) :
@@ -284,7 +289,7 @@ def initiate_detection(user_parameters, segmentation_done, map, shape) :
     return user_parameters
 
 @add_default_loading
-def _launch_detection(image, image_input_values: dict, time_stack_gen=None) :
+def _launch_detection(image, image_input_values: dict) :
 
     """
     Performs spots detection
@@ -297,25 +302,48 @@ def _launch_detection(image, image_input_values: dict, time_stack_gen=None) :
     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')
+    threshold_user_selection = image_input_values.get('Interactive threshold selector')
     
-    if type(threshold) == type(None) : 
-        #detection
-        if type(time_stack_gen) != type(None) :
-            image_sample = time_stack_gen()
-        else :
-            image_sample = image
-    
-        threshold = compute_auto_threshold(image_sample, voxel_size=voxel_size, spot_radius=spot_size) * threshold_penalty
+    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
     
-    spots = detection.detect_spots(
-        images= image,
-        threshold=threshold,
-        return_threshold= False,
+    filtered_image = _apply_log_filter(
+        image=image,
+        voxel_size=voxel_size,
+        spot_radius=spot_size,
+        log_kernel_size = log_kernel_size,
+    )
+
+    local_maxima = _local_maxima_mask(
+        image_filtered=filtered_image,
         voxel_size=voxel_size,
-        spot_radius= spot_size,
-        log_kernel_size=log_kernel_size,
+        spot_radius=spot_size,
         minimum_distance=minimum_distance
+    )
+
+    if threshold_user_selection :
+
+        threshold_slider = _create_threshold_slider(
+            logfiltered_image=filtered_image,
+            local_maxima=local_maxima,
+            default=threshold,
+            min=filtered_image[local_maxima].min(),
+            max=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]
         
     return spots, threshold
 
@@ -449,6 +477,7 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
     #Nucleus features : area is computed in bigfish
     features_names += ['nucleus_mean_signal', 'nucleus_median_signal', 'nucleus_max_signal', 'nucleus_min_signal']
     features_names += ['snr_mean', 'snr_median', 'snr_std']
+    features_names += ['cell_center_coord','foci_number','foci_in_nuc_number']
 
     result_frame = pd.DataFrame()
 
@@ -485,6 +514,30 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
                 compute_topography=True
             )
 
+        #center of cell coordinates
+        local_cell_center = regionprops(
+            label_image=cell_mask.astype(int)
+        )[0]['centroid']
+        cell_center = (local_cell_center[0] + min_y, local_cell_center[1] + min_x)
+
+        #foci in nucleus
+        if type(foci_coords) != type(None) :
+            if len(foci_coords) == 0 : 
+                foci_number = 0
+                foci_in_nuc_number = 0
+            else :
+                foci_number = len(foci_coords)
+                foci_index = list(zip(*foci_coords))
+                if len(foci_index) == 5 :
+                    foci_index = foci_index[1:3]
+                elif len(foci_index) == 4 :
+                    foci_index = foci_index[:2]
+                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
+
         #Signal to noise
         snr_dict = _compute_cell_snr(
             image,
@@ -501,6 +554,7 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
         features = list(features)
         features += [np.mean(nuc_signal), np.median(nuc_signal), np.max(nuc_signal), np.min(nuc_signal)]
         features += [snr_mean, snr_median, snr_std]
+        features += [cell_center, foci_number, foci_in_nuc_number]
 
         features = [acquisition_id, cell_id, cell_bbox] + features
         
@@ -686,4 +740,83 @@ def get_nucleus_signal(image, other_images, user_parameters) :
 
         return nucleus_signal
     else :
-        return image
+        return image
+
+def _create_threshold_slider(
+        logfiltered_image : np.ndarray,
+        local_maxima : np.ndarray,
+        default : int,
+        min : int,
+        max : int,
+        voxel_size
+) :
+    
+    if isinstance(default, float) : default = round(default)
+
+    @magicgui(
+        threshold={'widget_type' : 'Slider', 'value' : default, 'min' : min, 'max' : max},
+        auto_call=True
+    )
+    def threshold_slider(threshold: int) -> LayerDataTuple:
+        spots = detection.spots_thresholding(
+            image=logfiltered_image,
+            mask_local_max=local_maxima,
+            threshold=threshold
+        )[0]
+        layer_args = {
+            'size': 7, 
+            'scale' : voxel_size, 
+            'face_color' : 'transparent', 
+            'edge_color' : 'blue', 
+            'symbol' : 'ring', 
+            'opacity' : 0.7, 
+            'blending' : 'additive', 
+            'name': 'single spots',
+            'features' : {'threshold' : threshold}
+            }
+        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)

small_fish_gui/pipeline/spots.py

@@ -0,0 +1,71 @@
+"""
+Sub-module to handle individual spot extraction.
+
+"""
+
+import numpy as np
+import pandas as pd
+from ..interface.output import write_results
+
+def launch_spots_extraction(
+        acquisition_id,
+        user_parameters,
+        image,
+        spots,
+        nucleus_label,
+        cell_label,
+) :
+    Spots = compute_Spots(
+        acquisition_id=acquisition_id,
+        image=image,
+        spots=spots,
+        nucleus_label=nucleus_label,
+        cell_label=cell_label,
+    )
+
+    did_output = write_results(
+        Spots,
+        path= user_parameters['spots_extraction_folder'],
+        filename= user_parameters['spots_filename'],
+        do_excel=user_parameters['do_spots_excel'],
+        do_csv=user_parameters['do_spots_csv'],
+        do_feather=user_parameters['do_spots_feather'],
+        )
+    
+    if did_output : print("Individual spots extracted at {0}".format(user_parameters['spots_extraction_folder']))
+
+def compute_Spots(
+        acquisition_id : int,
+        image : np.ndarray,
+        spots : np.ndarray,
+        nucleus_label = None,
+        cell_label = None,
+) :
+
+    index = list(zip(*spots))
+    index = tuple(index)
+    spot_intensities_list = list(image[index])
+    if type(nucleus_label) != type(None) :
+        in_nuc_list = list(nucleus_label.astype(bool)[index[-2:]]) #Only plane coordinates
+    else :
+        in_nuc_list = np.NaN
+    if type(cell_label) != type(None) :
+        cell_label_list = list(cell_label[index[-2:]]) #Only plane coordinates
+    else :
+        cell_label_list = np.NaN
+    id_list = np.arange(len(spots))
+
+    coord_list = list(zip(*index))
+
+    Spots = pd.DataFrame({
+        'acquisition_id' : [acquisition_id] * len(spots),
+        'spot_id' : id_list,
+        'intensity' : spot_intensities_list,
+        'cell_label' : cell_label_list,
+        'in_nucleus' : in_nuc_list,
+        'coordinates' : coord_list,
+    })
+
+    return Spots
+    
+

{small_fish_gui-1.2.0.dist-info → small_fish_gui-1.3.0.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.2.0
+Version: 1.3.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.2.0.dist-info → small_fish_gui-1.3.0.dist-info}/RECORD

@@ -1,9 +1,10 @@
 small_fish_gui/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
-small_fish_gui/README.md,sha256=LuvmYYwCVw7-rKhdhrtqxnxUfQxPUE-bbPlGNwzJh_4,1830
-small_fish_gui/__init__.py,sha256=X2D6chgv6h8daHaMPwY_iCAscI86KwOkCCez6vsShPw,1941
+small_fish_gui/README.md,sha256=2c_homYDJXX6VsBiEs5obhBh3HpcTSMdyjLo-35WzE4,4062
+small_fish_gui/Segmentation example.jpg,sha256=opfiSbjmfF6z8kBs08sg_FNR2Om0AcMPU5sSwSLHdoQ,215038
+small_fish_gui/__init__.py,sha256=1eF6detE4uCLLHVMeTw-aRG6fjoUMdhrvnf-b48bVSk,1941
 small_fish_gui/__main__.py,sha256=EzSCoJ7jpSdK-QbzUwQLGZeQWjybNeq8VnCBucA8MZw,1372
+small_fish_gui/napari_detection_example.png,sha256=l5EZlrbXemLiGqb5inSVsD6Kko1Opz528-go-fBfrw8,977350
 small_fish_gui/requirements.txt,sha256=9OMfUAnLdHevq6w_fVoDmVmkSMJeFofkOK_86_fu9C0,321
-small_fish_gui/start.py,sha256=HTbzsVcaMji1BZnWyjfn3bDGIQeXGG4zFzvCBepqFvA,108
 small_fish_gui/utils.py,sha256=tSoMb8N69WdKTtMItPb1DYZiIAz1mjI26BCKJAi6vuc,1798
 small_fish_gui/.github/workflows/python-publish.yml,sha256=5Ltnuhw9TevhzndlBmdUgYMnS73xEAxSyd1u8DHdn5s,1084
 small_fish_gui/gui/__init__.py,sha256=178HC3t2z4EnP0iBnMcaP_pyh5xHwOkEE6p3WJwBQeU,911
@@ -12,25 +13,26 @@ small_fish_gui/gui/general_help_screenshot.png,sha256=X4E6Td5f04K-pBUPDaBJRAE3D5
 small_fish_gui/gui/help_module.py,sha256=PmgkkDs7bZ2-po83A_PK9uldQcHjehYmqre21nYb6DQ,9600
 small_fish_gui/gui/layout.py,sha256=_ErOS2IUejeUuPLkDmPB3FzLkoHOWR-Iaxz-aUeETks,7695
 small_fish_gui/gui/mapping_help_screenshot.png,sha256=HcuRh5TYciUogUasza5vZ_QSshaiHsskQK23mh9vQS8,34735
-small_fish_gui/gui/prompts.py,sha256=74JPsGGtGMcHNdNQFjjHEN5XwdSd7hZKog_DTIcYaJ8,12389
+small_fish_gui/gui/prompts.py,sha256=NAR7qjKwybiZZ2caO_lB8_CEttG8i4lHdt9lxjh6ESM,13160
 small_fish_gui/gui/segmentation_help_screenshot.png,sha256=rbSgIydT0gZtfMh1qk4mdMbEIyCaakvHmxa2eOrLwO0,118944
 small_fish_gui/gui/test.py,sha256=Pf-GW9AgW-0VL1mFbYtqRvPAaa8DgwCThv2dDUHCcmU,156
 small_fish_gui/interface/__init__.py,sha256=PB86R4Y9kV80aGZ-vP0ZW2KeaCwGbBbCtFCmbN2yl28,275
 small_fish_gui/interface/image.py,sha256=X1L7S5svxUwdoDcI3QM1PbN-c4Nz5w30hixq3IgqSn8,1130
-small_fish_gui/interface/output.py,sha256=wqXJHk-PzqZwYr8NHLg9jcEJlZQXZk8R76aeWcTxsEw,1337
+small_fish_gui/interface/output.py,sha256=dyhpO1YrRCIbQYpqU_52E1DTNPf0wdktd--CB15iT3k,1712
 small_fish_gui/interface/parameters.py,sha256=lUugD-4W2TZyJF3TH1q70TlktEYhhPtcPCrvxm5Dk50,36
 small_fish_gui/interface/testing.py,sha256=MY5-GcPOUHagcrwR8A7QOjAmjZIDVC8Wz3NibLe3KQw,321
 small_fish_gui/pipeline/_colocalisation.py,sha256=peBw2Qz5m6wSejDkDz240UgvWl8ohNelrnmEgznbEsw,9635
 small_fish_gui/pipeline/_custom_errors.py,sha256=tQ-AUhgzIFpK30AZiQQrtHCHyGVRDdAoIjzL0Fk-1pA,43
-small_fish_gui/pipeline/_detection_visualisation.py,sha256=CNxCQpiCzC9Uk-2RqSuTp55Glf1URCL_s8zidwljY9Y,5774
-small_fish_gui/pipeline/_preprocess.py,sha256=RHbMeYG6GPYyPJzxksgCQ8bs2O3qSXU0V-z4NZWQhrA,10487
-small_fish_gui/pipeline/_segmentation.py,sha256=0f8M2Ujczm0tU5AVwxhfOyzRCi_P_gg1393S4RAvDFs,12968
+small_fish_gui/pipeline/_napari_wrapper.py,sha256=WtqxxcM4l4NsEnqU-YDvm7-KJgXlsGur1HFUWUgvuao,9124
+small_fish_gui/pipeline/_preprocess.py,sha256=szNoav19Xo3USmiUTjcFgkMn9QK53ZOydbLV5aMFLws,10676
+small_fish_gui/pipeline/_segmentation.py,sha256=M2bQzgzw7Zt_DBeM3qvI0V4Pn0HFLwj0l8yV8M5aToo,12977
 small_fish_gui/pipeline/_signaltonoise.py,sha256=7A9t7xu7zghI6cr201Ldm-LjJ5NOuP56VSeJ8KIzcUo,8497
-small_fish_gui/pipeline/actions.py,sha256=eKKmT3SSDYKQz-zU8HKz9h0PPgqyYrj4qHbrw1hfpRQ,7118
-small_fish_gui/pipeline/detection.py,sha256=n-uuk2cP9Ls3WaZnuQfNHWyPoJWZNh8k9yW_8ZDC3fA,27484
+small_fish_gui/pipeline/actions.py,sha256=EIGIOlwJ_DADX1NcLWwrTP_AidDX-4f4ggZV0gkIb58,7988
+small_fish_gui/pipeline/detection.py,sha256=sZjcDeHujdmXHVifI_Ir0xudb30Y1cuJxI6YGtp4mRQ,31778
 small_fish_gui/pipeline/main.py,sha256=AAW-zK3b7Ece9cdHn9y6QG8lTa1HXG-8JtnvJ3m0HwA,3149
+small_fish_gui/pipeline/spots.py,sha256=yHvqf1eD25UltELpzcouYXhLkxiXI_mOL1ANSzXK5pw,1907
 small_fish_gui/pipeline/test.py,sha256=w4ZMGDmUDXxVgWTlZ2TKw19W8q5gcE9gLMKe0SWnRrw,2827
-small_fish_gui-1.2.0.dist-info/METADATA,sha256=ayA13aIDIc9K64nQLNlxWcTNNM7tO17BaK3kEycGiQw,2567
-small_fish_gui-1.2.0.dist-info/WHEEL,sha256=zEMcRr9Kr03x1ozGwg5v9NQBKn3kndp6LSoSlVg-jhU,87
-small_fish_gui-1.2.0.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
-small_fish_gui-1.2.0.dist-info/RECORD,,
+small_fish_gui-1.3.0.dist-info/METADATA,sha256=i9buygANVdkEX6uNgJjUIiQU_0xxPTg3tsWFMfxZxw0,2567
+small_fish_gui-1.3.0.dist-info/WHEEL,sha256=1yFddiXMmvYK7QYTqtRNtX66WJ0Mz8PYEiEUoOUUxRY,87
+small_fish_gui-1.3.0.dist-info/licenses/LICENSE,sha256=-iFy8VGBYs5VsHglKpk4D-hxqQ2jMJaqmfq_ulIzDks,1303
+small_fish_gui-1.3.0.dist-info/RECORD,,

{small_fish_gui-1.2.0.dist-info → small_fish_gui-1.3.0.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.24.2
+Generator: hatchling 1.25.0
 Root-Is-Purelib: true
 Tag: py3-none-any

small_fish_gui/start.py

@@ -1,7 +0,0 @@
-import sys
-
-def main():
-    import small_fish.pipeline.main
-
-if __name__ == "__main__":
-    sys.exit(main())