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

small_fish_gui/pipeline/actions.py

@@ -2,59 +2,77 @@
 This submodule groups all the possible actions of the user in the main windows. It is the start of each action the user can do.
 """
 
-from ..gui.prompts import output_image_prompt, ask_detection_confirmation, ask_cancel_detection, rename_prompt
-from ..interface.output import write_results
-from ._preprocess import map_channels, prepare_image_detection, reorder_shape, reorder_image_stack
-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 ..gui.prompts import output_image_prompt, prompt_save_segmentation, prompt_load_segmentation
+from ..gui.prompts import ask_detection_confirmation, ask_cancel_detection, ask_confirmation
+from ..gui.prompts import rename_prompt
+
+from ..interface.inoutput import write_results
+from ..interface.inoutput import input_segmentation, output_segmentation
+
+from ._preprocess import map_channels
+from ._preprocess import prepare_image_detection
+from ._preprocess import reorder_shape, reorder_image_stack
+from ._preprocess import ask_input_parameters
+
+from .detection import initiate_detection, launch_detection, launch_features_computation
+from .detection import get_nucleus_signal
 from .spots import launch_spots_extraction
 
+from .segmentation import launch_segmentation
+from ._colocalisation import initiate_colocalisation, launch_colocalisation
+
+from ..hints import pipeline_parameters
+
+import os
 import pandas as pd
 import PySimpleGUI as sg
+import numpy as np
+
+def segment_cells(user_parameters : pipeline_parameters, nucleus_label, cytoplasm_label) :
+    if user_parameters['segmentation_done'] :
+        if ask_confirmation("A segmentation is in small fish memory, do you want to erase it ? (you will not be able to undo)") :
+            user_parameters['segmentation_done'] = False
+            nucleus_label = None
+            cytoplasm_label = None
+        else : 
+            return nucleus_label, cytoplasm_label, user_parameters
+
+    nucleus_label, cytoplasm_label, user_parameters = launch_segmentation(
+        user_parameters,
+        nucleus_label=nucleus_label,
+        cytoplasm_label=cytoplasm_label,
+    )
+
+    if type(cytoplasm_label) != type(None) and type(nucleus_label) != type(None) :
+        user_parameters['segmentation_done'] = True
 
-def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_label, nucleus_label) :
+    return nucleus_label, cytoplasm_label, user_parameters
+
+def add_detection(user_parameters : pipeline_parameters, acquisition_id, cytoplasm_label, nucleus_label) :
     """
-    #TODO : list all keys added to user_parameters when returned.
+    #TODO : Separate segmentation from detection in pipeline.
     """
 
     new_results_df = pd.DataFrame()
     new_cell_results_df = pd.DataFrame()
 
     #Ask for image parameters
-    new_parameters = ask_input_parameters(ask_for_segmentation= not segmentation_done) #The image is open and stored inside user_parameters
+    new_parameters = ask_input_parameters(ask_for_segmentation= False) #The image is open and stored inside user_parameters
     if type(new_parameters) == type(None) : #if user clicks 'Cancel'
-        return new_results_df, new_cell_results_df, acquisition_id, user_parameters, segmentation_done,cytoplasm_label, nucleus_label
+        return new_results_df, new_cell_results_df, acquisition_id, user_parameters
     else :
         user_parameters.update(new_parameters)
 
-    map = map_channels(user_parameters)
-    if type(map) == type(None) : #User clicks Cancel 
-        return new_results_df, new_cell_results_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label, nucleus_label
-    user_parameters['reordered_shape'] = reorder_shape(user_parameters['shape'], map)
-
-
-    #Segmentation
-    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
-
-    if type(cytoplasm_label) == type(None) or type(nucleus_label) == type(None) :
-        user_parameters['Segmentation'] = False
-        segmentation_done = False
-
-    else : segmentation_done = True
+    map_ = map_channels(user_parameters)
+    if type(map_) == type(None) : #User clicks Cancel 
+        return new_results_df, new_cell_results_df, acquisition_id, user_parameters
+    user_parameters['reordered_shape'] = reorder_shape(user_parameters['shape'], map_)
 
     #Detection
     while True : # This loop allow user to try detection with different thresholds or parameters before launching features computation
         detection_parameters = initiate_detection(
             user_parameters,
-            segmentation_done,
-            map= map,
+            map_= map_,
             shape = user_parameters['image'].shape
             )
 
@@ -63,11 +81,11 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
         else : #If user clicks cancel
             cancel = ask_cancel_detection()
             if cancel : 
-                return new_results_df, new_cell_results_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label, nucleus_label
+                return new_results_df, new_cell_results_df, acquisition_id, user_parameters
             else : continue
 
         acquisition_id += 1
-        image, other_image = prepare_image_detection(map, user_parameters) 
+        image, other_image = prepare_image_detection(map_, user_parameters) 
         nucleus_signal = get_nucleus_signal(image, other_image, user_parameters)
         
         try : # Catch error raised if user enter a spot size too small compare to voxel size
@@ -87,7 +105,7 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
                 raise(error)
 
 
-        if user_parameters['Napari correction'] :
+        if user_parameters['show_napari_corrector'] :
             if ask_detection_confirmation(user_parameters.get('threshold')) : break
         else :
             break
@@ -116,7 +134,93 @@ def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_
     user_parameters=user_parameters,
     frame_results=frame_result,
     )
-    return new_results_df, new_cell_results_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label, nucleus_label
+    return new_results_df, new_cell_results_df, acquisition_id, user_parameters
+
+def save_segmentation(nucleus_label : np.ndarray, cytoplasm_label: np.ndarray) :
+    if type(nucleus_label) == type(None) or type(cytoplasm_label) == type(None) :
+        sg.popup("No segmentation to save.")
+    
+    else :
+
+        while True :
+            answer = prompt_save_segmentation()
+            if type(answer) == type(None) : 
+                return False #User clicks cancel
+
+            path = answer['folder'] + '/' + answer['filename']
+            is_npy, is_npz, is_npz_compressed = answer['ext'], answer['ext0'], answer['ext1']
+
+            if is_npy + is_npz + is_npz_compressed == 1 : 
+                if is_npy : 
+                    extension = 'npy'
+                    if os.path.isfile(path + '_nucleus_segmentation.npy') or os.path.isfile(path + '_cytoplasm_segmentation.npy') : 
+                        if ask_confirmation("File exists. Replace ?") :
+                            break
+                        else :
+                            pass
+                    else :
+                        break
+
+                elif is_npz :
+                    extension = 'npz_uncompressed'
+                    if os.path.isfile(path + '_nucleus_segmentation.npz') or os.path.isfile(path + '_cytoplasm_segmentation.npz') : 
+                        if ask_confirmation("File exists. Replace ?") :
+                            break
+                        else :
+                            pass
+                    else :
+                        break
+
+                elif is_npz_compressed : 
+                    extension = 'npz_compressed'
+                    if os.path.isfile(path + '_nucleus_segmentation.npz') or os.path.isfile(path + '_cytoplasm_segmentation.npz') : 
+                        if ask_confirmation("File exists. Replace ?") :
+                            break
+                        else :
+                            pass
+                    else :
+                        break
+
+            else :
+                sg.popup("Please select an extension.")
+
+        saved = output_segmentation(
+            path,
+            extension,
+            nucleus_label,
+            cytoplasm_label,
+            )
+        if saved : sg.popup("Segmentation was saved at {0}.".format(path))
+        else : sg.popup("No segmentation was saved..")
+        return True
+    
+def load_segmentation(nucleus_label, cytoplasm_label, segmentation_done) :
+
+    if segmentation_done :
+        if ask_confirmation("Segmentation already in memory. Replace ?") :
+            pass
+        else :
+            return nucleus_label, cytoplasm_label, segmentation_done
+
+    answer = prompt_load_segmentation()
+    if type(answer) == type(None) : #user clicks cancel
+        return nucleus_label, cytoplasm_label, segmentation_done
+    nucleus_label, cytoplasm_label = input_segmentation(
+        answer['nucleus'],
+        answer['cytoplasm'],
+    )
+
+    if type(nucleus_label) != type(None) and type(nucleus_label) != np.ndarray :
+        nucleus_label = nucleus_label['arr_0']
+
+    if type(cytoplasm_label) != type(None) and type(cytoplasm_label) != np.ndarray :
+        cytoplasm_label = cytoplasm_label['arr_0']
+
+    segmentation_done = (type(nucleus_label) != type(None) and type(cytoplasm_label) != type(None))
+
+    if segmentation_done : assert type(nucleus_label) == np.ndarray and type(cytoplasm_label) == np.ndarray
+
+    return nucleus_label, cytoplasm_label, segmentation_done
 
 def save_results(result_df, cell_result_df, global_coloc_df, cell_coloc_df) :
     if len(result_df) != 0 :
@@ -207,14 +311,14 @@ def rename_acquisitions(
     
     if len(result_df) == 0 :
         sg.popup("No acquisition to rename.")
-        return result_df, cell_result_df, global_coloc_df
+        return result_df, cell_result_df, global_coloc_df, cell_coloc_df
     
     if len(selected_acquisitions) == 0 :
         sg.popup("Please select the acquisitions you would like to rename.")
 
     else :
         name = rename_prompt()
-        if not name : return result_df, cell_result_df, global_coloc_df #User didn't put a name or canceled
+        if not name : return result_df, cell_result_df, global_coloc_df, cell_coloc_df #User didn't put a name or canceled
         name : str = name.replace(' ','_')
         acquisition_ids = list(result_df.iloc[list(selected_acquisitions)]['acquisition_id'])
         old_names = list(result_df.loc[result_df['acquisition_id'].isin(acquisition_ids)]['name'])

small_fish_gui/pipeline/detection.py

@@ -1,23 +1,25 @@
 """
 Contains code to handle detection as well as bigfish wrappers related to spot detection.
 """
+from ..hints import pipeline_parameters
+
 
 from ._preprocess import ParameterInputError
 from ._preprocess import check_integrity, convert_parameters_types
-from ._signaltonoise import compute_snr_spots
+
 from ..gui.napari import correct_spots, _update_clusters, threshold_selection
 from ..gui import add_default_loading
-from ..gui import detection_parameters_promt, input_image_prompt
+from ..gui import detection_parameters_promt
+
 from ..utils import compute_anisotropy_coef
-from .spots import compute_Spots
+from ._signaltonoise import compute_snr_spots
+
 from magicgui import magicgui
-from napari.layers import Image, Points
 from napari.types import LayerDataTuple
 
 import numpy as np
 import pandas as pd
 import PySimpleGUI as sg
-import os
 from numpy import NaN
 import bigfish.detection as detection
 import bigfish.stack as stack
@@ -29,66 +31,6 @@ from skimage.measure import regionprops
 from scipy.ndimage import binary_dilation
 
 
-def ask_input_parameters(ask_for_segmentation=True) :
-    """
-    Prompt user with interface allowing parameters setting for bigFish detection / deconvolution.
-    
-    Keys :
-        - 'image path'
-        - '3D stack'
-        - 'time stack'
-        - 'multichannel'
-        - 'Dense regions deconvolution'
-        - 'Segmentation
-        - 'Napari correction'
-        - 'threshold'
-        - '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)}'
-    """
-    
-    values = {}
-    image_input_values = {}
-    while True :
-        is_3D_preset = image_input_values.setdefault('3D stack', False)
-        is_time_preset = image_input_values.setdefault('time stack', False)
-        is_multichannel_preset = image_input_values.setdefault('multichannel', False)
-        denseregion_preset = image_input_values.setdefault('Dense regions deconvolution', False)
-        do_clustering_preset = image_input_values.setdefault('Cluster computation', False)
-        do_segmentation_preset = image_input_values.setdefault('Segmentation', False)
-        do_napari_preset = image_input_values.setdefault('Napari correction', False)
-
-        image_input_values = input_image_prompt(
-            is_3D_stack_preset=is_3D_preset,
-            time_stack_preset=is_time_preset,
-            multichannel_preset=is_multichannel_preset,
-            do_dense_regions_deconvolution_preset=denseregion_preset,
-            do_clustering_preset= do_clustering_preset,
-            do_segmentation_preset=do_segmentation_preset,
-            do_Napari_correction=do_napari_preset,
-            ask_for_segmentation= ask_for_segmentation
-        )
-        if type(image_input_values) == type(None) :
-            return image_input_values
-
-        if 'image' in image_input_values.keys() :
-            image_input_values['shape'] = image_input_values['image'].shape 
-            break
-
-
-    values.update(image_input_values)
-    values['dim'] = 3 if values['3D stack'] else 2
-    values['filename'] = os.path.basename(values['image path'])
-    if values['Segmentation'] and values['time stack'] : sg.popup('Segmentation is not supported for time stack. Segmentation will be turned off.')
-    
-    return values
-
 
 def compute_auto_threshold(images, voxel_size=None, spot_radius=None, log_kernel_size=None, minimum_distance=None, im_number= 15, crop_zstack= None) :
     """
@@ -262,38 +204,38 @@ def cluster_detection(spots, voxel_size, radius = 350, nb_min_spots = 4, keys_to
 
     return res
 
-def initiate_detection(user_parameters, segmentation_done, map, shape) :
-    is_3D_stack= user_parameters['3D stack']
-    is_multichannel = user_parameters['multichannel']
-    do_dense_region_deconvolution = user_parameters['Dense regions deconvolution']
-    do_clustering = user_parameters['Cluster computation']
-    do_segmentation = user_parameters['Segmentation']
+def initiate_detection(user_parameters : pipeline_parameters, map_, shape) :
+    is_3D_stack= user_parameters['is_3D_stack']
+    is_multichannel = user_parameters['is_multichannel']
+    do_dense_region_deconvolution = user_parameters['do_dense_regions_deconvolution']
+    do_clustering = user_parameters['do_cluster_computation']
+    detection_parameters = user_parameters.copy()
     
     while True :
-        user_parameters = detection_parameters_promt(
+        detection_parameters = detection_parameters_promt(
             is_3D_stack=is_3D_stack,
             is_multichannel=is_multichannel,
             do_dense_region_deconvolution=do_dense_region_deconvolution,
             do_clustering=do_clustering,
-            do_segmentation=do_segmentation,
-            segmentation_done= segmentation_done,
-            default_dict=user_parameters
+            segmentation_done= user_parameters['segmentation_done'],
+            default_dict=detection_parameters
             )
-        if type(user_parameters) == type(None) : return user_parameters
+        if type(detection_parameters) == type(None) : return user_parameters
         try :
-            user_parameters = convert_parameters_types(user_parameters)
-            user_parameters = check_integrity(
-                user_parameters, 
+            detection_parameters = convert_parameters_types(detection_parameters)
+            detection_parameters = check_integrity(
+                detection_parameters, 
                 do_dense_region_deconvolution,
                 do_clustering, 
                 is_multichannel, 
-                segmentation_done, 
-                map, 
+                user_parameters['segmentation_done'], 
+                map_, 
                 shape
                 )
         except ParameterInputError as error:
             sg.popup(error)
         else :
+            user_parameters.update(detection_parameters)
             break
     return user_parameters
 
@@ -311,7 +253,7 @@ def _launch_detection(image, image_input_values: dict) :
     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')
+    threshold_user_selection = image_input_values['show_interactive_threshold_selector']
     
     if type(threshold) == type(None) :     
         threshold = threshold_penalty * compute_auto_threshold(image, voxel_size=voxel_size, spot_radius=spot_size, log_kernel_size=log_kernel_size, minimum_distance=minimum_distance)
@@ -446,11 +388,11 @@ def _compute_cell_snr(image: np.ndarray, bbox, spots, voxel_size, spot_size) :
     return snr_dict
 
 @add_default_loading
-def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signal, cell_label, nucleus_label, user_parameters) :
+def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signal, cell_label, nucleus_label, user_parameters : pipeline_parameters) :
 
     #Extract parameters
     dim = user_parameters['dim']
-    do_clustering = user_parameters['Cluster computation']
+    do_clustering = user_parameters['do_cluster_computation']
     voxel_size = user_parameters['voxel_size']
 
     if do_clustering : other_coords = {'clusters_coords' : clusters} if len(clusters) > 0 else None
@@ -579,7 +521,7 @@ def launch_cell_extraction(acquisition_id, spots, clusters, image, nucleus_signa
     return result_frame
 
 @add_default_loading
-def launch_clustering(spots, user_parameters): 
+def launch_clustering(spots, user_parameters : pipeline_parameters): 
 
     voxel_size = user_parameters['voxel_size']
     nb_min_spots = user_parameters['min number of spots']
@@ -624,8 +566,8 @@ def launch_detection(
         'threshold'
     """
     fov_result = {}
-    do_dense_region_deconvolution = user_parameters['Dense regions deconvolution']
-    do_clustering = user_parameters['Cluster computation']
+    do_dense_region_deconvolution = user_parameters['do_dense_regions_deconvolution']
+    do_clustering = user_parameters['do_cluster_computation']
 
     spots, threshold  = _launch_detection(image, user_parameters, hide_loading = hide_loading)
         
@@ -640,7 +582,7 @@ def launch_detection(
 
     user_parameters['threshold'] = threshold
 
-    if user_parameters['Napari correction'] :
+    if user_parameters['show_napari_corrector'] :
 
         spots, clusters = correct_spots(
             image, 
@@ -659,11 +601,10 @@ def launch_detection(
     return user_parameters, fov_result, spots, clusters
             
 
-def launch_features_computation(acquisition_id, image, nucleus_signal, spots, clusters, nucleus_label, cell_label, user_parameters, frame_results) :
+def launch_features_computation(acquisition_id, image, nucleus_signal, spots, clusters, nucleus_label, cell_label, user_parameters :pipeline_parameters, frame_results) :
 
     dim = image.ndim
-            
-    if user_parameters['Cluster computation'] : 
+    if user_parameters['do_cluster_computation'] : 
         frame_results['cluster_number'] = len(clusters)
         if dim == 3 :
             frame_results['total_spots_in_clusters'] = clusters.sum(axis=0)[3] if len(clusters) >0 else  0
@@ -671,16 +612,22 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
             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(
-            acquisition_id=acquisition_id,
-            spots=spots,
-            clusters=clusters,
-            image=image,
-            nucleus_signal=nucleus_signal,
-            cell_label= cell_label,
-            nucleus_label=nucleus_label,
-            user_parameters=user_parameters,
-        )
+        
+        try :
+            cell_result_dframe = launch_cell_extraction(
+                acquisition_id=acquisition_id,
+                spots=spots,
+                clusters=clusters,
+                image=image,
+                nucleus_signal=nucleus_signal,
+                cell_label= cell_label,
+                nucleus_label=nucleus_label,
+                user_parameters=user_parameters,
+            )
+
+        except IndexError as e: #User loaded a segmentation and no cells can be extracted out of it.
+            raise Exception("No cell was fit for quantification in segmentation. This can happen if you loaded empty segmentation or there is a missmatch between cytoplasm and nuclei.\nIf you didn't load segmentation please report the issue as this should not happen.")
+
     else :
         cell_result_dframe = pd.DataFrame()
 
@@ -701,10 +648,11 @@ def launch_features_computation(acquisition_id, image, nucleus_signal, spots, cl
     cell_result_col = list(cell_result_dframe.columns)
     name = "acquisition_{0}".format(acquisition_id)
     frame_results['name'] = name
-    cell_result_dframe['name'] = name
     frame_results = frame_results.loc[:,['name'] + result_col]
-    cell_result_dframe = cell_result_dframe.loc[:,['name'] + cell_result_col]
-    cell_result_dframe['total_rna_number'] = cell_result_dframe['nb_rna_in_nuc'] + cell_result_dframe['nb_rna_out_nuc']
+    if user_parameters['segmentation_done'] : 
+        cell_result_dframe['name'] = name
+        cell_result_dframe = cell_result_dframe.loc[:,['name'] + cell_result_col]
+        cell_result_dframe['total_rna_number'] = cell_result_dframe['nb_rna_in_nuc'] + cell_result_dframe['nb_rna_out_nuc']
         
     return frame_results, cell_result_dframe
 
@@ -741,8 +689,8 @@ def _compute_cluster_dataframe(clusters) :
     return df
 
 def get_nucleus_signal(image, other_images, user_parameters) :
-    if user_parameters['multichannel'] :
-        rna_signal_channel = user_parameters['channel to compute']
+    if user_parameters['is_multichannel'] :
+        rna_signal_channel = user_parameters['channel_to_compute']
         nucleus_signal_channel = user_parameters['nucleus channel signal']
         if type(nucleus_signal_channel) == type(None) :
             return np.zeros(shape=image.shape)

small_fish_gui/pipeline/main.py

@@ -5,49 +5,31 @@ This script is called when software starts; it is the main loop.
 import pandas as pd
 import PySimpleGUI as sg
 from ..gui import hub_prompt
-from .actions import add_detection, save_results, compute_colocalisation, delete_acquisitions, rename_acquisitions
+from .actions import add_detection, save_results, compute_colocalisation, delete_acquisitions, rename_acquisitions, save_segmentation, load_segmentation, segment_cells
 from ._preprocess import clean_unused_parameters_cache
 from ..batch import batch_promp
+from ..hints import pipeline_parameters
 
 #'Global' parameters
-user_parameters = dict() # Very important instance containg all choice from user that will influence the behavior of the actions loops.
+user_parameters = pipeline_parameters({'segmentation_done' : False}) #TypedDict
 acquisition_id = -1
-result_df = pd.DataFrame()
-cell_result_df = pd.DataFrame()
+result_df = pd.DataFrame(columns=['acquisition_id'])
+cell_result_df = pd.DataFrame(columns=['acquisition_id'])
 global_coloc_df = pd.DataFrame()
 cell_coloc_df = pd.DataFrame()
-segmentation_done = False
 cytoplasm_label = None
 nucleus_label = None
 
-#Use for dev purpose
-MAKE_NEW_SAVE = False
-PATH = "/home/floricslimani/Documents/small_fish_workshop/save"
-LOAD_SAVE = False
-
 while True : #Break this loop to close small_fish
 
-    if LOAD_SAVE :
-        result_df = pd.read_csv(PATH + "/result.csv", sep='|')
-        cell_result_df = pd.read_csv(PATH + "/cell_result_df.csv", sep='|')
-        global_coloc_df = pd.read_csv(PATH + "/global_coloc_df.csv", sep='|')
-        cell_coloc_df = pd.read_csv(PATH + "/cell_coloc_df.csv", sep='|')
-
-
-    else :
-        result_df = result_df.reset_index(drop=True)
-        cell_result_df = cell_result_df.reset_index(drop=True)
-        global_coloc_df = global_coloc_df.reset_index(drop=True)
-        cell_coloc_df = cell_coloc_df.reset_index(drop=True)
     try :
-        event, values = hub_prompt(result_df, segmentation_done)
+        event, values = hub_prompt(result_df, user_parameters['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(
+            new_result_df, new_cell_result_df, acquisition_id, user_parameters =  add_detection(
                 user_parameters=user_parameters,
-                segmentation_done=segmentation_done,
                 acquisition_id=acquisition_id,
                 cytoplasm_label = cytoplasm_label,
                 nucleus_label = nucleus_label,
@@ -55,6 +37,13 @@ while True : #Break this loop to close small_fish
             result_df = pd.concat([result_df, new_result_df], axis=0)
             cell_result_df = pd.concat([cell_result_df, new_cell_result_df], axis=0)
 
+        elif event == 'Segment cells' :
+            nucleus_label, cytoplasm_label, user_parameters = segment_cells(
+                user_parameters=user_parameters,
+                nucleus_label=nucleus_label,
+                cytoplasm_label = cytoplasm_label,
+            )
+
         elif event == 'Save results' :
             save_results(
                 result_df=result_df,
@@ -62,7 +51,16 @@ while True : #Break this loop to close small_fish
                 global_coloc_df=global_coloc_df,
                 cell_coloc_df = cell_coloc_df,
             )
-            
+        
+        elif event == 'Save segmentation' :
+            save_segmentation(
+                nucleus_label=nucleus_label,
+                cytoplasm_label=cytoplasm_label,
+            )
+
+        elif event == 'Load segmentation' :
+            nucleus_label, cytoplasm_label, user_parameters['segmentation_done'] = load_segmentation(nucleus_label, cytoplasm_label, user_parameters['segmentation_done'])
+        
         elif event == 'Compute colocalisation' :
             result_tables = values.setdefault('result_table', []) #Contains the lines selected by the user on the sum-up array.
 
@@ -74,18 +72,18 @@ while True : #Break this loop to close small_fish
                 cell_coloc_df=cell_coloc_df,
             )
 
-        elif event == "Reset results" :
+        elif event == "Reset all" :
             result_df = pd.DataFrame()
             cell_result_df = pd.DataFrame()
             global_coloc_df = pd.DataFrame()
             cell_coloc_df = pd.DataFrame()
             acquisition_id = -1
-            segmentation_done = False
+            user_parameters['segmentation_done'] = False
             cytoplasm_label = None
             nucleus_label = None
 
         elif event == "Reset segmentation" :
-            segmentation_done = False
+            user_parameters['segmentation_done'] = False
             cytoplasm_label = None
             nucleus_label = None
 
@@ -94,7 +92,7 @@ while True : #Break this loop to close small_fish
             result_df, cell_result_df, global_coloc_df, cell_coloc_df = delete_acquisitions(selected_acquisitions, result_df, cell_result_df, global_coloc_df, cell_coloc_df)
 
         elif event == "Batch detection" :
-            result_df, cell_result_df, acquisition_id, user_parameters, segmentation_done, cytoplasm_label,nucleus_label = batch_promp(
+            result_df, cell_result_df, acquisition_id, user_parameters, user_parameters['segmentation_done'], cytoplasm_label,nucleus_label = batch_promp(
                 result_df,
                 cell_result_df,
                 acquisition_id=acquisition_id,
@@ -108,11 +106,6 @@ while True : #Break this loop to close small_fish
         else :
             break
         
-        if MAKE_NEW_SAVE :
-            result_df.reset_index(drop=True).to_csv(PATH + "/result.csv", sep='|')
-            cell_result_df.reset_index(drop=True).to_csv(PATH + "/cell_result_df.csv", sep='|')
-            cell_coloc_df.reset_index(drop=True).to_csv(PATH + "/cell_coloc_df.csv", sep='|')
-            global_coloc_df.reset_index(drop=True).to_csv(PATH + "/global_coloc_df.csv", sep='|')
 
     except Exception as error :
         sg.popup(str(error))