small-fish-gui 1.0.0__py3-none-any.whl

small_fish_gui/pipeline/_segmentation.py

@@ -0,0 +1,334 @@
+"""
+Contains cellpose wrappers to segmentate images.
+"""
+
+from cellpose.core import use_gpu
+from skimage.measure import label
+from ..gui.layout import _segmentation_layout
+from ..gui import prompt, prompt_with_help, ask_cancel_segmentation
+
+import cellpose.models as models
+import numpy as np
+import bigfish.multistack as multistack
+import bigfish.stack as stack
+import bigfish.plot as plot
+import PySimpleGUI as sg
+import os
+
+def launch_segmentation(image: np.ndarray, user_parameters: dict) :
+    """
+    Ask user for necessary parameters and perform cell segmentation (cytoplasm + nucleus) with cellpose.
+
+    Input
+    -----
+    Image : np.ndarray[c,z,y,x]
+        Image to use for segmentation.
+
+    Returns
+    -------
+        cytoplasm_label, nucleus_label
+    """
+
+    while True : # Loop if show_segmentation 
+        #Default parameters
+        cyto_model_name = user_parameters.setdefault('cyto_model_name', 'cyto2')
+        cyto_size = user_parameters.setdefault('cytoplasm diameter', 180)
+        cytoplasm_channel = user_parameters.setdefault('cytoplasm channel', 0)
+        nucleus_model_name = user_parameters.setdefault('nucleus_model_name', 'nuclei')
+        nucleus_size = user_parameters.setdefault('nucleus diameter', 130)
+        nucleus_channel = user_parameters.setdefault('nucleus channel', 0)
+        path = os.getcwd()
+        show_segmentation = user_parameters.setdefault('show segmentation', False)
+        segment_only_nuclei = user_parameters.setdefault('Segment only nuclei', False)
+        filename = user_parameters['filename']
+        available_channels = list(range(image.shape[0]))
+
+
+    #Ask user for parameters
+    #if incorrect parameters --> set relaunch to True
+        while True :
+            layout = _segmentation_layout(
+                cytoplasm_model_preset = cyto_model_name,
+                cytoplasm_channel_preset= cytoplasm_channel,
+                nucleus_model_preset = nucleus_model_name,
+                nucleus_channel_preset= nucleus_channel,
+                cyto_diameter_preset= cyto_size,
+                nucleus_diameter_preset= nucleus_size,
+                saving_path_preset= path,
+                show_segmentation_preset=show_segmentation,
+                segment_only_nuclei_preset=segment_only_nuclei,
+                filename_preset=filename,
+            )
+
+            event, values = prompt_with_help(layout, help='segmentation')
+            if event == 'Cancel' :
+                cancel_segmentation = ask_cancel_segmentation()
+
+                if cancel_segmentation :
+                    return None, None, user_parameters
+                else : 
+                    continue
+
+            #Extract parameters
+            values = _cast_segmentation_parameters(values)
+            do_only_nuc = values['Segment only nuclei']
+            cyto_model_name = values['cyto_model_name']
+            cyto_size = values['cytoplasm diameter']
+            cytoplasm_channel = values['cytoplasm channel']
+            nucleus_model_name = values['nucleus_model_name']
+            nucleus_size = values['nucleus diameter']
+            nucleus_channel = values['nucleus channel']
+            path = values['saving path'] if values['saving path'] != '' else None
+            show_segmentation = values['show segmentation']
+            filename = values['filename'] if type(path) != type(None) else None
+            channels = [cytoplasm_channel, nucleus_channel]
+
+            relaunch= False
+            #Checking integrity of parameters
+            if type(cyto_model_name) != str  and not do_only_nuc:
+                sg.popup('Invalid cytoplasm model name.')
+                values['cyto_model_name'] = user_parameters.setdefault('cyto_model_name', 'cyto2')
+                relaunch= True
+            if cytoplasm_channel not in available_channels and not do_only_nuc:
+                sg.popup('For given input image please select channel in {0}\ncytoplasm channel : {1}'.format(available_channels, cytoplasm_channel))
+                relaunch= True
+                values['cytoplasm channel'] = user_parameters.setdefault('cytoplasm channel',0)
+
+            if type(cyto_size) not in [int, float] and not do_only_nuc:
+                sg.popup("Incorrect cytoplasm size.")
+                relaunch= True
+                values['cytoplasm diameter'] = user_parameters.setdefault('diameter', 30)
+
+            if type(nucleus_model_name) != str :
+                sg.popup('Invalid nucleus model name.')
+                values['nucleus_model_name'] = user_parameters.setdefault('nucleus_model_name', 'nuclei')
+                relaunch= True
+            if nucleus_channel not in available_channels :
+                sg.popup('For given input image please select channel in {0}\nnucleus channel : {1}'.format(available_channels, nucleus_channel))
+                relaunch= True
+                values['nucleus channel'] = user_parameters.setdefault('nucleus_channel', 0)
+            if type(nucleus_size) not in [int, float] :
+                sg.popup("Incorrect nucleus size.")
+                relaunch= True
+                values['nucleus diameter'] = user_parameters.setdefault('nucleus diameter', 30)
+
+            user_parameters.update(values)
+            if not relaunch : break
+
+        #Launching segmentation
+        waiting_layout = [
+            [sg.Text("Running segmentation...")]
+        ]
+        window = sg.Window(
+            title= 'small_fish',
+            layout= waiting_layout,
+            grab_anywhere= True,
+            no_titlebar= False
+        )
+
+        window.read(timeout= 30, close= False)
+
+        try :
+            if type(path) != type(None) and filename != '':
+                output_path = path + '/' + filename
+                nuc_path = output_path + "_nucleus_segmentation"
+                cyto_path = output_path + "_cytoplasm_segmentation"
+            else :
+                output_path = None
+                nuc_path = None
+                cyto_path = None
+
+
+            cytoplasm_label, nucleus_label = cell_segmentation(
+                image,
+                cyto_model_name= cyto_model_name,
+                cyto_diameter= cyto_size,
+                nucleus_model_name= nucleus_model_name,
+                nucleus_diameter= nucleus_size,
+                channels=channels,
+                do_only_nuc=do_only_nuc
+                )
+
+        finally  : window.close()
+        if show_segmentation or type(output_path) != type(None) :
+            nuc_proj = image[nucleus_channel]
+            im_proj = image[cytoplasm_channel]
+            if im_proj.ndim == 3 :
+                im_proj = stack.maximum_projection(im_proj)
+            if nuc_proj.ndim == 3 :
+                nuc_proj = stack.maximum_projection(nuc_proj)
+            plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=show_segmentation, path_output=None, title= "Nucleus segmentation (blue)", remove_frame=False,)
+            if type(nuc_path) != type(None) : plot.plot_segmentation_boundary(nuc_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=False, path_output=nuc_path, title= "Nucleus segmentation (blue)", remove_frame=True,)
+            if not do_only_nuc : 
+                plot.plot_segmentation_boundary(im_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=show_segmentation, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=False)
+                if type(cyto_path) != type(None) : plot.plot_segmentation_boundary(im_proj, cytoplasm_label, nucleus_label, boundary_size=2, contrast=True, show=False, path_output=cyto_path, title="Cytoplasm Segmentation (red)", remove_frame=True)
+        if show_segmentation :
+            layout = [
+                [sg.Text("Proceed with current segmentation ?")],
+                [sg.Button("Yes"), sg.Button("No")]
+            ]
+            
+            event, values = prompt(layout=layout, add_ok_cancel=False)
+            if event == "No" :
+                continue
+
+        if cytoplasm_label.max() == 0 : #No cell segmented
+            layout = [
+            [sg.Text("No cell segmented. Proceed anyway ?")],
+            [sg.Button("Yes"), sg.Button("No")]
+        ]
+            event, values = prompt(layout=layout, add_ok_cancel=False)
+            if event == "Yes" :
+                return None, None, user_parameters
+        else :
+            break
+
+
+        
+    user_parameters.update(values)
+    return cytoplasm_label, nucleus_label, user_parameters
+
+def cell_segmentation(image, cyto_model_name, nucleus_model_name, channels, cyto_diameter, nucleus_diameter, do_only_nuc=False) :
+
+    nuc_channel = channels[1]
+    if not do_only_nuc : 
+        cyto_channel = channels[0]
+        if image[cyto_channel].ndim >= 3 :
+            cyto = stack.maximum_projection(image[cyto_channel])
+        else : 
+            cyto = image[cyto_channel]
+
+    if image[nuc_channel].ndim >= 3 :
+        nuc = stack.maximum_projection(image[nuc_channel])
+    else : 
+        nuc = image[nuc_channel]
+    
+    if not do_only_nuc :
+        image = np.zeros(shape=(2,) + cyto.shape)
+        image[0] = cyto
+        image[1] = nuc
+        image = np.moveaxis(image, source=(0,1,2), destination=(2,0,1))
+
+    nuc_label = _segmentate_object(nuc, nucleus_model_name, nucleus_diameter, [0,0])
+    if not do_only_nuc :
+        cytoplasm_label = _segmentate_object(image, cyto_model_name, cyto_diameter, [1,2])
+        nuc_label, cytoplasm_label = multistack.match_nuc_cell(nuc_label=nuc_label, cell_label=cytoplasm_label, single_nuc=True, cell_alone=False)
+    else :
+        cytoplasm_label = nuc_label
+
+    return cytoplasm_label, nuc_label
+
+def _segmentate_object(im, model_name, object_size_px, channels = [0,0]) :
+
+    model = models.CellposeModel(
+        gpu= use_gpu(),
+        model_type= model_name,
+    )
+
+    label = model.eval(
+        im,
+        diameter= object_size_px,
+        channels= channels,
+        do_3D= False,
+        )[0]
+    label = np.array(label, dtype= np.int64)
+    label = remove_disjoint(label)
+    
+    return label
+
+def _cast_segmentation_parameters(values) :
+
+    if values['cyto_model_name'] == '' :
+        values['cyto_model_name'] = None
+
+    if values['nucleus_model_name'] == '' :
+        values['nucleus_model_name'] = None
+
+    try : #cytoplasm channel
+        values['cytoplasm channel'] = int(values['cytoplasm channel'])
+    except ValueError :
+        pass
+
+    try : #nucleus channel
+        values['nucleus channel'] = int(values['nucleus channel'])
+    except ValueError :
+        pass
+
+    try : #object size
+        values['cytoplasm diameter'] = float(values['cytoplasm diameter'])
+    except ValueError :
+        pass
+
+    try : #object size
+        values['nucleus diameter'] = float(values['nucleus diameter'])
+    except ValueError :
+        pass
+    
+    return values
+
+def remove_disjoint(image):
+    """
+    *CODE FROM BIG-FISH (LICENCE IN __INIT__.PY) IMPORTED TO AVOID IMPORT ERROR WHEN BIGFISH SEGMENTATION MODULE INITIALISES : try to import deprecated module for python 3.8
+
+    For each instances with disconnected parts, keep the larger one.
+
+    Parameters
+    ----------
+    image : np.ndarray, np.int, np.uint or bool
+        Labelled image with shape (z, y, x) or (y, x).
+
+    Returns
+    -------
+    image_cleaned : np.ndarray, np.int or np.uint
+        Cleaned image with shape (z, y, x) or (y, x).
+
+    """
+    # check parameters
+    stack.check_array(
+        image,
+        ndim=[2, 3],
+        dtype=[np.uint8, np.uint16, np.int32, np.int64, bool])
+
+    # handle boolean array
+    cast_to_bool = False
+    if image.dtype == bool:
+        cast_to_bool = bool
+        image = image.astype(np.uint8)
+
+    # initialize cleaned labels
+    image_cleaned = np.zeros_like(image)
+
+    # loop over instances
+    max_label = image.max()
+    for i in range(1, max_label + 1):
+
+        # get instance mask
+        mask = image == i
+
+        # check if an instance is labelled with this value
+        if mask.sum() == 0:
+            continue
+
+        # get an index for each disconnected part of the instance
+        labelled_mask = label(mask)
+        indices = sorted(list(set(labelled_mask.ravel())))
+        if 0 in indices:
+            indices = indices[1:]
+
+        # keep the largest part of the instance
+        max_area = 0
+        mask_instance = None
+        for j in indices:
+            mask_part_j = labelled_mask == j
+            area_j = mask_part_j.sum()
+            if area_j > max_area:
+                max_area = area_j
+                mask_instance = mask_part_j
+
+        # add instance in the final label
+        image_cleaned[mask_instance] = i
+
+    if cast_to_bool:
+        image_cleaned = image_cleaned.astype(bool)
+
+    return image_cleaned

small_fish_gui/pipeline/_signaltonoise.py

@@ -0,0 +1,219 @@
+"""
+Signal to noise wrapper from BigFish code.
+"""
+
+
+# ### SNR ###
+import bigfish.stack as stack
+import numpy as np
+from bigfish.detection.utils import get_object_radius_pixel, get_spot_volume, get_spot_surface
+
+def compute_snr_spots(image, spots, voxel_size, spot_radius):
+    """
+    Modified version of bigfish.detection.utils compute_snr_spots : 
+    # Author: Arthur Imbert <arthur.imbert.pro@gmail.com>
+    # License: BSD 3 clause
+    
+    Compute signal-to-noise ratio (SNR) based on spot coordinates.
+
+    .. math::
+
+        \\mbox{SNR} = \\frac{\\mbox{max(spot signal)} -
+        \\mbox{mean(background)}}{\\mbox{std(background)}}
+
+    Background is a region twice larger surrounding the spot region. Only the
+    y and x dimensions are taking into account to compute the SNR.
+
+    Parameters
+    ----------
+    image : np.ndarray
+        Image with shape (z, y, x) or (y, x).
+    spots : np.ndarray
+        Coordinate of the spots, with shape (nb_spots, 3) or (nb_spots, 2).
+        One coordinate per dimension (zyx or yx coordinates).
+    voxel_size : int, float, Tuple(int, float), List(int, float) or None
+        Size of a voxel, in nanometer. One value per spatial dimension (zyx or
+        yx dimensions). If it's a scalar, the same value is applied to every
+        dimensions. Not used if 'log_kernel_size' and 'minimum_distance' are
+        provided.
+    spot_radius : int, float, Tuple(int, float), List(int, float) or None
+        Radius of the spot, in nanometer. One value per spatial dimension (zyx
+        or yx dimensions). If it's a scalar, the same radius is applied to
+        every dimensions. Not used if 'log_kernel_size' and 'minimum_distance'
+        are provided.
+
+    Returns
+    -------
+    res : dict
+        Median signal-to-noise ratio computed for every spots.
+        +
+            'snr_median' : np.median(snr_spots),
+            'snr_mean' : np.mean(snr_spots),
+            'snr_std' : np.std(snr_spots),
+            'cell_medianbackground_mean' : np.mean(median_background_list),
+            'cell_medianbackground_std' : np.std(median_background_list),
+            'cell_meanbackground_mean'  : np.mean(mean_background_list),
+            'cell_meanbackground_std'  : np.std(mean_background_list),
+            'cell_stdbackground_mean' : np.mean(std_background_list),
+            'cell_stdbackground_std' : np.std(std_background_list)
+
+    """
+    # check parameters
+    stack.check_array(
+        image,
+        ndim=[2, 3],
+        dtype=[np.uint8, np.uint16, np.float32, np.float64])
+    stack.check_range_value(image, min_=0)
+    stack.check_array(
+        spots,
+        ndim=2,
+        dtype=[np.float32, np.float64, np.int32, np.int64])
+    stack.check_parameter(
+        voxel_size=(int, float, tuple, list),
+        spot_radius=(int, float, tuple, list))
+
+    # check consistency between parameters
+    ndim = image.ndim
+    if ndim != spots.shape[1]:
+        raise ValueError("Provided image has {0} dimensions but spots are "
+                         "detected in {1} dimensions."
+                         .format(ndim, spots.shape[1]))
+    if isinstance(voxel_size, (tuple, list)):
+        if len(voxel_size) != ndim:
+            raise ValueError(
+                "'voxel_size' must be a scalar or a sequence with {0} "
+                "elements.".format(ndim))
+    else:
+        voxel_size = (voxel_size,) * ndim
+    if isinstance(spot_radius, (tuple, list)):
+        if len(spot_radius) != ndim:
+            raise ValueError(
+                "'spot_radius' must be a scalar or a sequence with {0} "
+                "elements.".format(ndim))
+    else:
+        spot_radius = (spot_radius,) * ndim
+
+    # cast spots coordinates if needed
+    if spots.dtype == np.float64:
+        spots = np.round(spots).astype(np.int64)
+
+    # cast image if needed
+    image_to_process = image.copy().astype(np.float64)
+
+    # clip coordinate if needed
+    if ndim == 3:
+        spots[:, 0] = np.clip(spots[:, 0], 0, image_to_process.shape[0] - 1)
+        spots[:, 1] = np.clip(spots[:, 1], 0, image_to_process.shape[1] - 1)
+        spots[:, 2] = np.clip(spots[:, 2], 0, image_to_process.shape[2] - 1)
+    else:
+        spots[:, 0] = np.clip(spots[:, 0], 0, image_to_process.shape[0] - 1)
+        spots[:, 1] = np.clip(spots[:, 1], 0, image_to_process.shape[1] - 1)
+
+    # compute radius used to crop spot image
+    radius_pixel = get_object_radius_pixel(
+        voxel_size_nm=voxel_size,
+        object_radius_nm=spot_radius,
+        ndim=ndim)
+    radius_signal_ = [np.sqrt(ndim) * r for r in radius_pixel]
+    radius_signal_ = tuple(radius_signal_)
+
+    # compute the neighbourhood radius
+    radius_background_ = tuple(i * 2 for i in radius_signal_)
+
+    # ceil radii
+    radius_signal = np.ceil(radius_signal_).astype(int)
+    radius_background = np.ceil(radius_background_).astype(int)
+
+    # loop over spots
+    snr_spots = []
+    median_background_list = []
+    mean_background_list = []
+    std_background_list = []
+    
+
+    for spot in spots:
+
+        # extract spot images
+        spot_y = spot[ndim - 2]
+        spot_x = spot[ndim - 1]
+        radius_signal_yx = radius_signal[-1]
+        radius_background_yx = radius_background[-1]
+        edge_background_yx = radius_background_yx - radius_signal_yx
+        if ndim == 3:
+            spot_z = spot[0]
+            radius_background_z = radius_background[0]
+            max_signal = image_to_process[spot_z, spot_y, spot_x]
+            spot_background_, _ = get_spot_volume(
+                image_to_process, spot_z, spot_y, spot_x,
+                radius_background_z, radius_background_yx)
+            spot_background = spot_background_.copy()
+
+            # discard spot if cropped at the border (along y and x dimensions)
+            expected_size = (2 * radius_background_yx + 1) ** 2
+            actual_size = spot_background.shape[1] * spot_background.shape[2]
+            if expected_size != actual_size:
+                continue
+
+            # remove signal from background crop
+            spot_background[:,
+                            edge_background_yx:-edge_background_yx,
+                            edge_background_yx:-edge_background_yx] = -1
+            spot_background = spot_background[spot_background >= 0]
+
+        else:
+            max_signal = image_to_process[spot_y, spot_x]
+            spot_background_, _ = get_spot_surface(
+                image_to_process, spot_y, spot_x, radius_background_yx)
+            spot_background = spot_background_.copy()
+
+            # discard spot if cropped at the border
+            expected_size = (2 * radius_background_yx + 1) ** 2
+            if expected_size != spot_background.size:
+                continue
+
+            # remove signal from background crop
+            spot_background[edge_background_yx:-edge_background_yx,
+                            edge_background_yx:-edge_background_yx] = -1
+            spot_background = spot_background[spot_background >= 0]
+
+        # compute mean background
+        median_background = np.median(spot_background)
+        mean_background = np.mean(spot_background)
+
+        # compute standard deviation background
+        std_background = np.std(spot_background)
+
+        # compute SNR
+        snr = (max_signal - mean_background) / std_background
+        snr_spots.append(snr)
+        median_background_list.append(median_background)
+        mean_background_list.append(mean_background)
+        std_background_list.append(std_background)
+
+    #  average SNR
+    if len(snr_spots) == 0:
+        res = {
+            'snr_median' : 0,
+            'snr_mean' : 0,
+            'snr_std' : 0,
+            'cell_medianbackground_mean' : 0,
+            'cell_medianbackground_std' : 0,
+            'cell_meanbackground_mean'  : 0,
+            'cell_meanbackground_std'  : 0,
+            'cell_stdbackground_mean' : 0,
+            'cell_stdbackground_std' : 0
+        }
+    else:
+        res = {
+            'snr_median' : np.median(snr_spots),
+            'snr_mean' : np.mean(snr_spots),
+            'snr_std' : np.std(snr_spots),
+            'cell_medianbackground_mean' : np.mean(median_background_list),
+            'cell_medianbackground_std' : np.std(median_background_list),
+            'cell_meanbackground_mean'  : np.mean(mean_background_list),
+            'cell_meanbackground_std'  : np.std(mean_background_list),
+            'cell_stdbackground_mean' : np.mean(std_background_list),
+            'cell_stdbackground_std' : np.std(std_background_list)
+        }
+
+    return res

small_fish_gui/pipeline/actions.py

@@ -0,0 +1,127 @@
+from ..gui.prompts import output_image_prompt, ask_detection_confirmation, ask_cancel_detection
+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
+
+import pandas as pd
+import PySimpleGUI as sg
+
+def add_detection(user_parameters, segmentation_done, acquisition_id, cytoplasm_label, nucleus_label) :
+    """
+    #TODO : list all keys added to user_parameters when returned
+    """
+
+    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
+    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
+    else :
+        user_parameters.update(new_parameters)
+
+    map = map_channels(user_parameters)
+    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)
+
+    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
+
+    #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,
+            shape = user_parameters['image'].shape
+            )
+
+        if type(detection_parameters) != type(None) :
+            user_parameters.update(detection_parameters) 
+        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
+            else : continue
+
+        acquisition_id += 1
+        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
+            user_parameters, frame_result, spots, clusters = launch_detection(
+                image,
+                other_image,
+                user_parameters,
+                cell_label=cytoplasm_label,
+                nucleus_label=nucleus_label
+            )
+
+        except ValueError as error :
+            if "The array should have an upper bound of 1" in str(error) :
+                sg.popup("Spot size too small for current voxel size.")
+                continue
+            else :
+                raise(error)
+
+
+        if user_parameters['Napari correction'] :
+            if ask_detection_confirmation(user_parameters.get('threshold')) : break
+        else :
+            break
+        
+    #Features computation
+    new_results_df, new_cell_results_df = launch_features_computation(
+    acquisition_id=acquisition_id,
+    image=image,
+    nucleus_signal = nucleus_signal,
+    spots=spots,
+    clusters=clusters,
+    nucleus_label = nucleus_label,
+    cell_label= cytoplasm_label,
+    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
+
+def save_results(result_df, cell_result_df, coloc_df) :
+    if len(result_df) != 0 :
+        dic = output_image_prompt(filename=result_df.iloc[0].at['filename'])
+
+        if isinstance(dic, dict) :
+            path = dic['folder']
+            filename = dic['filename']
+            do_excel = dic['Excel']
+            do_feather = dic['Feather']
+            sucess1 = write_results(result_df, path= path, filename=filename, do_excel= do_excel, do_feather= do_feather)
+            sucess2 = write_results(cell_result_df, path= path, filename=filename + '_cell_result', do_excel= do_excel, do_feather= do_feather)
+            sucess3 = write_results(coloc_df, path= path, filename=filename + '_coloc_result', do_excel= do_excel, do_feather= do_feather)
+            if sucess1 and sucess2 and sucess3 : sg.popup("Sucessfully saved at {0}.".format(path))
+
+    else :
+        dic = None
+        sg.popup('No results to save.') 
+
+def compute_colocalisation(result_tables, result_dataframe) :
+    colocalisation_distance = initiate_colocalisation(result_tables)
+
+    if colocalisation_distance == False :
+        res_coloc = pd.DataFrame() # popup handled in initiate_colocalisation
+    else :
+        res_coloc = launch_colocalisation(result_tables, result_dataframe=result_dataframe, colocalisation_distance=colocalisation_distance)
+
+    return res_coloc