small-fish-gui 1.1.0__tar.gz → 1.3.0__tar.gz

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.3
 Name: small_fish_gui
-Version: 1.1.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.1.0 → small_fish_gui-1.3.0}/pyproject.toml

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

small_fish_gui-1.3.0/src/small_fish_gui/README.md

@@ -0,0 +1,98 @@
+# Small Fish
+**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.
+
+Cell segmentation (**2D**) is peformed using *cellpose* (published work) : https://github.com/MouseLand/cellpose; compatible with your own cellpose models.
+
+Spot detection is performed via *big-fish* (published work) : https://github.com/fish-quant/big-fish
+
+Time stacks are not yet supported.
+
+## What can you do with small fish ?
+
+- Single molecule quantification (including a lot of spatial features)
+- Foci/Transcription site quantification
+- Nuclear signal quantification
+- 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.
+
+```bash
+conda create -n small_fish python=3.8
+conda activate small_fish
+```
+Then download the small_fish package : 
+```bash
+pip install small_fish_gui
+```
+<b> (Recommended) </b> Results visualisation is achieved through *Napari* which you can install with :
+
+```bash
+pip install napari[all]
+```
+
+## Run Small fish
+
+First activate your python environnement : 
+```bash
+activate small_fish
+```
+Then launch Small fish : 
+```bash
+python -m small_fish_gui
+```
+
+## Cellpose configuration
+
+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
+
+Optional features to include in future versions : 
+- batch processing
+- time stack (which would include cell tracking)
+- 3D segmentation

{small_fish_gui-1.1.0 → small_fish_gui-1.3.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__ = "0.5.0"
+__version__ = "1.3.0"

small_fish_gui-1.3.0/src/small_fish_gui/__main__.py

@@ -0,0 +1,29 @@
+import sys, subprocess
+import PySimpleGUI as sg
+
+def main():
+    import small_fish_gui.pipeline.main
+
+def is_last_version() :
+    latest_version = str(subprocess.run([sys.executable, '-m', 'pip', 'install', '{}==random'.format('small_fish_gui')], capture_output=True, text=True))
+    latest_version = latest_version[latest_version.find('(from versions:')+15:]
+    latest_version = latest_version[:latest_version.find(')')]
+    latest_version = latest_version.replace(' ','').split(',')[-1]
+
+    current_version = str(subprocess.run([sys.executable, '-m', 'pip', 'show', '{}'.format('small_fish_gui')], capture_output=True, text=True))
+    current_version = current_version[current_version.find('Version:')+8:]
+    current_version = current_version[:current_version.find('\\n')].replace(' ','')
+
+    return current_version == latest_version
+
+if __name__ == "__main__":
+
+    if not is_last_version() :
+        print("A new version of Small Fish is available. To update close small fish and type :\npip install --upgrade small_fish_gui")
+
+    try :
+        sys.exit(main())
+    except Exception as error :
+        sg.popup("Sorry. Something went wrong...\nIf you have some time to spare could you please communicate the error you encountered (next window) on :\nhttps://github.com/2Echoes/small_fish/issues.")
+        sg.popup_error_with_traceback(error)
+        raise error

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/src/small_fish_gui/gui/layout.py

@@ -151,7 +151,7 @@ def radio_layout(values, header=None) :
         layout = add_header(header, layout=layout)
     return layout
 
-def _segmentation_layout(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= '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',) :
     
     USE_GPU = use_gpu()
 
@@ -165,14 +165,14 @@ def _segmentation_layout(cytoplasm_model_preset= 'cyto2', nucleus_model_preset=
     layout += [add_header("Cell Segmentation", [sg.Text("Choose cellpose model for cytoplasm: \n")]),
               [combo_layout(models_list, key='cyto_model_name', default_value= cytoplasm_model_preset)]
                         ]
-    layout += [parameters_layout(['cytoplasm channel'],default_values= [cytoplasm_channel_preset])]
+    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 += [
             add_header("Nucleus segmentation",[sg.Text("Choose cellpose model for nucleus: \n")]),
               combo_layout(models_list, key='nucleus_model_name', default_value= nucleus_model_preset)
                 ]
-    layout += [parameters_layout(['nucleus channel'], default_values= [nucleus_channel_preset])]
+    if multichannel : layout += [parameters_layout(['nucleus channel'], default_values= [nucleus_channel_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.1.0 → small_fish_gui-1.3.0}/src/small_fish_gui/gui/prompts.py

@@ -1,7 +1,8 @@
 import PySimpleGUI as sg
 import pandas as pd
 import os
-from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_layout, add_header
+import numpy as np
+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
 
@@ -112,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)
@@ -203,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
@@ -266,6 +284,7 @@ def _warning_popup(warning:str) :
 def _sumup_df(results: pd.DataFrame) :
 
     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']]
     else :
         res = pd.DataFrame(columns= ['acquisition_id', 'spot_number', 'cell_number', 'filename', 'channel to compute'])
@@ -284,9 +303,9 @@ def hub_prompt(fov_results, do_segmentation=False) :
     layout = [
         [sg.Text('RESULTS', font= 'bold 13')],
         [sg.Table(values= list(sumup_df.values), headings= list(sumup_df.columns), row_height=20, num_rows= 5, vertical_scroll_only=False, key= "result_table"), segmentation_object],
-        [sg.Button('Add detection'), sg.Button('Compute colocalisation'), sg.Button('Batch detection')],
-        # [sg.Button('Save results', button_color= 'green'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset results',button_color= 'gray')]
-        [sg.Button('Save results', button_color= 'green'), sg.Button('Reset results',button_color= 'gray')]
+        [sg.Button('Add detection'), sg.Button('Compute colocalisation')],#, sg.Button('Batch detection')],
+        [sg.Button('Save results', button_color= 'green'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset results',button_color= 'gray')]
+        # [sg.Button('Save results', button_color= 'green'), sg.Button('Reset results',button_color= 'gray')]
     ]
 
     window = sg.Window('small fish', layout= layout, margins= (10,10))

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/src/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-1.1.0 → small_fish_gui-1.3.0}/src/small_fish_gui/pipeline/_colocalisation.py

@@ -204,13 +204,9 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
         voxel_size = voxel_size1
 
     if shape1 != shape2 :
-        print(shape1)
-        print(shape2) 
         raise MissMatchError("shape 1 different than shape 2")
     else :
         shape = shape1
-        print(shape1)
-        print(shape2)
 
     acquisition_couple = (acquisition1.at['acquisition_id'], acquisition2.at['acquisition_id'])
 
@@ -235,6 +231,9 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
         except MissMatchError as e :
             sg.popup(str(e))
             fraction_spots2_coloc_cluster1 = np.NaN
+        except TypeError : # Clusters not computed
+            fraction_spots2_coloc_cluster1 = np.NaN
+
 
     else : fraction_spots2_coloc_cluster1 = np.NaN
 
@@ -242,9 +241,12 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
         try :
             clusters2 = acquisition2['clusters'][:,:len(voxel_size)]
             fraction_spots1_coloc_cluster2 = spots_colocalisation(image_shape=shape, spot_list1=spots1, spot_list2=clusters2, distance= colocalisation_distance, voxel_size=voxel_size) / spot1_total
-        except MissMatchError as e :
+        except MissMatchError as e :# Clusters not computed
             sg.popup(str(e))
             fraction_spots1_coloc_cluster2 = np.NaN
+        except TypeError :
+            fraction_spots1_coloc_cluster2 = np.NaN
+
 
     else : fraction_spots1_coloc_cluster2 = np.NaN
 
@@ -261,6 +263,4 @@ def launch_colocalisation(result_tables, result_dataframe, colocalisation_distan
         'fraction_spots1_coloc_cluster2' : [fraction_spots1_coloc_cluster2],
     })
 
-    print(coloc_df.loc[:,['fraction_spots1_coloc_spots2','fraction_spots2_coloc_spots1', 'fraction_spots2_coloc_cluster1', 'fraction_spots1_coloc_cluster2']])
-
     return coloc_df

small_fish_gui-1.1.0/src/small_fish_gui/pipeline/_detection_visualisation.py → small_fish_gui-1.3.0/src/small_fish_gui/pipeline/_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-1.1.0 → small_fish_gui-1.3.0}/src/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
 
 
@@ -269,4 +274,16 @@ def reorder_shape(shape, map) :
         np.array(shape)[source]
     )
 
-    return new_shape
+    return new_shape
+
+def clean_unused_parameters_cache(user_parameters: dict) :
+    """
+    Clean unused parameters that were set to None in previous run.
+    """
+    parameters = ['alpha', 'beta', 'gamma', 'cluster size', 'min number of spots']
+    for parameter in parameters :
+        if parameter in user_parameters.keys() :
+            if type(user_parameters[parameter]) == type(None) :
+                del user_parameters[parameter]
+    
+    return user_parameters

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/src/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
@@ -31,7 +32,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
 
     while True : # Loop if show_segmentation 
         #Default parameters
-        cyto_model_name = user_parameters.setdefault('cyto_model_name', 'cyto2')
+        cyto_model_name = user_parameters.setdefault('cyto_model_name', 'cyto3')
         cyto_size = user_parameters.setdefault('cytoplasm diameter', 180)
         cytoplasm_channel = user_parameters.setdefault('cytoplasm channel', 0)
         nucleus_model_name = user_parameters.setdefault('nucleus_model_name', 'nuclei')
@@ -42,6 +43,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
         segment_only_nuclei = user_parameters.setdefault('Segment only nuclei', False)
         filename = user_parameters['filename']
         available_channels = list(range(image.shape[0]))
+        multichannel = user_parameters.get('multichannel')
 
 
     #Ask user for parameters
@@ -58,6 +60,7 @@ def launch_segmentation(image: np.ndarray, user_parameters: dict) :
                 show_segmentation_preset=show_segmentation,
                 segment_only_nuclei_preset=segment_only_nuclei,
                 filename_preset=filename,
+                multichannel=multichannel,
             )
 
             event, values = prompt_with_help(layout, help='segmentation')
@@ -150,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")]
@@ -172,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 ?")],
@@ -236,7 +252,10 @@ def _segmentate_object(im, model_name, object_size_px, channels = [0,0]) :
     
     return label
 
-def _cast_segmentation_parameters(values) :
+def _cast_segmentation_parameters(values:dict) :
+
+    values.setdefault('cytoplasm channel',0)
+    values.setdefault('nucleus channel',0)
 
     if values['cyto_model_name'] == '' :
         values['cyto_model_name'] = None

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/src/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()
@@ -31,7 +32,8 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
     if user_parameters['Segmentation'] and not segmentation_done:
         im_seg = reorder_image_stack(map, user_parameters)
         cytoplasm_label, nucleus_label, user_parameters = launch_segmentation(im_seg, user_parameters=user_parameters)
-
+    elif segmentation_done :
+        pass
     else :
         cytoplasm_label, nucleus_label = None,None
 
@@ -83,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,
@@ -107,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 :
@@ -124,4 +140,35 @@ def compute_colocalisation(result_tables, result_dataframe) :
     else :
         res_coloc = launch_colocalisation(result_tables, result_dataframe=result_dataframe, colocalisation_distance=colocalisation_distance)
 
-    return res_coloc
+    return res_coloc
+
+def delete_acquisitions(selected_acquisitions : pd.DataFrame, 
+                        result_df : pd.DataFrame, 
+                        cell_result_df : pd.DataFrame, 
+                        coloc_df : pd.DataFrame
+                        ) :
+    
+    if len(result_df) == 0 :
+        sg.popup("No acquisition to delete.")
+        return result_df, cell_result_df, coloc_df
+
+    if len(selected_acquisitions) == 0 :
+        sg.popup("Please select the acquisitions you would like to delete.")
+    else :
+        acquisition_ids = list(result_df.iloc[list(selected_acquisitions)]['acquisition_id'])
+        result_drop_idx = result_df[result_df['acquisition_id'].isin(acquisition_ids)].index
+        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 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 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

{small_fish_gui-1.1.0 → small_fish_gui-1.3.0}/src/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
 
@@ -357,15 +385,17 @@ def launch_post_detection(image, spots, image_input_values: dict,) :
     #features
     fov_res['spot_number'] = len(spots)
     snr_res = compute_snr_spots(image, spots, voxel_size, spot_size)
-        
-    if dim == 3 :
-        Z,Y,X = list(zip(*spots))
-        spots_values = image[Z,Y,X]
+    if len(spots) == 0 :
+        fov_res['spotsSignal_median'], fov_res['spotsSignal_mean'], fov_res['spotsSignal_std'] = np.NaN, np.NaN, np.NaN
     else :
-        Y,X = list(zip(*spots))
-        spots_values = image[Y,X]
-
-    fov_res['spotsSignal_median'], fov_res['spotsSignal_mean'], fov_res['spotsSignal_std'] = np.median(spots_values), np.mean(spots_values), np.std(spots_values)
+        if dim == 3 :
+            Z,Y,X = list(zip(*spots))
+            spots_values = image[Z,Y,X]
+        else :
+            Y,X = list(zip(*spots))
+            spots_values = image[Y,X]
+        fov_res['spotsSignal_median'], fov_res['spotsSignal_mean'], fov_res['spotsSignal_std'] = np.median(spots_values), np.mean(spots_values), np.std(spots_values)
+    
     fov_res['median_pixel'] = np.median(image)
     fov_res['mean_pixel'] = np.mean(image)
 
@@ -447,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()
 
@@ -483,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,
@@ -499,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
         
@@ -601,9 +657,9 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
     if user_parameters['Cluster computation'] : 
         frame_results['cluster_number'] = len(clusters)
         if dim == 3 :
-            frame_results['total_spots_in_clusters'] = clusters.sum(axis=0)[3]
+            frame_results['total_spots_in_clusters'] = clusters.sum(axis=0)[3] if len(clusters) >0 else  0
         else :
-            frame_results['total_spots_in_clusters'] = clusters.sum(axis=0)[2]
+            frame_results['total_spots_in_clusters'] = clusters.sum(axis=0)[2] if len(clusters) >0 else  0
     
     if type(cell_label) != type(None) and type(nucleus_label) != type(None): 
         cell_result_dframe = launch_cell_extraction(
@@ -673,7 +729,7 @@ def get_nucleus_signal(image, other_images, user_parameters) :
             return np.zeros(shape=image.shape)
 
         if rna_signal_channel == nucleus_signal_channel :
-            nucleus_signal == image
+            nucleus_signal = image
         
         elif nucleus_signal_channel > rna_signal_channel :
             nucleus_signal_channel -=1
@@ -684,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-1.1.0 → small_fish_gui-1.3.0}/src/small_fish_gui/pipeline/main.py

@@ -2,7 +2,8 @@
 import pandas as pd
 import PySimpleGUI as sg
 from ..gui import hub_prompt
-from .actions import add_detection, save_results, compute_colocalisation
+from .actions import add_detection, save_results, compute_colocalisation, delete_acquisitions
+from ._preprocess import clean_unused_parameters_cache
 
 #'Global' parameters
 user_parameters = dict() # Very important object containg all choice from user that will influence the behavior of the main loop.
@@ -15,10 +16,15 @@ cytoplasm_label = None
 nucleus_label = None
 
 while True : #Break this loop to close small_fish
+    result_df = result_df.reset_index(drop=True)
+    cell_result_df = cell_result_df.reset_index(drop=True)
+    coloc_df = coloc_df.reset_index(drop=True)
     try :
         event, values = hub_prompt(result_df, segmentation_done)
 
         if event == 'Add detection' :
+            user_parameters = clean_unused_parameters_cache(user_parameters)
+            
 
             new_result_df, new_cell_result_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label, nucleus_label =  add_detection(
                 user_parameters=user_parameters,
@@ -64,8 +70,8 @@ while True : #Break this loop to close small_fish
             nucleus_label = None
 
         elif event == "Delete acquisitions" :
-        #TODO
-            pass
+            selected_acquisitions = values.setdefault('result_table', []) #Contains the lines selected by the user on the sum-up array.
+            result_df, cell_result_df, coloc_df = delete_acquisitions(selected_acquisitions, result_df, cell_result_df, coloc_df)
 
         elif event == "Batch detection" :
         #TODO

small_fish_gui-1.3.0/src/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.1.0/src/small_fish_gui/README.md

@@ -1,51 +0,0 @@
-# Small Fish
-**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.
-
-Cell segmentation (**2D**) is peformed using *cellpose* (published work) : https://github.com/MouseLand/cellpose; compatible with your own cellpose models.
-
-Spot detection is performed via *big-fish* (published work) : https://github.com/fish-quant/big-fish
-
-Time stacks are not yet supported.
-
-## What can you do with small fish ?
-
-- Single molecule quantification (including a lot of spatial features)
-- Foci/Transcription site quantification
-- Nuclear signal quantification
-- Signal to noise analysis
-- multichannel colocalisation
-
-## Installation
-
-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.
-
-```bash
-conda create -n small_fish python=3.8
-activate small_fish
-```
-Then download the small_fish package : 
-```bash
-pip install small_fish_gui
-```
-<b> (Recommended) </b> Results visualisation is achieved through *Napari* which you can install with :
-
-```bash
-pip install napari[all]
-```
-
-## Run Small fish
-
-First activate your python environnement : 
-```bash
-activate small_fish
-```
-Then launch Small fish : 
-```bash
-python -m small_fish_gui
-```
-## Developpement
-
-Optional features to include in future versions : 
-- batch processing
-- time stack (which would include cell tracking)
-- 3D segmentation

small_fish_gui-1.1.0/src/small_fish_gui/__main__.py

@@ -1,15 +0,0 @@
-import sys
-import os
-import PySimpleGUI as sg
-
-def main():
-    import small_fish_gui.pipeline.main
-
-
-if __name__ == "__main__":
-    try :
-        sys.exit(main())
-    except Exception as error :
-        sg.popup("Sorry. Something went wrong...\nIf you have some time to spare could you please communicate the error you encountered (next window) on :\nhttps://github.com/2Echoes/small_fish/issues.")
-        sg.popup_error_with_traceback(error)
-        raise error

small_fish_gui-1.1.0/src/small_fish_gui/start.py

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