small-fish-gui 1.7.1__py3-none-any.whl → 1.8.1__py3-none-any.whl

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.7.1"
+__version__ = "1.8.1"

small_fish_gui/batch/integrity.py

@@ -9,7 +9,7 @@ import numpy as np
 import PySimpleGUI as sg
 
 from ..pipeline._preprocess import check_integrity, convert_parameters_types, ParameterInputError, _check_segmentation_parameters
-from ..pipeline._segmentation import _cast_segmentation_parameters
+from ..pipeline.segmentation import _cast_segmentation_parameters
 
 def check_file(filename:str) :
 
@@ -105,7 +105,7 @@ def check_detection_parameters(
         do_clustering,
         is_multichannel,
         is_3D,
-        map,
+        map_,
         shape
 ) :
     
@@ -118,7 +118,7 @@ def check_detection_parameters(
             do_clustering=do_clustering,
             multichannel=is_multichannel,
             segmentation_done=None,
-            map=map,
+            map_=map_,
             shape=shape
         )
     except ParameterInputError as e: 

small_fish_gui/batch/pipeline.py

@@ -6,6 +6,8 @@ import os
 import pandas as pd
 import PySimpleGUI as sg
 
+from ..hints import pipeline_parameters
+
 from .input import open_image
 from ..interface import write_results
 from ..pipeline import reorder_shape, reorder_image_stack, prepare_image_detection
@@ -24,10 +26,10 @@ def batch_pipeline(
         batch_window : sg.Window,
         batch_progress_bar : sg.ProgressBar,
         progress_count : sg.Text,
-        parameters : dict,
+        parameters : pipeline_parameters,
         filenames_list : list,
         do_segmentation : bool,
-        map : dict,
+        map_ : dict,
         results_df : pd.DataFrame,
         cell_results_df : pd.DataFrame,
         is_3D,
@@ -73,12 +75,12 @@ def batch_pipeline(
         #1. Re-order shape
         shape = image.shape
         parameters['shape'] = shape
-        parameters['reordered_shape'] = reorder_shape(shape, map=map)
+        parameters['reordered_shape'] = reorder_shape(shape, map_=map_)
 
         #2. Segmentation (opt)
         if do_segmentation :
             window_print(batch_window,"Segmenting cells...")
-            im_seg = reorder_image_stack(map, parameters)
+            im_seg = reorder_image_stack(map_, image)
             parameters = _cast_segmentation_parameters(parameters)
             cytoplasm_label, nucleus_label = cell_segmentation(
                 im_seg,
@@ -90,6 +92,8 @@ def batch_pipeline(
                 do_only_nuc=parameters['Segment only nuclei']
                 )
             
+            parameters['segmentation_done'] = True
+
             if cytoplasm_label.max() == 0 : #No cell segmented
                 window_print(batch_window,"No cell was segmented, computing next image.")
                 continue
@@ -108,11 +112,12 @@ def batch_pipeline(
 
         else :
             cytoplasm_label, nucleus_label = None,None
+            parameters['segmentation_done'] = False
 
         #3. Detection, deconvolution, clusterisation
         window_print(batch_window,"Detecting spots...")
         parameters = convert_parameters_types(parameters)
-        image, other_image = prepare_image_detection(map, parameters) 
+        image, other_image = prepare_image_detection(map_, parameters) 
         nucleus_signal = get_nucleus_signal(image, other_image, parameters)
         try : # Catch error raised if user enter a spot size too small compare to voxel size
             parameters, frame_result, spots, clusters = launch_detection(
@@ -132,7 +137,10 @@ def batch_pipeline(
                 raise(error)
         
         if parameters['save detection'] :
-            if parameters['Cluster computation'] : spots_list = [spots, clusters[:,:parameters['dim']]]
+            if parameters['do_cluster_computation'] : 
+                if len(clusters) > 0 :
+                    spots_list = [spots, clusters[:,:parameters['dim']]]
+                else : spots_list = [spots]
             else : spots_list = [spots]
             output_spot_tiffvisual(
                 image,

small_fish_gui/batch/prompt.py

@@ -45,18 +45,18 @@ def batch_promp(
     #Input tab
     input_layout = _input_parameters_layout(
         ask_for_segmentation=True,
-        is_3D_stack_preset= preset.setdefault("3D stack" ,False),
+        is_3D_stack_preset= preset.setdefault("is_3D_stack" ,False),
         time_stack_preset=False,
-        multichannel_preset=preset.setdefault("multichannel" ,False),
-        do_dense_regions_deconvolution_preset=preset.setdefault("Dense regions deconvolution" ,False),
-        do_clustering_preset= preset.setdefault("Cluster computation", False),
+        multichannel_preset=preset.setdefault("is_multichannel" ,False),
+        do_dense_regions_deconvolution_preset=preset.setdefault("do_dense_regions_deconvolution" ,False),
+        do_clustering_preset= preset.setdefault("do_cluster_computation", False),
         do_Napari_correction=False,
-        do_segmentation_preset= preset.setdefault("Segmentation", False),
+        do_segmentation_preset= preset.setdefault("segmentation_done", False),
     )
     input_layout += [[sg.Button('Ok')]]
     input_tab = sg.Tab("Input", input_layout)
 
-    napari_correction_elmt = get_elmt_from_key(input_tab, key='Napari correction')
+    napari_correction_elmt = get_elmt_from_key(input_tab, key='show_napari_corrector')
 
     #Maptab
     map_layout = _ask_channel_map_layout(
@@ -86,7 +86,7 @@ def batch_promp(
     
     apply_segmentation_button = sg.Button('apply', key='apply-segmentation')
     segmentation_layout += [[apply_segmentation_button]]
-    seg_keys_to_hide = ['show segmentation', 'saving path', 'filename']
+    seg_keys_to_hide = ['show segmentation', 'saving path', 'filename', 'other_nucleus_image']
     segmentation_tab = sg.Tab("Segmentation", segmentation_layout, visible=False)
 
     #Detection tab
@@ -228,11 +228,11 @@ def batch_promp(
                 print("Welcome to small fish batch analysis. Please start by loading some files and setting parameters.")
 
             batch_folder = values.get('Batch_folder')
-            is_multichanel = values.get('multichannel')
-            is_3D = values.get('3D stack')
-            do_segmentation = values.get('Segmentation')
-            do_dense_regions_deconvolution = values.get('Dense regions deconvolution')
-            do_clustering = values.get('Cluster computation')
+            is_multichanel = values.get('is_multichannel')
+            is_3D = values.get('is_3D_stack')
+            do_segmentation = values.get('do_segmentation')
+            do_dense_regions_deconvolution = values.get('do_dense_regions_deconvolution')
+            do_clustering = values.get('do_cluster_computation')
 
             if type(batch_folder) != type(None)  and event == 'Load':
 
@@ -321,7 +321,7 @@ def batch_promp(
                     do_clustering=do_clustering,
                     is_multichannel=is_multichanel,
                     is_3D=is_3D,
-                    map= Master_parameters_dict.get('_map'),
+                    map_= Master_parameters_dict.get('_map'),
                     shape=last_shape
                 )
 
@@ -350,7 +350,7 @@ def batch_promp(
                     parameters=values,
                     filenames_list=filename_list,
                     do_segmentation=do_segmentation,
-                    map= Master_parameters_dict['_map'],
+                    map_= Master_parameters_dict['_map'],
                     results_df=results_df,
                     cell_results_df=cell_results_df,
                     is_3D=is_3D,

small_fish_gui/batch/update.py

@@ -36,7 +36,7 @@ def update_detection_tab(
     
     #Acess elements
     ##Detection
-    channel_to_compute = get_elmt_from_key(tab_elmt, key= 'channel to compute')
+    channel_to_compute = get_elmt_from_key(tab_elmt, key= 'channel_to_compute')
     voxel_size_z = get_elmt_from_key(tab_elmt, key= 'voxel_size_z')
     spot_size_z = get_elmt_from_key(tab_elmt, key= 'spot_size_z')
     log_kernel_size_z = get_elmt_from_key(tab_elmt, key= 'log_kernel_size_z')
@@ -58,7 +58,7 @@ def update_detection_tab(
     nucleus_channel_signal = get_elmt_from_key(tab_elmt, key= 'nucleus channel signal')
     
     #disable
-    interactive_threshold_selector = get_elmt_from_key(tab_elmt, key= 'Interactive threshold selector')
+    interactive_threshold_selector = get_elmt_from_key(tab_elmt, key= 'show_interactive_threshold_selector')
 
     update_dict={
         'is_3D' : is_3D,

small_fish_gui/batch/utils.py

@@ -16,12 +16,12 @@ def call_auto_map(
     ) :
     
     if len(shape) < 2 + is_3D + is_multichannel :
-        sg.popup("Image is of dimension {0} and you're trying to map {1} dimensions".format(len(shape), 2+is_3D+is_multichannel))
+        sg.popup("Image is of dimension {0} and you're trying to map_ {1} dimensions".format(len(shape), 2+is_3D+is_multichannel))
         return {}
 
-    #Get auto map
+    #Get auto map_
     try :
-        map = _auto_map_channels(
+        map_ = _auto_map_channels(
             is_3D_stack=is_3D,
             is_time_stack=False,
             multichannel=is_multichannel,
@@ -41,12 +41,12 @@ def call_auto_map(
         c_elmt = get_elmt_from_key(tab_elmt, 'c')
 
         #Update values
-        x_elmt.update(value=map.get('x'))
-        y_elmt.update(value=map.get('y'))
-        z_elmt.update(value=map.get('z'))
-        c_elmt.update(value=map.get('c'))
+        x_elmt.update(value=map_.get('x'))
+        y_elmt.update(value=map_.get('y'))
+        z_elmt.update(value=map_.get('z'))
+        c_elmt.update(value=map_.get('c'))
 
-        return map
+        return map_
 
 def create_map(
         values:dict,

small_fish_gui/batch/values.txt

@@ -6,7 +6,7 @@ image path
 3D stack 
 multichannel 
 Dense regions deconvolution 
-Cluster computation 
+do_cluster_computation 
 Segmentation 
 Napari correction 
 x 
@@ -48,7 +48,7 @@ deconvolution_kernel_y
 deconvolution_kernel_x 
 cluster size 
 min number of spots 
-Interactive threshold selector 
+show_interactive_threshold_selector 
 spots_extraction_folder 
 spots_filename 
 do_spots_csv 

small_fish_gui/gui/help_module.py

@@ -43,11 +43,11 @@ def _general_help() :
     help_text = """
     Pipeline settings :
 
-        Dense regions deconvolution : (Recommanded for cluster computations) Detect dense and bright regions with potential clustered 
+        do_dense_regions_deconvolution : (Recommanded for cluster computations) Detect dense and bright regions with potential clustered 
             spots and simulate a more realistic number of spots in these regions.
             See bigfish documentation : https://big-fish.readthedocs.io/en/stable/detection/dense.html
 
-        Cluster computation :
+        do_cluster_computation :
             DBScan algorithm is ran by big-fish to detecte clusters of spots. Use is you want to quantify one of the following : 
             Transcription sites, foci, colocalisation of spots near foci...
         
@@ -73,7 +73,7 @@ def _detection_help() :
     Access fully detailed documentation : 
     
         DETECTION : https://big-fish.readthedocs.io/en/stable/detection/spots.html
-        DENSE REGIONS DECONVOLUTION : https://big-fish.readthedocs.io/en/stable/detection/dense.html
+        do_dense_regions_deconvolution : https://big-fish.readthedocs.io/en/stable/detection/dense.html
         CLUSTERING : https://big-fish.readthedocs.io/en/stable/detection/cluster.html
         
     """
@@ -114,7 +114,7 @@ def _detection_help() :
 
     """
     deconv_header="""    
-    DENSE REGIONS DECONVOLUTION PARAMETERS
+    do_dense_regions_deconvolution PARAMETERS
 
     """
     deconv_text="""

small_fish_gui/gui/layout.py

@@ -101,7 +101,7 @@ def path_layout(keys= [],look_for_dir = False, header=None, preset=os.getcwd())
         layout = [add_header(header)] + layout
     return layout
 
-def bool_layout(parameters= [], header=None, preset=None) :
+def bool_layout(parameters= [], header=None, preset=None, keys=None) :
     if len(parameters) == 0 : return []
     check_parameter(parameters= list, header= (str, type(None)), preset=(type(None), list, tuple, bool))
     for key in parameters : check_parameter(key = str)
@@ -112,11 +112,19 @@ def bool_layout(parameters= [], header=None, preset=None) :
     else : 
         for key in preset : check_parameter(key = bool)
 
+    max_length = len(max(parameters, key=len))
 
+    if type(keys) == type(None) :
+        keys = parameters
+    elif isinstance(keys,(list,tuple)) :
+        if len(keys) != len(parameters) : raise ValueError("keys arguement must be of same length than parameters argument")
+    elif len(parameters) == 1 and isinstance(keys, str) :
+        keys = [keys]
+    else :
+        raise ValueError('Incorrect keys parameters. Expected list of same length than parameters or None.')
 
-    max_length = len(max(parameters, key=len))
     layout = [
-        [sg.Checkbox(pad_right(name, max_length, ' '), key= name, default=box_preset)] for name, box_preset in zip(parameters,preset)
+        [sg.Checkbox(pad_right(name, max_length, ' '), key=key, default=box_preset)] for name, box_preset, key in zip(parameters,preset,keys)
     ]
     if isinstance(header, str) :
         layout = [add_header(header)] + layout
@@ -139,14 +147,14 @@ def combo_elmt(values, key, header=None, read_only=True, default_value=None) :
         layout = add_header(header) + layout
     return layout
 
-def radio_layout(values, header=None) :
+def radio_layout(values, header=None, key=None) :
     """
     Single choice buttons.
     """
     if len(values) == 0 : return []
     check_parameter(values= list, header= (str, type(None)))
     layout = [
-        [sg.Radio(value, group_id= 0) for value in values]
+        [sg.Radio(value, group_id= 0, key=key) for value in values]
     ]
     if isinstance(header, str) :
         layout = [add_header(header)] + layout
@@ -219,18 +227,14 @@ def _input_parameters_layout(
 
 ) :
     layout_image_path = path_layout(['image path'], header= "Image")
-    layout_image_path += bool_layout(['3D stack', 'multichannel'], preset= [is_3D_stack_preset, time_stack_preset, multichannel_preset])
+    layout_image_path += bool_layout(['3D stack', 'Multichannel stack'], keys=['is_3D_stack', 'is_multichannel'], preset= [is_3D_stack_preset, multichannel_preset])
     
-    if ask_for_segmentation : 
-        layout_image_path += bool_layout(
-            ['Dense regions deconvolution', 'Cluster computation', 'Segmentation', 'Napari correction'], 
-            preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_segmentation_preset, do_Napari_correction], 
-            header= "Pipeline settings")
-    else : 
-        layout_image_path += bool_layout(
-            ['Dense regions deconvolution', 'Cluster computation', 'Napari correction'], 
-            preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], 
-            header= "Pipeline settings")
+    layout_image_path += bool_layout(
+        ['Dense regions deconvolution', 'Compute clusters', 'Cell segmentation', 'Open Napari corrector'],
+        keys= ['do_dense_regions_deconvolution', 'do_cluster_computation', 'do_segmentation', 'show_napari_corrector'], 
+        preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_segmentation_preset, do_Napari_correction], 
+        header= "Pipeline settings")
+
 
     return layout_image_path
 
@@ -251,9 +255,9 @@ def _detection_layout(
     default_detection = [default_dict.setdefault('threshold',''), default_dict.setdefault('threshold penalty', '1')]
     opt= [True, True]
     if is_multichannel : 
-        detection_parameters += ['channel to compute']
+        detection_parameters += ['channel_to_compute']
         opt += [False]
-        default_detection += [default_dict.setdefault('channel to compute', '')]
+        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)
@@ -273,7 +277,7 @@ def _detection_layout(
     #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= 'Dense regions deconvolution')
+        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)
     
@@ -284,7 +288,7 @@ def _detection_layout(
 
     
 
-    layout += bool_layout(['Interactive threshold selector'], preset=[False])
+    layout += bool_layout(['Interactive threshold selector'],keys = ['show_interactive_threshold_selector'], preset=[False])
     layout += path_layout(
         keys=['spots_extraction_folder'],
         look_for_dir=True,

small_fish_gui/gui/prompts.py

@@ -2,7 +2,8 @@ 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_elmt, add_header, path_layout
+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
 from ..interface import open_image, check_format, FormatError
 from .help_module import ask_help
 
@@ -34,7 +35,6 @@ def prompt(layout, add_ok_cancel=True, timeout=None, timeout_key='TIMEOUT_KEY',
 
 def prompt_with_help(layout, help =None, add_scrollbar=True, vertical_scroll_only=True) :
     layout += [[]]
-    layout += [[sg.Button('Help')]]
     layout += [[sg.Button('Ok'), sg.Button('Cancel')]]
     
     if add_scrollbar :
@@ -63,34 +63,29 @@ def prompt_with_help(layout, help =None, add_scrollbar=True, vertical_scroll_onl
 
 def input_image_prompt(
         is_3D_stack_preset=False,
-        time_stack_preset=False,
         multichannel_preset = False,
         do_dense_regions_deconvolution_preset= False,
         do_clustering_preset = False,
-        do_segmentation_preset= False,
         do_Napari_correction= False,
-        ask_for_segmentation= True
 ) :
     """
         Keys :
         - 'image path'
-        - '3D stack'
+        - 'is_3D_stack'
         - 'time stack'
-        - 'multichannel'
-        - 'Dense regions deconvolution'
+        - 'is_multichannel'
+        - 'do_dense_regions_deconvolution'
         - 'Segmentation'
-        - 'Napari correction'
+        - 'show_napari_corrector'
 
     Returns Values
 
     """
     layout_image_path = path_layout(['image path'], header= "Image")
-    layout_image_path += bool_layout(['3D stack', 'time stack', 'multichannel'], preset= [is_3D_stack_preset, time_stack_preset, multichannel_preset])
+    layout_image_path += bool_layout(['3D stack', 'Multichannel stack'],keys= ['is_3D_stack', 'is_multichannel'], preset= [is_3D_stack_preset, multichannel_preset])
     
-    if ask_for_segmentation : 
-        layout_image_path += bool_layout(['Dense regions deconvolution', 'Cluster computation', 'Segmentation', 'Napari correction'], preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_segmentation_preset, do_Napari_correction], header= "Pipeline settings")
-    else : 
-        layout_image_path += bool_layout(['Dense regions deconvolution', 'Cluster computation', 'Napari correction'], preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], header= "Pipeline settings")
+    if type(do_dense_regions_deconvolution_preset) != type(None) and type(do_clustering_preset) != type(None) and type(do_Napari_correction) != type(None): 
+        layout_image_path += bool_layout(['Dense regions deconvolution', 'Compute clusters', 'Open results in Napari'], keys = ['do_dense_regions_deconvolution', 'do_cluster_computation', 'show_napari_corrector'], preset= [do_dense_regions_deconvolution_preset, do_clustering_preset, do_Napari_correction], header= "Pipeline settings")
     
     event, values = prompt_with_help(layout_image_path, help= 'general', add_scrollbar=False)
 
@@ -98,18 +93,12 @@ def input_image_prompt(
         return None
 
     im_path = values['image path']
-    is_3D_stack = values['3D stack']
-    is_time_stack = values['time stack']
-    is_multichannel = values['multichannel']
-    if not ask_for_segmentation : values['Segmentation'] = False
-
-    if is_time_stack :
-        sg.popup("Sorry time stack images are not yet supported.")
-        return values
+    is_3D_stack = values['is_3D_stack']
+    is_multichannel = values['is_multichannel']
     
     try :
         image = open_image(im_path)
-        check_format(image, is_3D_stack, is_time_stack, is_multichannel)
+        check_format(image, is_3D_stack, is_multichannel)
         values.update({'image' : image})
     except FormatError as error:
         sg.popup("Inconsistency between image format and options selected.\n Image shape : {0}".format(image.shape))
@@ -159,24 +148,16 @@ def output_image_prompt(filename) :
 
     else : return values
 
-def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_deconvolution, do_clustering, do_segmentation, segmentation_done, default_dict: dict) :
+def detection_parameters_promt(
+        is_3D_stack, 
+        is_multichannel, 
+        do_dense_region_deconvolution, 
+        do_clustering, 
+        segmentation_done, 
+        default_dict: dict
+        ):
     """
 
-    keys :
-        - 'threshold'
-        - 'threshold penalty
-        - 'time step'
-        - 'channel to compute'
-        - 'alpha'
-        - 'beta'
-        - 'gamma'
-        - 'voxel_size_{(z,y,x)}'
-        - 'spot_size{(z,y,x)}'
-        - 'log_kernel_size{(z,y,x)}'
-        - 'minimum_distance{(z,y,x)}'
-        - 'cluster size'
-        - 'min number of spots'
-
     Returns Values
         
     """
@@ -188,9 +169,9 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
     default_detection = [default_dict.setdefault('threshold',''), default_dict.setdefault('threshold penalty', '1')]
     opt= [True, True]
     if is_multichannel : 
-        detection_parameters += ['channel to compute']
+        detection_parameters += ['channel_to_compute']
         opt += [False]
-        default_detection += [default_dict.setdefault('channel to compute', '')]
+        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)
     
@@ -204,7 +185,7 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
     #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= 'Dense regions deconvolution')
+        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)
     
@@ -213,11 +194,11 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
         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 (do_segmentation and is_multichannel) or (is_multichannel and segmentation_done):
+    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'], preset=[False])
+    layout += bool_layout(['Interactive threshold selector'], keys=['show_interactive_threshold_selector'], preset=[False])
     layout += path_layout(
         keys=['spots_extraction_folder'],
         look_for_dir=True,
@@ -230,7 +211,8 @@ def detection_parameters_promt(is_3D_stack, is_multichannel, do_dense_region_dec
         size= 13
     )
     layout += bool_layout(
-        parameters= ['do_spots_csv', 'do_spots_excel', 'do_spots_feather'],
+        ['.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)]
     )
 
@@ -280,17 +262,17 @@ def _warning_popup(warning:str) :
 
 def _sumup_df(results: pd.DataFrame) :
 
-    COLUMNS = ['acquisition_id','name','threshold', 'spot_number', 'cell_number', 'filename', 'channel to compute']
+    COLUMNS = ['acquisition_id','name','threshold', 'spot_number', 'cell_number', 'filename', 'channel_to_compute']
 
     if len(results) > 0 :
-        if 'channel to compute' not in results : results['channel to compute'] = np.NaN
+        if 'channel_to_compute' not in results : results['channel_to_compute'] = np.NaN
         res = results.loc[:,COLUMNS]
     else :
         res = pd.DataFrame(columns= COLUMNS)
 
     return res
 
-def hub_prompt(fov_results, do_segmentation=False) :
+def hub_prompt(fov_results, do_segmentation=False) -> 'Union[Literal["Add detection", "Compute colocalisation", "Batch detection", "Rename acquisition", "Save results", "Delete acquisitions", "Reset segmentation", "Reset results", "Segment cells"], dict[Literal["result_table", ""]]]':
 
     sumup_df = _sumup_df(fov_results)
     
@@ -302,9 +284,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('Rename acquisition', button_color= 'green'), 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('Segment cells'), sg.Button('Add detection'), sg.Button('Compute colocalisation'), sg.Button('Batch detection')],
+        [sg.Button('Save results', button_color= 'green'), sg.Button('Save segmentation', button_color= 'green'), sg.Button('Load segmentation', button_color= 'green')],
+        [sg.Button('Rename acquisition', button_color= 'gray'), sg.Button('Delete acquisitions',button_color= 'gray'), sg.Button('Reset segmentation',button_color= 'gray'), sg.Button('Reset all',button_color= 'gray')],
     ]
 
     window = sg.Window('small fish', layout= layout, margins= (10,10))
@@ -359,3 +341,69 @@ def ask_cancel_detection() :
     else :
         return True
 
+
+def ask_confirmation(question_displayed : str) :
+    layout =[
+        [sg.Text(question_displayed, font= 'bold 10')],
+        [sg.Button("Yes"), sg.Button("No")]
+    ]
+
+    event, value = prompt(layout, add_ok_cancel=False, add_scrollbar=False)
+
+    if event == 'No' :
+        return False
+    else :
+        return True
+    
+
+def prompt_save_segmentation() -> 'dict[Literal["folder","filename","ext"]]':
+    while True :
+        relaunch = False
+        layout = path_layout(['folder'], look_for_dir= True, header= "Output parameters :")
+        layout += parameters_layout(["filename"], default_values= ["small_fish_segmentation"], size=25)
+        layout += radio_layout(['npy','npz_uncompressed', 'npz_compressed'], key= 'ext')
+
+        event,values= prompt(layout)
+        if event == ('Cancel') : 
+            return None
+
+        values['filename'] = values['filename'].replace(".npy","")
+        values['filename'] = values['filename'].replace(".npz","")
+        filename = values['filename']
+
+        if not os.path.isdir(values['folder']) :
+            sg.popup("Incorrect folder")
+            relaunch = True
+        elif os.path.isfile(values['folder'] + filename):
+            if ask_replace_file(filename) :
+                pass
+            else :
+                relaunch = True
+
+        if not relaunch : break
+
+    return values
+
+def prompt_load_segmentation() -> 'dict[Literal["nucleus","cytoplasm"]]':
+    while True :
+        relaunch = False
+        layout = path_layout(['nucleus'], look_for_dir= False, header= "Load segmentation :")
+        layout += path_layout(['cytoplasm'], look_for_dir= False)
+
+        event,values= prompt(layout)
+        if event == ('Cancel') : 
+            return None
+        
+        if not os.path.isfile(values['nucleus']) :
+            sg.popup("Incorrect nucleus file selected.")
+            relaunch = True
+
+        if not os.path.isfile(values['cytoplasm']) and values['cytoplasm'] != "" :
+            sg.popup("Incorrect cytoplasm file selected.")
+            relaunch = True
+                
+
+        if not relaunch : break
+
+
+    return values