small-fish-gui 1.10.4__py3-none-any.whl → 2.0.2__py3-none-any.whl

small_fish_gui/default_values.py

@@ -0,0 +1,51 @@
+""""
+Constant submodule to have a common reference for parameters default values
+"""
+import os
+
+#Image
+IS_MULTICHANNEL = False
+IS_3D_STACK = False
+CHANNEL = 0
+NUC_CHANNEL = 1
+
+#Segmentation
+FLOW_THRESHOLD = 0.4
+CELLPROB_THRESHOD = 0.
+CYTO_MODEL = "cpsam"
+NUC_MODEL = "cpsam"
+CYTO_DIAMETER = 90
+NUC_DIAMETER = 60
+ANISOTROPY = 1. 
+SHOW_SEGMENTATION = True
+SEGMENT_ONLY_NUCLEI = False
+DO_3D_SEMGENTATION = False
+VISUAL_PATH = os.getcwd()
+SAVE_SEGMENTATION_VISUAL = False
+
+#Detection
+THRESHOLD = None
+THRESHOLD_PENALTY = 1
+DO_DENSE_REGIONS_DECONVOLUTION = False
+DO_CLUSTER_COMPUTATION = False
+DO_CLUSTER_COMPUTATION = False
+SHOW_NAPARI_CORRECTOR = True
+INTERACTIVE_THRESHOLD = False
+
+#Deconvolution
+ALPHA = 0.5
+BETA = 1.
+GAMMA = 3.
+
+#Clustering
+CLUSTER_SIZE = 400
+MIN_NUMBER_SPOTS = 5
+
+#Coloc
+COLOC_RANGE = 400
+COLOC_VOXEL_SIZE = (1,2,3)
+
+#Spots Extraction
+DO_CSV = False
+DO_EXCEL = False
+SPOT_EXTRACTION_FOLDER = os.getcwd()

small_fish_gui/gui/__init__.py

@@ -24,4 +24,6 @@ from .layout import tuple_layout
 from .layout import radio_layout
 from .layout import add_header
 
-from .animation import add_default_loading
+from .animation import add_default_loading
+
+from .theme import default_theme

small_fish_gui/gui/_napari_widgets.py

@@ -158,21 +158,32 @@ class ChangesPropagater(NapariWidget) :
     """
     def __init__(self, label_list):
         self.label_list = label_list
+        for label_layer in self.label_list :
+            label_layer.events.selected_label.connect((self, 'update'))
         super().__init__()
 
     def _create_widget(self) :
         @magicgui(
-            call_button='Apply changes',
+            call_button='Expand label',
             auto_call=False,
         )
-        def apply_changes() -> None:
+        def apply_changes(label_number : int) -> None:
             for layer in self.label_list :
                 slices = layer.data.shape[0]
-                layer_2D = np.max(layer.data, axis=0)
-                layer.data = np.repeat(layer_2D[np.newaxis], slices, axis=0)
+                masked_layer = layer.data.copy()
+                masked_layer[masked_layer != label_number] = 0
+                masked_layer = np.max(masked_layer, axis=0)
+                expanded_layer = np.repeat(masked_layer[np.newaxis], slices, axis=0)
+                layer.data[expanded_layer == label_number] = expanded_layer[expanded_layer == label_number]
                 layer.refresh()
         return apply_changes
 
+    def update(self, event) :
+        layer : Labels = event.source
+        new_label = layer.selected_label
+        self.widget.label_number.value = new_label
+        self.widget.update()
+
 class ClusterIDSetter(ClusterWidget) :
     """
     Allow user to set selected single spots to chosen cluster_id

small_fish_gui/gui/layout.py

@@ -1,12 +1,13 @@
 import FreeSimpleGUI as sg
 import os
-from ..utils import check_parameter
-from ..hints import pipeline_parameters
-from typing import Optional, Union
 import cellpose.models as models
-from cellpose.core import use_gpu
+import small_fish_gui.default_values as default
+from typing import Optional, Union
 
-sg.theme('DarkAmber')
+from cellpose.core import use_gpu
+from .tooltips import FLOW_THRESHOLD_TOOLTIP,CELLPROB_TOOLTIP
+from ..hints import pipeline_parameters
+from ..utils import check_parameter
 
 
 def add_header(header_text) :
@@ -20,13 +21,29 @@ def pad_right(string, length, pad_char) :
     else : return string + pad_char* (length - len(string))
     
 
-def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, default_values=None, size=5, opt:list=None) :
+def parameters_layout(
+        parameters:'list[str]' = [], 
+        unit=None, 
+        header= None, 
+        default_values=None, 
+        keys = None,
+        tooltips = None,
+        size=5, 
+        opt:list=None
+        ) :
 
     if len(parameters) == 0 : return []
     check_parameter(parameters= list, header = (str, type(None)))
     for key in parameters : check_parameter(key = str)
     max_length = len(max(parameters, key=len))
 
+    if keys is None : keys = [None] * len(parameters)
+    else :
+        if len(keys) != len(parameters) : raise ValueError("keys length must be equal with parameters length or set to None.")
+    if tooltips is None : tooltips = [None] * len(parameters)
+    else :
+        if len(tooltips) != len(parameters) : raise ValueError("tooltips length must be equal with parameters length or set to None.")
+
     if type(opt) == type(None) :
         opt = [False] * len(parameters)
     else :
@@ -35,10 +52,11 @@ def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, defa
     if isinstance(default_values, (list, tuple)) :
         if len(default_values) != len(parameters) : raise ValueError("if default values specified it must be of equal length as parameters.")
         layout= [
-            [sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
-             sg.InputText(size= size, key= parameter, default_text= value)
-             
-             ] for parameter,value, option in zip(parameters,default_values, opt)
+            [
+                sg.Text("{0}".format(pad_right(parameter, max_length, ' ')), text_color= 'green' if option else None), 
+                sg.InputText(size= size, key= parameter if key is None else key, default_text= value, tooltip=tooltip)
+            
+            ] for parameter,value, option, key, tooltip in zip(parameters,default_values, opt, keys, tooltips)
         ]
     else :
         layout= [
@@ -56,7 +74,7 @@ def parameters_layout(parameters:'list[str]' = [], unit=None, header= None, defa
         layout = [add_header(header)] + layout
     return layout
 
-def tuple_layout(opt=None, default_dict={}, unit:dict={}, **tuples) :
+def tuple_layout(opt=None, default_dict={}, unit:dict={}, names : dict = {}, **tuples) :
     """
     tuples example : voxel_size = ['z','y','x']; will ask a tuple with 3 element default to 'z', 'y' 'x'.
     """
@@ -77,9 +95,9 @@ def tuple_layout(opt=None, default_dict={}, unit:dict={}, **tuples) :
     max_size = len(max(tuples.keys(), key=len))
     
     layout = [
-        [sg.Text(pad_right(tup, max_size, ' '), text_color= 'green' if opt[option] else None)] 
+        [sg.Text(pad_right(names[tup] if tup in names.keys() else tup, max_size, ' '), text_color= 'green' if opt[option] else None)] 
         + [sg.InputText(default_text=default_dict.setdefault('{0}_{1}'.format(tup,elmnt), elmnt),key= '{0}_{1}'.format(tup, elmnt), size= 5) for elmnt in tuples[tup]]
-        + [sg.Text(unit.setdefault(tup,''))] 
+        + [sg.Text(unit.setdefault(tup,''))]
         for tup,option, in zip(tuples,opt)
     ]
 
@@ -96,9 +114,13 @@ def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd())
     else : Browse = sg.FileBrowse
 
     max_length = len(max(keys, key=len))
-    layout = [
-        [sg.Text(pad_right(name, max_length, ' ')), Browse(key= name, target=(555666777,2), initial_folder= preset), sg.Text('')] for name in keys
-        ]
+
+    layout = []
+    for name in keys :
+        layout += [
+            [sg.Text(pad_right(name, max_length, ' '))], 
+            [sg.InputText(key= name, expand_x=True, default_text=preset), Browse(key= name + "_browse", initial_folder= preset), sg.Text('')],
+            ]
     if isinstance(header, str) :
         layout = [add_header(header)] + layout
     return layout
@@ -163,18 +185,25 @@ def radio_layout(values, header=None, key=None) :
     return layout
 
 def _segmentation_layout(
-        multichannel, 
-        cytoplasm_model_preset= 'cyto3', 
-        nucleus_model_preset= 'nuclei', 
-        cytoplasm_channel_preset=0, 
-        nucleus_channel_preset=0, 
+        multichannel : bool,
+        is_3D_stack : bool,
+        cytoplasm_model_preset= default.CYTO_MODEL, 
+        nucleus_model_preset= default.NUC_MODEL, 
+        cytoplasm_channel_preset=default.CHANNEL, 
+        nucleus_channel_preset=default.NUC_CHANNEL, 
         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(), 
+        cyto_diameter_preset=default.CYTO_DIAMETER, 
+        nucleus_diameter_preset= default.NUC_DIAMETER, 
+        show_segmentation_preset= default.SHOW_SEGMENTATION,
+        save_segmentation_visual_preset = default.SAVE_SEGMENTATION_VISUAL, 
+        segment_only_nuclei_preset=default.SEGMENT_ONLY_NUCLEI, 
+        saving_path_preset=default.VISUAL_PATH, 
         filename_preset='cell_segmentation.png',
+        cytoplasm_segmentation_3D = default.DO_3D_SEMGENTATION,
+        nucleus_segmentation_3D = default.DO_3D_SEMGENTATION,
+        cellprob_threshold = default.CELLPROB_THRESHOD,
+        flow_threshold = default.FLOW_THRESHOLD,
+        anisotropy= default.ANISOTROPY,
         ) :
     
     USE_GPU = use_gpu()
@@ -189,30 +218,51 @@ def _segmentation_layout(
     
     #cytoplasm parameters
     layout += [
-        add_header("Cell Segmentation"),
-        [sg.Text("Choose cellpose model for cytoplasm: \n")],
-        combo_elmt(models_list, key='cyto_model_name', default_value= cytoplasm_model_preset)
+        add_header("Cytoplasm Segmentation"),
+        [sg.Text("Choose parameters for cytoplasm segmentation: \n")],
                         ]
                         
-    if multichannel : layout += parameters_layout(['cytoplasm channel'],default_values= [cytoplasm_channel_preset])
+    if is_3D_stack : layout += bool_layout(['3D segmentation'], preset=[cytoplasm_segmentation_3D], keys=['cytoplasm_segmentation_3D'],)
+    if multichannel : layout += parameters_layout(['Cytoplasm channel'],default_values= [cytoplasm_channel_preset], keys = ["cytoplasm_channel"])
 
+    layout += [[sg.Text("Cellpose model : ")] + combo_elmt(models_list, key='cyto_model_name', default_value= cytoplasm_model_preset)]
+    layout += parameters_layout(['Cytoplasm diameter'], unit= "px", default_values= [cyto_diameter_preset], keys=['cytoplasm_diameter'])
+    layout += parameters_layout(
+        ["Flow threshold", "Cellprob threshold"], 
+        default_values=[flow_threshold, cellprob_threshold], 
+        keys=["flow_threshold_cyto","cellprob_threshold_cyto"],
+        tooltips= [FLOW_THRESHOLD_TOOLTIP, CELLPROB_TOOLTIP]
+        )
 
-    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_elmt(models_list, key='nucleus_model_name', default_value= nucleus_model_preset)
+            add_header("Nuclei segmentation"),
+            [sg.Text("Choose parameters for nuclei segmentation: \n")],
                 ]
     
-    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)
+    if is_3D_stack : layout += bool_layout(['3D segmentation'], preset=[nucleus_segmentation_3D], keys=['nucleus_segmentation_3D'],)
+    if multichannel : layout += parameters_layout(['nucleus_channel'], default_values= [nucleus_channel_preset])
+    layout += bool_layout(["Segment only nuclei"], preset=segment_only_nuclei_preset, keys=["segment_only_nuclei"])
     
+    layout += [[sg.Text("Cellpose model : ")] + combo_elmt(models_list, key='nucleus_model_name', default_value= nucleus_model_preset)]
+    layout += parameters_layout(['Nucleus diameter'],unit= "px", default_values= [nucleus_diameter_preset], keys=['nucleus_diameter'])
+    layout += parameters_layout(
+        ["Flow threshold", "Cellprob threshold"], 
+        default_values=[flow_threshold, cellprob_threshold], 
+        keys=["flow_threshold_nuc","cellprob_threshold_nuc"],
+        tooltips= [FLOW_THRESHOLD_TOOLTIP, CELLPROB_TOOLTIP]
+        )
+    if is_3D_stack : layout += parameters_layout(
+        ['anisotropy'], 
+        header = "Model parameters",
+        default_values = [anisotropy]
+        )
+
     #Control plots
-    layout += bool_layout(['show segmentation'], header= 'Segmentation plots', preset= show_segmentation_preset)
-    layout += path_layout(['saving path'], look_for_dir=True, preset=saving_path_preset)
+    layout += bool_layout(['Show_segmentation'],keys=['show_segmentation'], header= 'Segmentation plots', preset= show_segmentation_preset)
+    layout += bool_layout(['Save segmentation visual'], preset= save_segmentation_visual_preset, keys=['save_segmentation_visual'])
+    layout += path_layout(keys=['saving path'], look_for_dir=True, preset=saving_path_preset)
     layout += parameters_layout(['filename'], default_values=[filename_preset], size= 25)
 
     return layout
@@ -254,7 +304,7 @@ def _detection_layout(
 
     #Detection
     detection_parameters = ['threshold', 'threshold penalty']
-    default_detection = [default_dict.setdefault('threshold',''), default_dict.setdefault('threshold penalty', '1')]
+    default_detection = [default_dict.setdefault('threshold',default.THRESHOLD), default_dict.setdefault('threshold penalty', default.THRESHOLD_PENALTY)]
     opt= [True, True]
     if is_multichannel : 
         detection_parameters += ['channel_to_compute']
@@ -268,34 +318,31 @@ def _detection_layout(
     else : tuple_shape = ('z','y','x')
     opt = {'voxel_size' : False, 'spot_size' : False, 'log_kernel_size' : True, 'minimum_distance' : True}
     unit = {'voxel_size' : 'nm', 'minimum_distance' : 'nm', 'spot_size' : 'radius(nm)', 'log_kernel_size' : 'px'}
+    names = {'voxel_size' : 'Voxel size', 'spot_size' : 'Spot size', 'log_kernel_size' : 'LoG kernel size', 'minimum_distance' : 'Minimum distance between spots'}
 
-    layout += tuple_layout(opt=opt, unit=unit, default_dict=default_dict, voxel_size= tuple_shape, spot_size= tuple_shape, log_kernel_size= tuple_shape, minimum_distance= tuple_shape)
+    layout += tuple_layout(opt=opt, unit=unit, default_dict=default_dict, names=names, voxel_size= tuple_shape, spot_size= tuple_shape, log_kernel_size= tuple_shape, minimum_distance= tuple_shape)
     
     if (do_segmentation and is_multichannel) or (is_multichannel and segmentation_done):
-        default_segmentation = [default_dict.setdefault('nucleus channel signal', default_dict.setdefault('nucleus channel',0))]
-        layout += [[sg.Text("nucleus channel signal "), sg.InputText(default_text=default_segmentation, key= "nucleus channel signal", size= 5, tooltip= "Channel from which signal will be measured for nucleus features, \nallowing you to measure signal from a different channel than the one used for segmentation.")]]
-        # layout += parameters_layout(['nucleus channel signal'], default_values=default_segmentation) + [[sg.Text("Channel from which signal will be measured for nucleus features, allowing you to measure signal from a different channel than the one used for segmentation.")]]
+        layout += [[sg.Text("nucleus channel signal "), sg.InputText(default_text=default_dict.setdefault('nucleus_channel',default.NUC_CHANNEL), key= "nucleus channel signal", size= 5, tooltip= "Channel from which signal will be measured for nucleus features, \nallowing you to measure signal from a different channel than the one used for segmentation.")]]
     
     #Deconvolution
     if do_dense_region_deconvolution :
-        default_dense_regions_deconvolution = [default_dict.setdefault('alpha',0.5), default_dict.setdefault('beta',1)]
+        default_dense_regions_deconvolution = [default_dict.setdefault('alpha',default.ALPHA), default_dict.setdefault('beta',default.BETA)]
         layout += parameters_layout(['alpha', 'beta',], default_values= default_dense_regions_deconvolution, header= 'do_dense_regions_deconvolution')
-        layout += parameters_layout(['gamma'], unit= 'px', default_values= [default_dict.setdefault('gamma',5)])
+        layout += parameters_layout(['gamma'], unit= 'px', default_values= [default_dict.setdefault('gamma',default.GAMMA)])
         layout += tuple_layout(opt= {"deconvolution_kernel" : True}, unit= {"deconvolution_kernel" : 'px'}, default_dict=default_dict, deconvolution_kernel = tuple_shape)
     
     #Clustering
     if do_clustering :
-        layout += parameters_layout(['cluster_size'], unit="radius(nm)", default_values=[default_dict.setdefault('cluster_size',400)])
-        layout += parameters_layout(['min_number_of_spots'], default_values=[default_dict.setdefault('min_number_of_spots', 5)])
+        layout += parameters_layout(['Cluster radius'],keys=['cluster_size'], unit="radius(nm)", default_values=[default_dict.setdefault('cluster_size',default.CLUSTER_SIZE)])
+        layout += parameters_layout(['Min nb spots per cluster'],keys=['min_number_of_spots'], default_values=[default_dict.setdefault('min_number_of_spots', default.MIN_NUMBER_SPOTS)])
 
-    
-
-    layout += bool_layout(['Interactive threshold selector'],keys = ['show_interactive_threshold_selector'], preset=[False])
+    layout += bool_layout(['Interactive threshold selector'],keys = ['show_interactive_threshold_selector'], preset=[default.INTERACTIVE_THRESHOLD])
     layout += path_layout(
         keys=['spots_extraction_folder'],
         look_for_dir=True,
         header= "Individual spot extraction",
-        preset= default_dict.setdefault('spots_extraction_folder', '')
+        preset= default_dict.setdefault('spots_extraction_folder', default.SPOT_EXTRACTION_FOLDER)
     )
     default_filename = default_dict.setdefault("filename","") + "_spot_extraction"
     layout += parameters_layout(
@@ -304,12 +351,34 @@ def _detection_layout(
         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)]
+        ['.csv','.excel',],
+        keys= ['do_spots_csv', 'do_spots_excel'],
+        preset= [default_dict.setdefault('do_spots_csv',default.DO_CSV), default_dict.setdefault('do_spots_excel',default.DO_EXCEL),]
     )
 
     return layout
 
+def colocalization_layout(spot_list : list) :
+    layout = [
+        [sg.Push(), sg.Text("Co-localization", size=25, font="bold"), sg.Push()],
+        [sg.VPush()],
+        [sg.Text("Spots 1", size = 10)],
+        [sg.DropDown(values=[""] + spot_list, key="spots1_dropdown"), sg.Input(disabled=True, text_color="black"),sg.FileBrowse("Load spot extraction", key="spots1_browse")],
+        [sg.Text("Spots 2", size = 10)],
+        [sg.DropDown(values=[""] + spot_list, key="spots2_dropdown"), sg.Input(disabled=True, text_color="black"),sg.FileBrowse("Load spot extraction", key="spots2_browse")],
+    ]
+
+    layout += parameters_layout(['colocalisation distance'], unit= 'nm', default_values= default.COLOC_RANGE,)
+
+    layout += tuple_layout(opt={'voxel_size' : False},unit={'voxel_size' : "nm"}, voxel_size = ['z','y','x'], names={'voxel_size' : 'Voxel size'}, default_dict={'voxel_size' : default.COLOC_VOXEL_SIZE},)
+    layout += [[sg.Text("   'voxel size' is used only for loaded spot lists.")]]
+
+    layout += [[sg.Push(),sg.Button("Ok", bind_return_key=True),sg.Button("Cancel"),sg.Push(),],
+        [sg.VPush()]
+    ]
+
+    return layout
+
 def _ask_channel_map_layout(
         shape,
         is_3D_stack,

small_fish_gui/gui/napari_visualiser.py

@@ -134,7 +134,7 @@ def correct_spots(
         new_clusters = np.concatenate([
             cluster_layer.data,
             cluster_layer.features.loc[:,["spot_number","cluster_id"]].to_numpy()
-        ],axis=1)
+        ],axis=1).astype(int)
 
         new_spots = np.concatenate([
             single_layer.data,
@@ -145,7 +145,7 @@ def correct_spots(
         new_min_spot_number = widget_cluster_updater.min_spot
 
     else :
-        new_spots = single_layer.data 
+        new_spots = single_layer.data.astype(int) 
         new_clusters = None
         new_cluster_radius = None
         new_min_spot_number = None
@@ -159,6 +159,7 @@ def show_segmentation(
         nuc_label : np.ndarray,
         cyto_image : np.ndarray = None,
         cyto_label : np.ndarray = None,
+        anisotrpy : float = 1,
 ) :
     dim = nuc_image.ndim
     
@@ -186,16 +187,18 @@ def show_segmentation(
     #Init Napari viewer
     Viewer = napari.Viewer(ndisplay=2, title= 'Show segmentation', axis_labels=['z','y','x'] if dim == 3 else ['y', 'x'])
     
+    scale = (anisotrpy, 1, 1)
+
     # Adding nuclei
-    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.6, name= 'nucleus_label',)
+    nuc_signal_layer = Viewer.add_image(nuc_image, name= "nucleus signal", blending= 'additive', colormap='blue', contrast_limits=[nuc_image.min(), nuc_image.max()], scale=scale)
+    nuc_label_layer = Viewer.add_labels(nuc_label, opacity= 0.6, name= 'nucleus_label', scale=scale)
     nuc_label_layer.preserve_labels = True
     labels_layer_list = [nuc_label_layer]
     
     #Adding cytoplasm
     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): 
-        Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()])
-        cyto_label_layer = Viewer.add_labels(cyto_label, opacity= 0.6, name= 'cytoplasm_label')
+        Viewer.add_image(cyto_image, name= "cytoplasm signal", blending= 'additive', colormap='red', contrast_limits=[cyto_image.min(), cyto_image.max()], scale=scale)
+        cyto_label_layer = Viewer.add_labels(cyto_label, opacity= 0.6, name= 'cytoplasm_label', scale=scale)
         cyto_label_layer.preserve_labels = True
         labels_layer_list += [cyto_label_layer]
 
@@ -205,9 +208,10 @@ def show_segmentation(
     label_reseter = SegmentationReseter(labels_layer_list)
     changes_applier = ChangesPropagater(labels_layer_list)
 
-    buttons_container = widgets.Container(widgets=[label_picker.widget, changes_applier.widget, label_reseter.widget], labels=False, layout='horizontal')
+    buttons_container = widgets.Container(widgets=[label_picker.widget, label_reseter.widget], labels=False, layout='horizontal')
+    changes_applier = widgets.Container(widgets=[changes_applier.widget], labels=False, layout='horizontal')
     tools_container = widgets.Container(
-        widgets = [buttons_container, label_eraser.widget],
+        widgets = [buttons_container, changes_applier, label_eraser.widget],
         labels=False,
     )
     Viewer.window.add_dock_widget(tools_container, name='SmallFish', area='left')

small_fish_gui/gui/prompts.py

@@ -2,8 +2,19 @@ import FreeSimpleGUI as sg
 import pandas as pd
 import os
 import numpy as np
-from typing import Literal, Union, Any
-from .layout import path_layout, parameters_layout, bool_layout, tuple_layout, combo_elmt, add_header, path_layout, radio_layout
+import small_fish_gui.default_values as default
+
+from typing import Literal, Union
+from .layout import (
+    path_layout,
+    parameters_layout,
+    bool_layout,
+    path_layout, 
+    radio_layout,
+    colocalization_layout,
+    tuple_layout,
+    _detection_layout
+    )
 from ..interface import open_image, check_format, FormatError
 
 
@@ -13,12 +24,9 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY',
     """
     if add_ok_cancel : layout += [[sg.Button('Ok', bind_return_key=True), sg.Button('Cancel')]]
 
-    if add_scrollbar :
-        size = (400,500)
-        col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size)
-        layout = [[col_elmt]]
-    else :
-        size = (None,None)
+    size = (400,500)
+    col_elmt = sg.Column(layout, scrollable=True, vertical_scroll_only=True, size=size, expand_x=True, expand_y=True)
+    layout = [[col_elmt]]
     
     window = sg.Window('small fish', layout=layout, margins=(10,10), size=size, resizable=True, location=None)
     event, values = window.read(timeout=timeout, timeout_key=timeout_key)
@@ -33,8 +41,6 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY',
         window.close()
         return event, values
 
-
-
 def input_image_prompt(
         is_3D_stack_preset=False,
         multichannel_preset = False,
@@ -90,15 +96,16 @@ def output_image_prompt(filename) :
         layout = path_layout(['folder'], look_for_dir= True, header= "Output parameters :")
         layout += parameters_layout(["filename"], default_values= [filename + "_quantification"], size=25)
         layout += bool_layout(['csv','Excel', 'Feather'])
-        layout.append([sg.Button('Cancel')])
 
         event,values= prompt(layout)
+        if event == ('Cancel') : return None
 
         values['filename'] = values['filename'].replace(".xlsx","")
         values['filename'] = values['filename'].replace(".feather","")
         excel_filename = values['filename'] + ".xlsx"
         feather_filename = values['filename'] + ".feather"
 
+
         if not values['Excel'] and not values['Feather'] and not values['csv'] :
             sg.popup("Please check at least one box : Excel/Feather/csv")
             relaunch = True
@@ -118,9 +125,7 @@ def output_image_prompt(filename) :
 
         if not relaunch : break
 
-    if event == ('Cancel') : return None
-
-    else : return values
+    return values
 
 def detection_parameters_promt(
         is_3D_stack, 
@@ -135,60 +140,15 @@ def detection_parameters_promt(
     Returns Values
         
     """
-    if is_3D_stack : dim = 3
-    else : dim = 2
-
-    #Detection
-    detection_parameters = ['threshold', 'threshold penalty']
-    default_detection = [default_dict.setdefault('threshold',''), default_dict.setdefault('threshold penalty', '1')]
-    opt= [True, True]
-    if is_multichannel : 
-        detection_parameters += ['channel_to_compute']
-        opt += [False]
-        default_detection += [default_dict.setdefault('channel_to_compute', '')]
-    layout = [[sg.Text("Green parameters", text_color= 'green'), sg.Text(" are optional parameters.")]]
-    layout += parameters_layout(detection_parameters, header= 'Detection', opt=opt, default_values=default_detection)
-    
-    if dim == 2 : tuple_shape = ('y','x')
-    else : tuple_shape = ('z','y','x')
-    opt = {'voxel_size' : False, 'spot_size' : False, 'log_kernel_size' : True, 'minimum_distance' : True}
-    unit = {'voxel_size' : 'nm', 'minimum_distance' : 'nm', 'spot_size' : 'radius(nm)', 'log_kernel_size' : 'px'}
-
-    layout += tuple_layout(opt=opt, unit=unit, default_dict=default_dict, voxel_size= tuple_shape, spot_size= tuple_shape, log_kernel_size= tuple_shape, minimum_distance= tuple_shape)
-
-    #Deconvolution
-    if do_dense_region_deconvolution :
-        default_dense_regions_deconvolution = [default_dict.setdefault('alpha',0.5), default_dict.setdefault('beta',1)]
-        layout += parameters_layout(['alpha', 'beta',], default_values= default_dense_regions_deconvolution, header= 'do_dense_regions_deconvolution')
-        layout += parameters_layout(['gamma'], unit= 'px', default_values= [default_dict.setdefault('gamma',5)])
-        layout += tuple_layout(opt= {"deconvolution_kernel" : True}, unit= {"deconvolution_kernel" : 'px'}, default_dict=default_dict, deconvolution_kernel = tuple_shape)
     
-    #Clustering
-    if do_clustering :
-        layout += parameters_layout(['cluster_size'], unit="radius(nm)", default_values=[default_dict.setdefault('cluster_size',400)])
-        layout += parameters_layout(['min_number_of_spots'], default_values=[default_dict.setdefault('min_number_of_spots', 5)])
-
-    if is_multichannel and segmentation_done :
-        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'], keys=['show_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', '')
-    )
-    default_filename = default_dict.setdefault("filename","") + "_spot_extraction"
-    layout += parameters_layout(
-        parameters=['spots_filename'],
-        default_values=[default_filename],
-        size= 13
-    )
-    layout += bool_layout(
-        ['.csv','.excel','.feather'],
-        keys= ['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)]
+    layout = _detection_layout(
+        is_3D_stack=is_3D_stack, 
+        is_multichannel=is_multichannel, 
+        do_dense_region_deconvolution=do_dense_region_deconvolution, 
+        do_clustering=do_clustering,
+        segmentation_done=segmentation_done, 
+        default_dict=default_dict,
+        do_segmentation=False,
     )
 
     event, values = prompt(layout)
@@ -268,18 +228,45 @@ def hub_prompt(fov_results : pd.DataFrame, do_segmentation=False) -> 'Union[Lite
     while True : 
         event, values = window.read()
         if event == None : quit()
-        elif event == 'Help' : pass
         else : 
             window.close()
             return event, values
 
-def coloc_prompt() :
-    layout = parameters_layout(['colocalisation distance'], unit= 'nm', header= 'Colocalisation', default_values= 0)
-    event, values = prompt(layout)
+def coloc_prompt(spot_list : list) :
+    layout = colocalization_layout(spot_list)
 
-    if event == 'Ok' :
-        return values['colocalisation distance']
-    else : return False
+    layout = [[sg.Col(
+        layout,
+        expand_x=True,
+        expand_y=True,
+        vertical_scroll_only=True,
+        scrollable=True
+    )
+    ]]
+    window = sg.Window('small fish', layout=layout, margins=(10,10), resizable=True, location=None, auto_size_buttons=True)
+    while True : 
+        event, values = window.read(timeout=100, timeout_key="timeout")
+
+        if event == None : quit()
+        elif event == "timeout" : pass
+        elif event == 'Ok' :
+            
+            if values["spots1_dropdown"] =="" :
+                spots1 = values["spots1_browse"]
+            else :
+                spots1 = values["spots1_dropdown"]
+
+            if values["spots2_dropdown"] =="" :
+                spots2 = values["spots2_browse"]
+            else :
+                spots2 = values["spots2_dropdown"]
+            
+
+            window.close()
+            return values['colocalisation distance'], [values['voxel_size_z'], values['voxel_size_y'], values['voxel_size_x']], spots1, spots2
+        else : 
+            window.close()
+            return None,None,None,None
 
 def rename_prompt() :
     layout = parameters_layout(['name'], header= "Rename acquisitions", size=12)